diff --git a/cmake/libakantu/v3/printers.py b/cmake/libakantu/v3/printers.py
index 935520947..381d24368 100755
--- a/cmake/libakantu/v3/printers.py
+++ b/cmake/libakantu/v3/printers.py
@@ -1,228 +1,230 @@
 #!/usr/bin/env python
 # encoding: utf-8
 #
 # Inspired from boost's pretty printers from
 # Rüdiger Sonderfeld <ruediger@c-plusplus.de>
 # and from Pretty-printers for libstc++ from Free Software Foundation, Inc.
 #
 
 import gdb
 import re
+import sys
 # import libstdcxx.v6.printers as std
 
 __use_gdb_pp__ = True
 try:
     import gdb.printing
 except ImportError:
     __use_gdb_pp__ = False
 
 
 class AkantuPrinter(object):
     regex = None
 
     @classmethod
     def supports(cls, typename):
+        print('{0} ~= {1}'.format(typename, cls.regex), file=sys.stderr)
         return cls.regex.search(typename)
 
     @classmethod
     def get_basic_type(cls, value):
         """ Determines the type associated to a value"""
 
         _type = value.type
         # If it points to a reference, get the reference.
         if _type.code == gdb.TYPE_CODE_REF:
             _type = _type.target()
 
         # Get the unqualified type, stripped of typedefs.
         _type = _type.unqualified().strip_typedefs()
 
         return _type.tag
 
 if __use_gdb_pp__:
     __akantu_pretty_printers__ = \
         gdb.printing.RegexpCollectionPrettyPrinter("libakantu-v3")
 else:
     class AkantuPrettyPrinters(object):
         def __init__(self, name):
             super(AkantuPrettyPrinters, self).__init__()
             self.name = name
             self.printers = {}
 
         def add_printer(self, name, regex, printer):
             self.printers[name] = printer
 
         def __call__(self, val):
             typename = AkantuPrinter.get_basic_type(val)
             if not typename:
                 return None
 
             for name, printer in self.printers.iteritems():
                 if(printer.supports(typename)):
                     return printer
 
             return None
 
     __akantu_pretty_printers__ = AkantuPrettyPrinters("libakantu-v3")
 
 
 def register_pretty_printer(pretty_printer):
     "Registers a Pretty Printer"
 
     __akantu_pretty_printers__.add_printer(pretty_printer.name,
                                            pretty_printer.regex,
                                            pretty_printer)
 
     return pretty_printer
 
 @register_pretty_printer
 class AkaArrayPrinter(AkantuPrinter):
     """Pretty printer for akantu::Array<T>"""
     regex = re.compile('^akantu::Array<(.*?), (true|false)>$')
     name = 'akantu::Array'
 
     def __init__(self, value):
         self.typename = self.get_basic_type(value)
         self.value = value
         self.ptr = self.value['values']
-        self.size = int(self.value['size'])
+        self.size = int(self.value['size_'])
         self.nb_component = int(self.value['nb_component'])
 
     def display_hint(self):
         return 'array'
 
     def to_string(self):
         m = self.regex.search(self.typename)
         return 'Array<{0}>({1}, {2}) stored at {3}'.format(
             m.group(1), self.size, self.nb_component, self.ptr)
 
     def children(self):
         _ptr = self.ptr
         for i in range(self.size):
             _values = ["{0}".format((_ptr + j).dereference())
                        for j in range(self.nb_component)]
             _ptr = _ptr + self.nb_component
             yield ('[{0}]'.format(i),
                    ('{0}' if self.nb_component == 1 else '[{0}]').format(
                        ', '.join(_values)))
 
-@register_pretty_printer
-class AkaArrayIteratorPrinter(AkantuPrinter):
-    """Pretty printer for akantu::Array<T>"""
-    regex = re.compile('^akantu::Array<(.*?), (true|false)>::internal_iterator<(.*?), (.*?), (false|true)>$')
-    name = 'akantu::Array::iterator'
-
-    def __init__(self, value):
-        self.typename = self.get_basic_type(value)
-        self.value = value
-        self.ret = self.value['ret'].dereference()
-
-    def to_string(self):
-        m = self.regex.search(self.typename)
-        return 'Array<{0}>::iterator<{3}>'.format(
-            m.group(1), m.group(1))
-
-    def children(self):
-        yield ('[data]', self.ret)
+# @register_pretty_printer
+# class AkaArrayIteratorPrinter(AkantuPrinter):
+#     """Pretty printer for akantu::Array<T>"""
+#     regex = re.compile('^akantu::Array<(.*?), (true|false)>::internal_iterator<(.*?), (.*?), (false|true)>$')
+#     name = 'akantu::Array::iterator'
+
+#     def __init__(self, value):
+#         self.typename = self.get_basic_type(value)
+#         self.value = value
+#         self.ret = self.value['ret'].dereference()
+
+#     def to_string(self):
+#         m = self.regex.search(self.typename)
+#         return 'Array<{0}>::iterator<{3}>'.format(
+#             m.group(1), m.group(1))
+
+#     def children(self):
+#         yield ('[data]', self.ret)
 
 
 # @register_pretty_printer
 class AkaTensorPrinter(AkantuPrinter):
     """Pretty printer for akantu::Tensor<T>"""
     regex = re.compile('^akantu::Tensor<(.*), +(.*), +(.*)>$')
     name = 'akantu::Tensor'
 
     value = None
     typename = ""
     ptr = None
     dims = []
     ndims = 0
 
     def pretty_print(self):
         def ij2str(i, j, m):
             return "{0}".format((self.ptr+m*j + i).dereference())
 
         def line(i, m, n):
             return "[{0}]".format(", ".join((ij2str(i, j, m) for j in
                                              range(n))))
 
         m = int(self.dims[0])
         if (self.ndims == 1):
             n = 1
         else:
             n = int(self.dims[1])
 
         return "[{0}]".format(", ".join(line(i, m, n) for i in range(m)))
 
     def __init__(self, value):
         self.typename = self.get_basic_type(value)
         self.value = value
         self.ptr = self.value['values']
         self.dims = self.value['n']
 
     def children(self):
         yield ('values', self.pretty_print())
         yield ('wrapped', self.value['wrapped'])
 
 @register_pretty_printer
 class AkaVectorPrinter(AkaTensorPrinter):
     """Pretty printer for akantu::Vector<T>"""
     regex = re.compile('^akantu::Vector<(.*)>$')
     name = 'akantu::Vector'
     n = 0
     ptr = 0x0
 
     def __init__(self, value):
         super(AkaVectorPrinter, self).__init__(value)
         self.ndims = 1
 
     def to_string(self):
         m = self.regex.search(self.typename)
         return 'Vector<{0}>({1}) [{2}]'.format(m.group(1), int(self.dims[0]),
                                                str(self.ptr))
 
 
 @register_pretty_printer
 class AkaMatrixPrinter(AkaTensorPrinter):
     """Pretty printer for akantu::Matrix<T>"""
     regex = re.compile('^akantu::Matrix<(.*)>$')
     name = 'akantu::Matrix'
 
     def __init__(self, value):
         super(AkaMatrixPrinter, self).__init__(value)
         self.ndims = 2
 
     def to_string(self):
         m = self.regex.search(self.typename)
         return 'Matrix<%s>(%d, %d) [%s]' % (m.group(1), int(self.dims[0]),
                                             int(self.dims[1]),
                                             str(self.ptr))
 
 
 @register_pretty_printer
 class AkaElementPrinter(AkantuPrinter):
     """Pretty printer for akantu::Element"""
     regex = re.compile('^akantu::Element$')
     name = 'akantu::Element'
 
     def __init__(self, value):
         self.typename = self.get_basic_type(value)
         self.value = value
 
         self.element = self.value['element']
         self.eltype = self.value['type']
         self.ghost_type = self.value['ghost_type']
 
     def to_string(self):
         return 'Element({0}, {1}, {2})'.format(self.element, self.eltype,
                                                self.ghost_type)
 
 
 def register_akantu_printers(obj):
     "Register Akantu Pretty Printers."
 
     if __use_gdb_pp__:
         gdb.printing.register_pretty_printer(obj, __akantu_pretty_printers__)
     else:
         if obj is None:
             obj = gdb
         obj.pretty_printers.append(__akantu_pretty_printers__)
diff --git a/examples/cohesive_element/cohesive_intrinsic/cohesive_intrinsic.cc b/examples/cohesive_element/cohesive_intrinsic/cohesive_intrinsic.cc
index 3ebb7d77c..ac7619f48 100644
--- a/examples/cohesive_element/cohesive_intrinsic/cohesive_intrinsic.cc
+++ b/examples/cohesive_element/cohesive_intrinsic/cohesive_intrinsic.cc
@@ -1,157 +1,157 @@
 /**
  * @file   cohesive_intrinsic.cc
  *
  * @author Seyedeh Mohadeseh Taheri Mousavi <mohadeseh.taherimousavi@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Mon Jan 18 2016
  *
  * @brief  Test for cohesive elements
  *
  * @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_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 static void updateDisplacement(SolidMechanicsModelCohesive &, Array<UInt> &,
                                ElementType, Real);
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize("material.dat", argc, argv);
 
   const UInt spatial_dimension = 2;
   const UInt max_steps = 350;
 
   const ElementType type = _triangle_6;
 
   Mesh mesh(spatial_dimension);
   mesh.read("triangle.msh");
 
   CohesiveElementInserter inserter(mesh);
   inserter.setLimit(_x, -0.26, -0.24);
   inserter.insertIntrinsicElements();
 
   SolidMechanicsModelCohesive model(mesh);
 
   /// model initialization
   model.initFull();
 
   Real time_step = model.getStableTimeStep() * 0.8;
   model.setTimeStep(time_step);
   std::cout << "Time step: " << time_step << std::endl;
 
   Array<bool> & boundary = model.getBlockedDOFs();
 
   UInt nb_nodes = mesh.getNbNodes();
   UInt nb_element = mesh.getNbElement(type);
 
   /// boundary conditions
   for (UInt dim = 0; dim < spatial_dimension; ++dim) {
     for (UInt n = 0; n < nb_nodes; ++n) {
       boundary(n, dim) = true;
     }
   }
 
   model.updateResidual();
 
   model.setBaseName("intrinsic");
   model.addDumpFieldVector("displacement");
   model.addDumpField("velocity");
   model.addDumpField("acceleration");
   model.addDumpField("residual");
   model.addDumpField("stress");
   model.addDumpField("grad_u");
   model.addDumpField("force");
   model.dump();
 
   /// update displacement
   Array<UInt> elements;
   Real * bary = new Real[spatial_dimension];
   for (UInt el = 0; el < nb_element; ++el) {
     mesh.getBarycenter(el, type, bary);
     if (bary[0] > -0.25)
       elements.push_back(el);
   }
   delete[] bary;
 
   Real increment = 0.01;
 
   updateDisplacement(model, elements, type, increment);
 
   /// Main loop
   for (UInt s = 1; s <= max_steps; ++s) {
     model.solveStep();
 
     updateDisplacement(model, elements, type, increment);
 
     if (s % 1 == 0) {
       model.dump();
       std::cout << "passing step " << s << "/" << max_steps << std::endl;
     }
   }
 
   Real Ed = model.getEnergy("dissipated");
 
   Real Edt = 2 * sqrt(2);
 
   std::cout << Ed << " " << Edt << std::endl;
 
   if (Ed < Edt * 0.999 || Ed > Edt * 1.001 || std::isnan(Ed)) {
     std::cout << "The dissipated energy is incorrect" << std::endl;
     return EXIT_FAILURE;
   }
 
   finalize();
 
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
 static void updateDisplacement(SolidMechanicsModelCohesive & model,
                                Array<UInt> & elements, ElementType type,
                                Real increment) {
   Mesh & mesh = model.getMesh();
-  UInt nb_element = elements.getSize();
+  UInt nb_element = elements.size();
   UInt nb_nodes = mesh.getNbNodes();
   UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
   const Array<UInt> & connectivity = mesh.getConnectivity(type);
   Array<Real> & displacement = model.getDisplacement();
   Array<bool> update(nb_nodes);
   update.clear();
 
   for (UInt el = 0; el < nb_element; ++el) {
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt node = connectivity(elements(el), n);
       if (!update(node)) {
         displacement(node, 0) -= increment;
         //	displacement(node, 1) += increment;
         update(node) = true;
       }
     }
   }
 }
diff --git a/examples/implicit/implicit_dynamic.cc b/examples/implicit/implicit_dynamic.cc
index 11e9d6936..74ec51184 100644
--- a/examples/implicit/implicit_dynamic.cc
+++ b/examples/implicit/implicit_dynamic.cc
@@ -1,146 +1,146 @@
 /**
  * @file   implicit_dynamic.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  *
  * @brief  This code refers to the implicit 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 <iostream>
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 const Real bar_length = 10.;
 const Real bar_height = 1.;
 const Real bar_depth  = 1.;
 const Real F   = 5e3;
 const Real L   = bar_length;
 const Real I   = bar_depth * bar_height * bar_height * bar_height / 12.;
 const Real E   = 12e7;
 const Real rho = 1000;
 const Real m   = rho * bar_height * bar_depth;
 
 static Real w(UInt n) {
   return n*n*M_PI*M_PI/(L*L)*sqrt(E*I/m);
 }
 
 static Real analytical_solution(Real time) {
   return 2*F*L*L*L/(pow(M_PI, 4)*E*I) * ((1. - cos(w(1)*time)) + (1. - cos(w(3)*time))/81. + (1. - cos(w(5)*time))/625.);
 }
 
 const UInt spatial_dimension = 2;
 const Real time_step = 1e-4;
 const Real max_time  = 0.62;
 /* -------------------------------------------------------------------------- */
 int main(int argc, char *argv[]) {
 
   initialize("material_dynamic.dat", argc, argv);
 
   Mesh mesh(spatial_dimension);
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   MeshPartition * partition = NULL;
   if(prank == 0) {
     mesh.read("beam.msh");
     partition = new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
   }
 
   SolidMechanicsModel model(mesh);
   model.initParallel(partition);
   mesh.createGroupsFromMeshData<std::string>("physical_names");
 
   /// model initialization
   model.initFull(SolidMechanicsModelOptions(_implicit_dynamic));
   Material &mat = model.getMaterial(0);
   mat.setParam("E",   E);
   mat.setParam("rho", rho);
 
   model.getMassMatrix().saveMatrix("M.mtx");
 
   Array<Real> & force          = model.getForce();
   Array<Real> & displacment    = model.getDisplacement();
 
   // boundary conditions
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _x), "blocked");
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "blocked");
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "roller");
 
   const Array<UInt> & trac_nodes = mesh.getElementGroup("traction").getNodes();
 
   bool dump_node = false;
-  if(trac_nodes.getSize() > 0 && mesh.isLocalOrMasterNode(trac_nodes(0))) {
+  if(trac_nodes.size() > 0 && mesh.isLocalOrMasterNode(trac_nodes(0))) {
     force(trac_nodes(0), 1) = F;
     dump_node = true;
   }
 
   // output setup
   std::ofstream pos;
   pos.open("position.csv");
   if(!pos.good()) AKANTU_DEBUG_ERROR("Cannot open file \"position.csv\"");
 
   pos << "id,time,position,solution" << std::endl;
 
   model.setBaseName("dynamic");
   model.addDumpFieldVector("displacement");
   model.addDumpField("velocity"    );
   model.addDumpField("acceleration");
   model.addDumpField("force"       );
   model.addDumpField("residual"    );
   model.dump();
 
 
   model.setTimeStep(time_step);
 
   /// time loop
   Real time = 0.;
   for (UInt s = 1; time < max_time; ++s, time += time_step) {
     if(prank == 0)
       std::cout << s << "\r" << std::flush;
 
     model.solveStep<_scm_newton_raphson_tangent_modified, _scc_increment>(1e-12, 100);
 
     if(dump_node)
       pos << s << ","
           << time << ","
           << displacment(trac_nodes(0),  1) << ","
           << analytical_solution(s*time_step) << std::endl;
 
     if(s % 100 == 0)
       model.dump();
   }
 
   std::cout << std::endl;
   pos.close();
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/examples/io/dumper/locomotive_tools.cc b/examples/io/dumper/locomotive_tools.cc
index 661ae4121..74262dc67 100644
--- a/examples/io/dumper/locomotive_tools.cc
+++ b/examples/io/dumper/locomotive_tools.cc
@@ -1,93 +1,93 @@
 /**
  * @file   locomotive_tools.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  *
  * @date creation: Mon Aug 17 2015
  * @date last modification: Mon Jan 18 2016
  *
  * @brief  Common functions for the dumper examples
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include "locomotive_tools.hh"
 /* -------------------------------------------------------------------------- */
 
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 void applyRotation(const Vector<Real> & center, Real angle,
                    const Array<Real> & nodes, Array<Real> & displacement,
                    const Array<UInt> & node_group) {
   Array<Real>::const_vector_iterator nodes_it =
       nodes.begin(nodes.getNbComponent());
   Array<Real>::vector_iterator disp_it = displacement.begin(center.size());
   Array<UInt>::const_scalar_iterator node_num_it = node_group.begin();
   Array<UInt>::const_scalar_iterator node_num_end = node_group.end();
 
   Vector<Real> pos_rel(center.size());
 
   for (; node_num_it != node_num_end; ++node_num_it) {
     const Vector<Real> pos = nodes_it[*node_num_it];
     for (UInt i = 0; i < pos.size(); ++i)
       pos_rel(i) = pos(i);
 
     Vector<Real> dis = disp_it[*node_num_it];
 
     pos_rel -= center;
     Real radius = pos_rel.norm();
 
     if (std::abs(radius) < Math::getTolerance())
       continue;
 
     Real phi_i = std::acos(pos_rel(_x) / radius);
     if (pos_rel(_y) < 0)
       phi_i *= -1;
 
     dis(_x) = std::cos(phi_i - angle) * radius - pos_rel(_x);
     dis(_y) = std::sin(phi_i - angle) * radius - pos_rel(_y);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void fillColour(const Mesh & mesh, ElementTypeMapArray<UInt> & colour) {
   const ElementTypeMapArray<std::string> & phys_data =
       mesh.getData<std::string>("physical_names");
   const Array<std::string> & txt_colour = phys_data(_triangle_3);
   Array<UInt> & id_colour = colour(_triangle_3);
 
-  for (UInt i = 0; i < txt_colour.getSize(); ++i) {
+  for (UInt i = 0; i < txt_colour.size(); ++i) {
     std::string phy_name = txt_colour(i);
 
     if (phy_name == "red")
       id_colour(i) = 3;
     else if (phy_name == "white" || phy_name == "lwheel_1" ||
              phy_name == "rwheel_1")
       id_colour(i) = 2;
     else
       id_colour(i) = 1;
   }
 }
diff --git a/packages/core.cmake b/packages/core.cmake
index 412e427e8..db811ce57 100644
--- a/packages/core.cmake
+++ b/packages/core.cmake
@@ -1,592 +1,593 @@
 #===============================================================================
 # @file   core.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Nov 21 2011
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  package description for core
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 package_declare(core NOT_OPTIONAL
   DESCRIPTION "core package for Akantu"
   FEATURES_PUBLIC cxx_strong_enums cxx_defaulted_functions cxx_deleted_functions
   cxx_auto_type cxx_decltype_auto
   FEATURES_PRIVATE cxx_lambdas cxx_nullptr cxx_delegated_constructors
   cxx_range_for )
 
 package_declare_sources(core
   common/aka_array.cc
   common/aka_array.hh
   common/aka_array_tmpl.hh
   common/aka_blas_lapack.hh
   common/aka_circular_array.hh
   common/aka_circular_array_inline_impl.cc
   common/aka_common.cc
   common/aka_common.hh
   common/aka_common_inline_impl.cc
   common/aka_csr.hh
   common/aka_element_classes_info_inline_impl.cc
   common/aka_error.cc
   common/aka_error.hh
   common/aka_event_handler_manager.hh
   common/aka_extern.cc
   common/aka_factory.hh
   common/aka_fwd.hh
   common/aka_grid_dynamic.hh
   common/aka_math.cc
   common/aka_math.hh
   common/aka_math_tmpl.hh
   common/aka_memory.cc
   common/aka_memory.hh
   common/aka_memory_inline_impl.cc
   common/aka_named_argument.hh
   common/aka_random_generator.hh
   common/aka_safe_enum.hh
   common/aka_static_memory.cc
   common/aka_static_memory.hh
   common/aka_static_memory_inline_impl.cc
   common/aka_static_memory_tmpl.hh
   common/aka_typelist.hh
   common/aka_types.hh
   common/aka_visitor.hh
   common/aka_voigthelper.hh
   common/aka_voigthelper_tmpl.hh
   common/aka_voigthelper.cc
   common/aka_warning.hh
   common/aka_warning_restore.hh
   common/aka_iterators.hh
+  common/aka_static_if.hh
 
   fe_engine/element_class.cc
   fe_engine/element_class.hh
   fe_engine/element_class_tmpl.hh
   fe_engine/element_classes/element_class_hexahedron_8_inline_impl.cc
   fe_engine/element_classes/element_class_hexahedron_20_inline_impl.cc
   fe_engine/element_classes/element_class_pentahedron_6_inline_impl.cc
   fe_engine/element_classes/element_class_pentahedron_15_inline_impl.cc
   fe_engine/element_classes/element_class_point_1_inline_impl.cc
   fe_engine/element_classes/element_class_quadrangle_4_inline_impl.cc
   fe_engine/element_classes/element_class_quadrangle_8_inline_impl.cc
   fe_engine/element_classes/element_class_segment_2_inline_impl.cc
   fe_engine/element_classes/element_class_segment_3_inline_impl.cc
   fe_engine/element_classes/element_class_tetrahedron_10_inline_impl.cc
   fe_engine/element_classes/element_class_tetrahedron_4_inline_impl.cc
   fe_engine/element_classes/element_class_triangle_3_inline_impl.cc
   fe_engine/element_classes/element_class_triangle_6_inline_impl.cc
   fe_engine/element_type_conversion.hh
 
   fe_engine/fe_engine.cc
   fe_engine/fe_engine.hh
   fe_engine/fe_engine_inline_impl.cc
   fe_engine/fe_engine_template.hh
   fe_engine/fe_engine_template_tmpl_field.hh
   fe_engine/fe_engine_template_tmpl.hh
   fe_engine/geometrical_element.cc
   fe_engine/gauss_integration.cc
   fe_engine/gauss_integration_tmpl.hh
   fe_engine/integrator.hh
   fe_engine/integrator_gauss.hh
   fe_engine/integrator_gauss_inline_impl.cc
   fe_engine/interpolation_element.cc
   fe_engine/interpolation_element_tmpl.hh
   fe_engine/integration_point.hh
   fe_engine/shape_functions.hh
   fe_engine/shape_functions.cc
   fe_engine/shape_functions_inline_impl.cc
   fe_engine/shape_lagrange_base.cc
   fe_engine/shape_lagrange_base.hh
   fe_engine/shape_lagrange_base_inline_impl.cc
   fe_engine/shape_lagrange.cc
   fe_engine/shape_lagrange.hh
   fe_engine/shape_lagrange_inline_impl.cc
   fe_engine/shape_linked.cc
   fe_engine/shape_linked.hh
   fe_engine/shape_linked_inline_impl.cc
   fe_engine/element.hh
 
   io/dumper/dumpable.hh
   io/dumper/dumpable.cc
   io/dumper/dumpable_dummy.hh
   io/dumper/dumpable_inline_impl.hh
   io/dumper/dumper_field.hh
   io/dumper/dumper_material_padders.hh
   io/dumper/dumper_filtered_connectivity.hh
   io/dumper/dumper_element_partition.hh
 
   io/mesh_io.cc
   io/mesh_io.hh
   io/mesh_io/mesh_io_abaqus.cc
   io/mesh_io/mesh_io_abaqus.hh
   io/mesh_io/mesh_io_diana.cc
   io/mesh_io/mesh_io_diana.hh
   io/mesh_io/mesh_io_msh.cc
   io/mesh_io/mesh_io_msh.hh
   io/model_io.cc
   io/model_io.hh
 
   io/parser/algebraic_parser.hh
   io/parser/input_file_parser.hh
   io/parser/parsable.cc
   io/parser/parsable.hh
   io/parser/parsable_tmpl.hh
   io/parser/parser.cc
   io/parser/parser_real.cc
   io/parser/parser_random.cc
   io/parser/parser_types.cc
   io/parser/parser_input_files.cc
   io/parser/parser.hh
   io/parser/parser_tmpl.hh
   io/parser/parser_grammar_tmpl.hh
   io/parser/cppargparse/cppargparse.hh
   io/parser/cppargparse/cppargparse.cc
   io/parser/cppargparse/cppargparse_tmpl.hh
 
   io/parser/parameter_registry.cc
   io/parser/parameter_registry.hh
   io/parser/parameter_registry_tmpl.hh
 
   mesh/element_group.cc
   mesh/element_group.hh
   mesh/element_group_inline_impl.cc
   mesh/element_type_map.cc
   mesh/element_type_map.hh
   mesh/element_type_map_tmpl.hh
   mesh/element_type_map_filter.hh
   mesh/group_manager.cc
   mesh/group_manager.hh
   mesh/group_manager_inline_impl.cc
   mesh/mesh.cc
   mesh/mesh.hh
   mesh/mesh_accessor.hh
   mesh/mesh_accessor.cc
   mesh/mesh_events.hh
   mesh/mesh_filter.hh
   mesh/mesh_data.cc
   mesh/mesh_data.hh
   mesh/mesh_data_tmpl.hh
   mesh/mesh_inline_impl.cc
   mesh/node_group.cc
   mesh/node_group.hh
   mesh/node_group_inline_impl.cc
   mesh/mesh_iterators.hh
 
   mesh_utils/mesh_partition.cc
   mesh_utils/mesh_partition.hh
   mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
   mesh_utils/mesh_partition/mesh_partition_mesh_data.hh
   mesh_utils/mesh_partition/mesh_partition_scotch.hh
   mesh_utils/mesh_utils_pbc.cc
   mesh_utils/mesh_utils.cc
   mesh_utils/mesh_utils.hh
   mesh_utils/mesh_utils_distribution.cc
   mesh_utils/mesh_utils_distribution.hh
   mesh_utils/mesh_utils.hh
   mesh_utils/mesh_utils_inline_impl.cc
   mesh_utils/global_ids_updater.hh
   mesh_utils/global_ids_updater.cc
   mesh_utils/global_ids_updater_inline_impl.cc
 
   model/boundary_condition.hh
   model/boundary_condition_functor.hh
   model/boundary_condition_functor_inline_impl.cc
   model/boundary_condition_tmpl.hh
 
   model/common/neighborhood_base.hh
   model/common/neighborhood_base.cc
   model/common/neighborhood_base_inline_impl.cc
   model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.hh
   model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
   model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion_inline_impl.cc
   model/common/non_local_toolbox/non_local_manager.hh
   model/common/non_local_toolbox/non_local_manager.cc
   model/common/non_local_toolbox/non_local_manager_inline_impl.cc
   model/common/non_local_toolbox/non_local_manager_callback.hh
   model/common/non_local_toolbox/non_local_neighborhood_base.hh
   model/common/non_local_toolbox/non_local_neighborhood_base.cc
   model/common/non_local_toolbox/non_local_neighborhood.hh
   model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
   model/common/non_local_toolbox/non_local_neighborhood_inline_impl.cc
 
   model/dof_manager.cc
   model/dof_manager.hh
   model/dof_manager_default.cc
   model/dof_manager_default.hh
   model/dof_manager_default_inline_impl.cc
   model/dof_manager_inline_impl.cc
   model/model_solver.cc
   model/model_solver.hh
   model/model_solver_tmpl.hh
   model/non_linear_solver.cc
   model/non_linear_solver.hh
   model/non_linear_solver_default.hh
   model/non_linear_solver_lumped.cc
   model/non_linear_solver_lumped.hh
   model/solver_callback.hh
   model/solver_callback.cc
   model/time_step_solver.hh
   model/time_step_solvers/time_step_solver.cc
   model/time_step_solvers/time_step_solver_default.cc
   model/time_step_solvers/time_step_solver_default.hh
   model/time_step_solvers/time_step_solver_default_explicit.hh
   model/non_linear_solver_callback.hh
   model/time_step_solvers/time_step_solver_default_solver_callback.hh
 
   model/integration_scheme/generalized_trapezoidal.cc
   model/integration_scheme/generalized_trapezoidal.hh
   model/integration_scheme/integration_scheme.cc
   model/integration_scheme/integration_scheme.hh
   model/integration_scheme/integration_scheme_1st_order.cc
   model/integration_scheme/integration_scheme_1st_order.hh
   model/integration_scheme/integration_scheme_2nd_order.cc
   model/integration_scheme/integration_scheme_2nd_order.hh
   model/integration_scheme/newmark-beta.cc
   model/integration_scheme/newmark-beta.hh
   model/integration_scheme/pseudo_time.cc
   model/integration_scheme/pseudo_time.hh
   model/model.cc
   model/model.hh
   model/model_inline_impl.cc
 
   model/solid_mechanics/material.cc
   model/solid_mechanics/material.hh
   model/solid_mechanics/material_inline_impl.cc
   model/solid_mechanics/material_selector.hh
   model/solid_mechanics/material_selector_tmpl.hh
   model/solid_mechanics/materials/internal_field.hh
   model/solid_mechanics/materials/internal_field_tmpl.hh
   model/solid_mechanics/materials/random_internal_field.hh
   model/solid_mechanics/materials/random_internal_field_tmpl.hh
   model/solid_mechanics/solid_mechanics_model.cc
   model/solid_mechanics/solid_mechanics_model.hh
   model/solid_mechanics/solid_mechanics_model_inline_impl.cc
   model/solid_mechanics/solid_mechanics_model_io.cc
   model/solid_mechanics/solid_mechanics_model_mass.cc
   model/solid_mechanics/solid_mechanics_model_material.cc
   model/solid_mechanics/solid_mechanics_model_tmpl.hh
   model/solid_mechanics/solid_mechanics_model_event_handler.hh
   model/solid_mechanics/materials/plane_stress_toolbox.hh
   model/solid_mechanics/materials/plane_stress_toolbox_tmpl.hh
 
 
   model/solid_mechanics/materials/material_core_includes.hh
   model/solid_mechanics/materials/material_elastic.cc
   model/solid_mechanics/materials/material_elastic.hh
   model/solid_mechanics/materials/material_elastic_inline_impl.cc
   model/solid_mechanics/materials/material_thermal.cc
   model/solid_mechanics/materials/material_thermal.hh
   model/solid_mechanics/materials/material_elastic_linear_anisotropic.cc
   model/solid_mechanics/materials/material_elastic_linear_anisotropic.hh
   model/solid_mechanics/materials/material_elastic_orthotropic.cc
   model/solid_mechanics/materials/material_elastic_orthotropic.hh
   model/solid_mechanics/materials/material_damage/material_damage.hh
   model/solid_mechanics/materials/material_damage/material_damage_tmpl.hh
   model/solid_mechanics/materials/material_damage/material_marigo.cc
   model/solid_mechanics/materials/material_damage/material_marigo.hh
   model/solid_mechanics/materials/material_damage/material_marigo_inline_impl.cc
   model/solid_mechanics/materials/material_damage/material_mazars.cc
   model/solid_mechanics/materials/material_damage/material_mazars.hh
   model/solid_mechanics/materials/material_damage/material_mazars_inline_impl.cc
   model/solid_mechanics/materials/material_finite_deformation/material_neohookean.cc
   model/solid_mechanics/materials/material_finite_deformation/material_neohookean.hh
   model/solid_mechanics/materials/material_finite_deformation/material_neohookean_inline_impl.cc
   model/solid_mechanics/materials/material_plastic/material_plastic.cc
   model/solid_mechanics/materials/material_plastic/material_plastic.hh
   model/solid_mechanics/materials/material_plastic/material_plastic_inline_impl.cc
   model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening.cc
   model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening.hh
   model/solid_mechanics/materials/material_plastic/material_linear_isotropic_hardening_inline_impl.cc
   model/solid_mechanics/materials/material_viscoelastic/material_standard_linear_solid_deviatoric.cc
   model/solid_mechanics/materials/material_viscoelastic/material_standard_linear_solid_deviatoric.hh
 
   model/solid_mechanics/materials/material_non_local.hh
   model/solid_mechanics/materials/material_non_local_tmpl.hh
   model/solid_mechanics/materials/material_non_local_includes.hh
   model/solid_mechanics/materials/material_non_local_inline_impl.cc
 
   solver/sparse_solver.cc
   solver/sparse_solver.hh
   solver/sparse_solver_inline_impl.cc
   solver/sparse_matrix.cc
   solver/sparse_matrix.hh
   solver/sparse_matrix_inline_impl.cc
   solver/sparse_matrix_aij.cc
   solver/sparse_matrix_aij.hh
   solver/sparse_matrix_aij_inline_impl.cc
   solver/terms_to_assemble.hh
 
   synchronizer/communication_descriptor_tmpl.hh
   synchronizer/communications_tmpl.hh
   synchronizer/communication_buffer.hh
   synchronizer/communication_buffer_inline_impl.cc
   synchronizer/communication_descriptor.hh
   synchronizer/communication_tag.hh
   synchronizer/communications.hh
   synchronizer/data_accessor.cc
   synchronizer/data_accessor.hh
   synchronizer/element_synchronizer.cc
   synchronizer/element_synchronizer.hh
   synchronizer/node_synchronizer.cc
   synchronizer/node_synchronizer.hh
   synchronizer/dof_synchronizer.cc
   synchronizer/dof_synchronizer.hh
   synchronizer/dof_synchronizer_inline_impl.cc
   synchronizer/element_info_per_processor.cc
   synchronizer/element_info_per_processor.hh
   synchronizer/element_info_per_processor_tmpl.hh
   synchronizer/filtered_synchronizer.cc
   synchronizer/filtered_synchronizer.hh
   synchronizer/grid_synchronizer.cc
   synchronizer/grid_synchronizer.hh
   synchronizer/grid_synchronizer_tmpl.hh
   synchronizer/master_element_info_per_processor.cc
   synchronizer/node_info_per_processor.cc
   synchronizer/node_info_per_processor.hh
   synchronizer/real_static_communicator.hh
   synchronizer/slave_element_info_per_processor.cc
   synchronizer/static_communicator.cc
   synchronizer/static_communicator.hh
   synchronizer/static_communicator_dummy.hh
   synchronizer/static_communicator_inline_impl.hh
   synchronizer/synchronizer.cc
   synchronizer/synchronizer.hh
   synchronizer/synchronizer_impl.hh
   synchronizer/synchronizer_impl_tmpl.hh
   synchronizer/synchronizer_registry.cc
   synchronizer/synchronizer_registry.hh
   synchronizer/synchronizer_tmpl.hh
   )
 
 package_declare_elements(core
   ELEMENT_TYPES
   _point_1
   _segment_2
   _segment_3
   _triangle_3
   _triangle_6
   _quadrangle_4
   _quadrangle_8
   _tetrahedron_4
   _tetrahedron_10
   _pentahedron_6
   _pentahedron_15
   _hexahedron_8
   _hexahedron_20
   KIND regular
   GEOMETRICAL_TYPES
   _gt_point
   _gt_segment_2
   _gt_segment_3
   _gt_triangle_3
   _gt_triangle_6
   _gt_quadrangle_4
   _gt_quadrangle_8
   _gt_tetrahedron_4
   _gt_tetrahedron_10
   _gt_hexahedron_8
   _gt_hexahedron_20
   _gt_pentahedron_6
   _gt_pentahedron_15
   INTERPOLATION_TYPES
   _itp_lagrange_point_1
   _itp_lagrange_segment_2
   _itp_lagrange_segment_3
   _itp_lagrange_triangle_3
   _itp_lagrange_triangle_6
   _itp_lagrange_quadrangle_4
   _itp_serendip_quadrangle_8
   _itp_lagrange_tetrahedron_4
   _itp_lagrange_tetrahedron_10
   _itp_lagrange_hexahedron_8
   _itp_serendip_hexahedron_20
   _itp_lagrange_pentahedron_6
   _itp_lagrange_pentahedron_15
   GEOMETRICAL_SHAPES
   _gst_point
   _gst_triangle
   _gst_square
   _gst_prism
   GAUSS_INTEGRATION_TYPES
   _git_point
   _git_segment
   _git_triangle
   _git_tetrahedron
   _git_pentahedron
   INTERPOLATION_KIND _itk_lagrangian
   FE_ENGINE_LISTS
   gradient_on_integration_points
   interpolate_on_integration_points
   interpolate
   compute_normals_on_integration_points
   inverse_map
   contains
   compute_shapes
   compute_shapes_derivatives
   get_shapes_derivatives
   )
 
 package_declare_material_infos(core
   LIST AKANTU_CORE_MATERIAL_LIST
   INCLUDE material_core_includes.hh
   )
 
 package_declare_documentation_files(core
   manual.sty
   manual.cls
   manual.tex
   manual-macros.sty
   manual-titlepages.tex
   manual-authors.tex
   manual-introduction.tex
   manual-gettingstarted.tex
   manual-io.tex
   manual-feengine.tex
   manual-solidmechanicsmodel.tex
   manual-constitutive-laws.tex
   manual-lumping.tex
   manual-elements.tex
   manual-appendix-elements.tex
   manual-appendix-materials.tex
   manual-appendix-packages.tex
   manual-backmatter.tex
   manual-bibliography.bib
   manual-bibliographystyle.bst
 
   figures/bc_and_ic_example.pdf
   figures/boundary.pdf
   figures/boundary.svg
   figures/dirichlet.pdf
   figures/dirichlet.svg
   figures/doc_wheel.pdf
   figures/doc_wheel.svg
   figures/dynamic_analysis.png
   figures/explicit_dynamic.pdf
   figures/explicit_dynamic.svg
   figures/static.pdf
   figures/static.svg
   figures/hooke_law.pdf
   figures/hot-point-1.png
   figures/hot-point-2.png
   figures/implicit_dynamic.pdf
   figures/implicit_dynamic.svg
   figures/insertion.pdf
   figures/interpolate.pdf
   figures/interpolate.svg
   figures/problemDomain.pdf_tex
   figures/problemDomain.pdf
   figures/static_analysis.png
   figures/stress_strain_el.pdf
   figures/tangent.pdf
   figures/tangent.svg
   figures/vectors.pdf
   figures/vectors.svg
 
   figures/stress_strain_neo.pdf
   figures/visco_elastic_law.pdf
   figures/isotropic_hardening_plasticity.pdf
   figures/stress_strain_visco.pdf
 
   figures/elements/hexahedron_8.pdf
   figures/elements/hexahedron_8.svg
   figures/elements/quadrangle_4.pdf
   figures/elements/quadrangle_4.svg
   figures/elements/quadrangle_8.pdf
   figures/elements/quadrangle_8.svg
   figures/elements/segment_2.pdf
   figures/elements/segment_2.svg
   figures/elements/segment_3.pdf
   figures/elements/segment_3.svg
   figures/elements/tetrahedron_10.pdf
   figures/elements/tetrahedron_10.svg
   figures/elements/tetrahedron_4.pdf
   figures/elements/tetrahedron_4.svg
   figures/elements/triangle_3.pdf
   figures/elements/triangle_3.svg
   figures/elements/triangle_6.pdf
   figures/elements/triangle_6.svg
   figures/elements/xtemp.pdf
   )
 
 package_declare_documentation(core
   "This package is the core engine of \\akantu. It depends on:"
   "\\begin{itemize}"
   "\\item A C++ compiler (\\href{http://gcc.gnu.org/}{GCC} >= 4, or \\href{https://software.intel.com/en-us/intel-compilers}{Intel})."
   "\\item The cross-platform, open-source \\href{http://www.cmake.org/}{CMake} build system."
   "\\item The \\href{http://www.boost.org/}{Boost} C++ portable libraries."
   "\\item The \\href{http://www.zlib.net/}{zlib} compression library."
   "\\end{itemize}"
   ""
   "Under Ubuntu (14.04 LTS) the installation can be performed using the commands:"
   "\\begin{command}"
   "  > sudo apt-get install cmake libboost-dev zlib1g-dev g++"
   "\\end{command}"
   ""
   "Under Mac OS X the installation requires the following steps:"
   "\\begin{itemize}"
   "\\item Install Xcode"
   "\\item Install the command line tools."
   "\\item Install the MacPorts project which allows to automatically"
   "download and install opensource packages."
   "\\end{itemize}"
   "Then the following commands should be typed in a terminal:"
   "\\begin{command}"
   "  > sudo port install cmake gcc48 boost"
   "\\end{command}"
   )
 
 find_program(READLINK_COMMAND readlink)
 find_program(ADDR2LINE_COMMAND addr2line)
 find_program(PATCH_COMMAND patch)
 mark_as_advanced(READLINK_COMMAND)
 mark_as_advanced(ADDR2LINE_COMMAND)
 
 package_declare_extra_files_to_package(core
   SOURCES
     common/aka_element_classes_info.hh.in
     common/aka_config.hh.in
     model/solid_mechanics/material_list.hh.in
   )
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.9))
   package_set_compile_flags(core CXX "-Wno-undefined-var-template")
 endif()
 
 if(DEFINED AKANTU_CXX11_FLAGS)
   package_declare(core_cxx11 NOT_OPTIONAL
     DESCRIPTION "C++ 11 additions for Akantu core"
     COMPILE_FLAGS CXX "${AKANTU_CXX11_FLAGS}")
 
   if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.6")
       set(AKANTU_CORE_CXX11 OFF CACHE BOOL "C++ 11 additions for Akantu core - not supported by the selected compiler" FORCE)
     endif()
   endif()
 
   package_declare_documentation(core_cxx11
     "This option activates some features of the C++11 standard. This is usable with GCC>=4.7 or Intel>=13.")
 else()
   if(CMAKE_VERSION VERSION_LESS 3.1)
     message(FATAL_ERROR "Since version 3.0 Akantu requires at least c++11 capable compiler")
   endif()
 endif()
diff --git a/src/common/aka_array.cc b/src/common/aka_array.cc
index 08e70d815..a9950241f 100644
--- a/src/common/aka_array.cc
+++ b/src/common/aka_array.cc
@@ -1,123 +1,124 @@
 /**
  * @file   aka_array.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Implementation of akantu::Array
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <memory>
 #include <utility>
 
 /* -------------------------------------------------------------------------- */
-#include "aka_common.hh"
 #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),
+    : 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 << " + 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 <> Int Array<Real>::find(const Real & elem) const {
+template <> UInt Array<Real>::find(const Real & elem) const {
   AKANTU_DEBUG_IN();
-  UInt i = 0;
+
   Real epsilon = std::numeric_limits<Real>::epsilon();
-  for (; (i < size) && (fabs(values[i] - elem) <= epsilon); ++i)
-    ;
+  auto it = std::find_if(begin(), end(), [&elem, &epsilon](auto && a) {
+    return std::abs(a - elem) <= epsilon;
+  });
 
   AKANTU_DEBUG_OUT();
-  return (i == size) ? -1 : (Int)i;
+  return (it != end()) ? end() - it : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<ElementType> & Array<ElementType>::operator*=(__attribute__((unused))
                                                     const ElementType & alpha) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<ElementType> & Array<ElementType>::
 operator-=(__attribute__((unused)) const Array<ElementType> & vect) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<ElementType> & Array<ElementType>::
 operator+=(__attribute__((unused)) const Array<ElementType> & vect) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator*=(__attribute__((unused))
                                       const char & alpha) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator-=(__attribute__((unused))
                                       const Array<char> & vect) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return *this;
 }
 
 template <>
 Array<char> & Array<char>::operator+=(__attribute__((unused))
                                       const Array<char> & vect) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return *this;
 }
 
-} // akantu
+} // namespace akantu
diff --git a/src/common/aka_array.hh b/src/common/aka_array.hh
index a1c08394c..46300822e 100644
--- a/src/common/aka_array.hh
+++ b/src/common/aka_array.hh
@@ -1,397 +1,399 @@
 /**
  * @file   aka_array.hh
  *
  * @author Till Junge <till.junge@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  Array container for Akantu
  * This container differs from the std::vector from the fact it as 2 dimensions
  * a main dimension and the size stored per entries
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_VECTOR_HH__
 #define __AKANTU_VECTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <typeinfo>
 #include <vector>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /// class that afford to store vectors in static memory
 class ArrayBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   explicit ArrayBase(ID id = "");
 
   virtual ~ArrayBase();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the amount of space allocated in bytes
   inline UInt getMemorySize() const;
 
   /// set the size to zero without freeing the allocated space
   inline void empty();
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors */
   /* ------------------------------------------------------------------------ */
 public:
   /// Get the real size allocated in memory
   AKANTU_GET_MACRO(AllocatedSize, allocated_size, UInt);
   /// Get the Size of the Array
-  AKANTU_GET_MACRO(Size, size, UInt);
+  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 &);
 
   // AKANTU_GET_MACRO(Tag, tag, const std::string &);
   // AKANTU_SET_MACRO(Tag, tag, const std::string &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// id of the vector
   ID id;
 
   /// the size allocated
   UInt allocated_size{0};
 
   /// the size used
-  UInt size{0};
+  UInt size_{0};
 
   /// number of components
   UInt nb_component{1};
 
   /// size of the stored type
   UInt size_of_type{0};
 };
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <typename T, bool is_scal> class Array : public ArrayBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   using value_type = T;
   using reference = value_type &;
   using pointer_type = value_type *;
   using const_reference = const value_type &;
 
   /// Allocation of a new vector
-  explicit inline Array(UInt size = 0, UInt nb_component = 1, const ID & id = "");
+  explicit inline Array(UInt size = 0, UInt nb_component = 1,
+                        const ID & id = "");
 
   /// Allocation of a new vector with a default value
   Array(UInt size, UInt nb_component, const value_type def_values[],
         const ID & id = "");
 
   /// Allocation of a new vector with a default value
   Array(UInt size, UInt nb_component, const_reference value,
         const ID & id = "");
 
   /// Copy constructor (deep copy if deep=true)
   Array(const Array<value_type, is_scal> & vect, bool deep = true,
         const ID & id = "");
 
 #ifndef SWIG
   /// Copy constructor (deep copy)
   explicit Array(const std::vector<value_type> & vect);
 #endif
 
   inline ~Array() override;
 
   Array & operator=(const Array & a) {
     /// this is to let STL allocate and copy arrays in the case of
     /// std::vector::resize
     AKANTU_DEBUG_ASSERT(this->size == 0, "Cannot copy akantu::Array");
     return const_cast<Array &>(a);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Iterator                                                                 */
   /* ------------------------------------------------------------------------ */
   /// \todo protected: does not compile with intel  check why
 public:
   template <class R, class IR = R, bool issame = is_same<IR, T>::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 rerturning Vectors of size n  on entries of Array with
   /// nb_component = n
   using vector_iterator = iterator<Vector<T>>;
   /// const_iterator rerturning Vectors of n size on entries of Array with
   /// nb_component = n
   using const_vector_iterator = const_iterator<Vector<T>>;
 
   /// iterator rerturning Matrices of size (m, n) on entries of Array with
   /// nb_component = m*n
   using matrix_iterator = iterator<Matrix<T>>;
   /// const iterator rerturning Matrices of size (m, n) on entries of Array with
   /// nb_component = m*n
   using const_matrix_iterator = const_iterator<Matrix<T>>;
 
   /* ------------------------------------------------------------------------ */
   /// Get an iterator that behaves like a pointer T * to the first entry
   inline scalar_iterator begin();
   /// Get an iterator that behaves like a pointer T * to the end of the Array
   inline scalar_iterator end();
   /// Get a const_iterator to the beginging of an Array of scalar
   inline const_scalar_iterator begin() const;
   /// Get a const_iterator to the end of an Array of scalar
   inline const_scalar_iterator end() const;
 
   /// Get a scalar_iterator on the beginning of the Array considered of shape
   /// (new_size)
   inline scalar_iterator begin_reinterpret(UInt new_size);
   /// Get a scalar_iterator on the end of the Array considered of shape
   /// (new_size)
   inline scalar_iterator end_reinterpret(UInt new_size);
   /// Get a const_scalar_iterator on the beginning of the Array considered of
   /// shape (new_size)
   inline const_scalar_iterator begin_reinterpret(UInt new_size) const;
   /// Get a const_scalar_iterator on the end of the Array considered of shape
   /// (new_size)
   inline const_scalar_iterator end_reinterpret(UInt new_size) const;
 
   /* ------------------------------------------------------------------------ */
   /// Get a vector_iterator on the beginning of the Array
   inline vector_iterator begin(UInt n);
   /// Get a vector_iterator on the end of the Array
   inline vector_iterator end(UInt n);
   /// Get a vector_iterator on the beginning of the Array
   inline const_vector_iterator begin(UInt n) const;
   /// Get a vector_iterator on the end of the Array
   inline const_vector_iterator end(UInt n) const;
 
   /// Get a vector_iterator on the begining of the Array considered of shape
   /// (new_size, n)
   inline vector_iterator begin_reinterpret(UInt n, UInt new_size);
   /// Get a vector_iterator on the end of the Array considered of shape
   /// (new_size, n)
   inline vector_iterator end_reinterpret(UInt n, UInt new_size);
   /// Get a const_vector_iterator on the begining of the Array considered of
   /// shape (new_size, n)
   inline const_vector_iterator begin_reinterpret(UInt n, UInt new_size) const;
   /// Get a const_vector_iterator on the end of the Array considered of shape
   /// (new_size, n)
   inline const_vector_iterator end_reinterpret(UInt n, UInt new_size) const;
 
   /* ------------------------------------------------------------------------ */
   /// Get a matrix_iterator on the begining of the Array (Matrices of size (m,
   /// n))
   inline matrix_iterator begin(UInt m, UInt n);
   /// Get a matrix_iterator on the end of the Array (Matrices of size (m, n))
   inline matrix_iterator end(UInt m, UInt n);
   /// Get a const_matrix_iterator on the begining of the Array (Matrices of size
   /// (m, n))
   inline const_matrix_iterator begin(UInt m, UInt n) const;
   /// Get a const_matrix_iterator on the end of the Array (Matrices of size (m,
   /// n))
   inline const_matrix_iterator end(UInt m, UInt n) const;
 
   /// Get a matrix_iterator on the begining of the Array considered of shape
   /// (new_size, m*n)
   inline matrix_iterator begin_reinterpret(UInt m, UInt n, UInt size);
   /// Get a matrix_iterator on the end of the Array considered of shape
   /// (new_size, m*n)
   inline matrix_iterator end_reinterpret(UInt m, UInt n, UInt size);
   /// Get a const_matrix_iterator on the begining of the Array considered of
   /// shape (new_size, m*n)
   inline const_matrix_iterator begin_reinterpret(UInt m, UInt n,
                                                  UInt size) const;
   /// Get a const_matrix_iterator on the end of the Array considered of shape
   /// (new_size, m*n)
   inline const_matrix_iterator end_reinterpret(UInt m, UInt n, UInt size) const;
 
   /* ------------------------------------------------------------------------ */
   /* 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[]);
 
   /// append a Vector or a Matrix
   template <template <typename> class C>
   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);
 
   /// 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
-  Int find(const_reference elem) const;
+  UInt find(const_reference elem) const;
 
   /// @see Array::find(const_reference elem) const
-  Int find(T elem[]) const;
+  UInt find(T elem[]) const;
 
   /// @see Array::find(const_reference elem) const
-  template <template <typename> class C> inline Int find(const C<T> & elem);
+  template <template <typename> class C> inline UInt find(const C<T> & elem);
 
   /// set all entries of the array to 0
-  inline void clear() { std::fill_n(values, size * nb_component, T()); }
+  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); }
+  inline void set(T t) { std::fill_n(values, size_ * nb_component, t); }
 
   /// 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> inline void set(const C<T> & vm);
 
   /// 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 174f8e1c0..dcbbfffc0 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1538 +1,1543 @@
 /**
  * @file   aka_array_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  Inline functions of the classes Array<T> and ArrayBase
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T>                                                 */
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_ARRAY_TMPL_HH__
 #define __AKANTU_AKA_ARRAY_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator()(UInt i, UInt j) {
-  AKANTU_DEBUG_ASSERT(size > 0, "The array \"" << id << "\" is empty");
-  AKANTU_DEBUG_ASSERT((i < size) && (j < nb_component),
+  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),
+  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),
+  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),
+  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);
+  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;
+//   UInt pos = size_;
 
-//   resizeUnitialized(size + 1, false);
+//   resizeUnitialized(size_ + 1, false);
 
 //   T * tmp = values + nb_component * pos;
 //   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 // }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a matrix or a vector to the array
  * @param new_elem a reference to a Matrix<T> or Vector<T> */
 template <class T, bool is_scal>
 template <template <typename> class C>
 inline void Array<T, is_scal>::push_back(const C<T> & new_elem) {
   AKANTU_DEBUG_ASSERT(
       nb_component == new_elem.size(),
       "The vector("
           << new_elem.size()
           << ") as not a size compatible with the Array (nb_component="
           << nb_component << ").");
-  UInt pos = size;
-  resizeUnitialized(size + 1, false);
+  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;
+  UInt pos = size_;
 
-  resizeUnitialized(size + 1, false);
+  resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   T * new_elem = it.data();
   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * erase an element. If the erased element is not the last of the array, the
  * last element is moved into the hole in order to maintain contiguity. This
  * may invalidate existing iterators (For instance an iterator obtained by
  * Array::end() is no longer correct) and will change the order of the
  * elements.
  * @param i index of element to erase
  */
 template <class T, bool is_scal> inline void Array<T, is_scal>::erase(UInt i) {
   AKANTU_DEBUG_IN();
-  AKANTU_DEBUG_ASSERT((size > 0), "The array is empty");
-  AKANTU_DEBUG_ASSERT((i < size), "The element at position ["
-                                      << i << "] is out of range (" << i
-                                      << ">=" << size << ")");
+  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)) {
+  if (i != (size_ - 1)) {
     for (UInt j = 0; j < nb_component; ++j) {
-      values[i * nb_component + j] = values[(size - 1) * nb_component + j];
+      values[i * nb_component + j] = values[(size_ - 1) * nb_component + j];
     }
   }
 
-  resize(size - 1);
+  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) &&
+  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) {
+  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) &&
+  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) {
+  for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ += *b++;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Multiply all entries of this array by a scalar in place
  * @param alpha scalar multiplicant
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::operator*=(const T & alpha) {
   T * a = values;
-  for (UInt i = 0; i < size * nb_component; ++i) {
+  for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ *= alpha;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compare this array element by element to another.
  * @param other array to compare to
  * @return true it all element are equal and arrays have the same shape, else
  * false
  */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator==(const Array<T, is_scal> & array) const {
-  bool equal = nb_component == array.nb_component && size == array.size &&
+  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());
+    return std::equal(values, values + size_ * nb_component, array.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator!=(const Array<T, is_scal> & array) const {
   return !operator==(array);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * set all tuples of the array to a given vector or matrix
  * @param vm Matrix or Vector to fill the array with
  */
 template <class T, bool is_scal>
 template <template <typename> class C>
 inline void Array<T, is_scal>::set(const C<T> & vm) {
   AKANTU_DEBUG_ASSERT(
       nb_component == vm.size(),
       "The size of the object does not match the number of components");
-  for (T * it = values; it < values + nb_component * size; it += nb_component) {
+  for (T * it = values; it < values + nb_component * size_;
+       it += nb_component) {
     std::copy(vm.storage(), vm.storage() + nb_component, it);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::append(const Array<T> & other) {
   AKANTU_DEBUG_ASSERT(
       nb_component == other.nb_component,
       "Cannot append an array with a different number of component");
-  UInt old_size = this->size;
-  this->resizeUnitialized(this->size + other.getSize(), false);
+  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.getSize() * nb_component, tmp);
+  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(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   if (!is_scal) {
     T val = T();
     std::uninitialized_fill(values, values + size * nb_component, val);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T def_values[],
                          const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   T * tmp = values;
 
   for (UInt i = 0; i < size; ++i) {
     tmp = values + nb_component * i;
     std::uninitialized_copy(def_values, def_values + nb_component, tmp);
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T & value,
                          const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   std::uninitialized_fill_n(values, size * nb_component, value);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const Array<T, is_scal> & vect, bool deep,
                          const ID & id)
     : ArrayBase(vect) {
   AKANTU_DEBUG_IN();
   this->id = (id == "") ? vect.id : id;
 
   if (deep) {
-    allocate(vect.size, vect.nb_component);
+    allocate(vect.size_, vect.nb_component);
     T * tmp = values;
     std::uninitialized_copy(vect.storage(),
-                            vect.storage() + size * nb_component, tmp);
+                            vect.storage() + size_ * nb_component, tmp);
   } else {
     this->values = vect.storage();
-    this->size = vect.size;
+    this->size_ = vect.size_;
     this->nb_component = vect.nb_component;
     this->allocated_size = vect.allocated_size;
     this->size_of_type = vect.size_of_type;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const std::vector<T> & vect) {
   AKANTU_DEBUG_IN();
   this->id = "";
 
   allocate(vect.size(), 1);
   T * tmp = values;
-  std::uninitialized_copy(&(vect[0]), &(vect[size - 1]), tmp);
+  std::uninitialized_copy(&(vect[0]), &(vect[size_ - 1]), tmp);
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> Array<T, is_scal>::~Array() {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG(dblAccessory,
                "Freeing " << printMemorySize<T>(allocated_size * nb_component)
                           << " (" << id << ")");
 
   if (values) {
     if (!is_scal)
-      for (UInt i = 0; i < size * nb_component; ++i) {
+      for (UInt i = 0; i < size_ * nb_component; ++i) {
         T * obj = values + i;
         obj->~T();
       }
     free(values);
   }
-  size = allocated_size = 0;
+  size_ = allocated_size = 0;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * perform the allocation for the constructors
  * @param size is the size of the array
  * @param nb_component is the number of component of the array
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::allocate(UInt size, UInt nb_component) {
   AKANTU_DEBUG_IN();
   if (size == 0) {
-    values = NULL;
+    values = nullptr;
   } else {
     values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
-    AKANTU_DEBUG_ASSERT(values != NULL,
+    AKANTU_DEBUG_ASSERT(values != nullptr,
                         "Cannot allocate "
                             << printMemorySize<T>(size * nb_component) << " ("
                             << id << ")");
   }
 
   if (values == NULL) {
-    this->size = this->allocated_size = 0;
+    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_ = 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;
+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;
+  this->size_ = tmp_size;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal> void Array<T, is_scal>::resize(UInt new_size) {
   resizeUnitialized(new_size, !is_scal);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resize(UInt new_size, const T & val) {
   this->resizeUnitialized(new_size, true, val);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed.
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resizeUnitialized(UInt new_size, bool fill,
                                           const T & val) {
   //  AKANTU_DEBUG_IN();
   // free some memory
   if (new_size <= allocated_size) {
     if (!is_scal) {
       T * old_values = values;
-      if (new_size < size) {
-        for (UInt i = new_size * nb_component; i < size * nb_component; ++i) {
+      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) *
+                   "Freeing " << printMemorySize<T>((allocated_size - size_) *
                                                     nb_component)
                               << " (" << id << ")");
 
       // Normally there are no allocation problem when reducing an array
       if (new_size == 0) {
         free(values);
         values = NULL;
       } else {
         auto * tmp_ptr = static_cast<T *>(
             realloc(values, new_size * nb_component * sizeof(T)));
 
         if (tmp_ptr == NULL) {
           AKANTU_EXCEPTION("Cannot free data ("
                            << id << ")"
                            << " [current allocated size : " << allocated_size
                            << " | "
                            << "requested size : " << new_size << "]");
         }
         values = tmp_ptr;
       }
       allocated_size = new_size;
     }
   } else {
     // allocate more memory
     UInt size_to_alloc = (new_size - allocated_size < AKANTU_MIN_ALLOCATION)
                              ? allocated_size + AKANTU_MIN_ALLOCATION
                              : new_size;
 
     auto * tmp_ptr = static_cast<T *>(
         realloc(values, size_to_alloc * nb_component * sizeof(T)));
     AKANTU_DEBUG_ASSERT(
         tmp_ptr != NULL,
         "Cannot allocate " << printMemorySize<T>(size_to_alloc * nb_component));
     if (tmp_ptr == NULL) {
       AKANTU_DEBUG_ERROR("Cannot allocate more data ("
                          << id << ")"
                          << " [current allocated size : " << allocated_size
                          << " | "
                          << "requested size : " << new_size << "]");
     }
 
     AKANTU_DEBUG(dblAccessory,
                  "Allocating " << printMemorySize<T>(
                      (size_to_alloc - allocated_size) * nb_component));
 
     allocated_size = size_to_alloc;
     values = tmp_ptr;
   }
 
-  if (fill && this->size < new_size) {
-    std::uninitialized_fill(values + size * nb_component,
+  if (fill && this->size_ < new_size) {
+    std::uninitialized_fill(values + size_ * nb_component,
                             values + new_size * nb_component, val);
   }
 
-  size = new_size;
+  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)));
+      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 i = 0, k = size_ - 1; i < size_; ++i, --k) {
     for (UInt j = 0; j < new_component; ++j) {
       UInt m = new_component - j - 1;
       UInt n = m / multiplicator;
       for (UInt l = 0, p = block_size - 1; l < block_size; ++l, --p) {
         values[k * nb_component * multiplicator + m * block_size + p] =
             values[k * nb_component + n * block_size + p];
       }
     }
   }
 
   nb_component = nb_component * multiplicator;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * search elem in the array, return  the position of the first occurrence or
  * -1 if not found
  *  @param elem the element to look for
  *  @return index of the first occurrence of elem or -1 if elem is not present
  */
 template <class T, bool is_scal>
-Int Array<T, is_scal>::find(const T & elem) const {
+UInt Array<T, is_scal>::find(const T & elem) const {
   AKANTU_DEBUG_IN();
-  UInt i = 0;
-  for (; (i < size) && (values[i] != elem); ++i)
-    ;
+
+  auto begin = this->begin();
+  auto end = this->end();
+  auto it = std::find(begin, end, elem);
 
   AKANTU_DEBUG_OUT();
-  return (i == size) ? -1 : (Int)i;
+  return (it != end) ? it - begin : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
-template <class T, bool is_scal> Int Array<T, is_scal>::find(T elem[]) const {
+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) {
+  for (; i < size_; ++i) {
     if (*it == elem[0]) {
       T * cit = it;
       UInt c = 0;
       for (; (c < nb_component) && (*cit == elem[c]); ++c, ++cit)
         ;
       if (c == nb_component) {
         AKANTU_DEBUG_OUT();
         return i;
       }
     }
     it += nb_component;
   }
-  return -1;
+  return UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <template <typename> class C>
-inline Int Array<T, is_scal>::find(const C<T> & elem) {
+inline UInt Array<T, is_scal>::find(const C<T> & elem) {
+  AKANTU_DEBUG_ASSERT(elem.size() == nb_component,
+                      "Cannot find an element with a wrong size ("
+                          << elem.size() << ") != " << nb_component);
   return this->find(elem.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * copy the content of another array. This overwrites the current content.
  * @param other Array to copy into this array. It has to have the same
  * nb_component as this. If compiled in debug mode, an incorrect other will
  * result in an exception being thrown. Optimised code may result in
  * unpredicted behaviour.
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::copy(const Array<T, is_scal> & vect,
                              bool no_sanity_check) {
   AKANTU_DEBUG_IN();
 
   if (!no_sanity_check)
     if (vect.nb_component != nb_component)
       AKANTU_DEBUG_ERROR(
           "The two arrays do not have the same number of components");
 
-  resize((vect.size * vect.nb_component) / nb_component);
+  resize((vect.size_ * vect.nb_component) / nb_component);
 
   T * tmp = values;
-  std::uninitialized_copy(vect.storage(), vect.storage() + size * nb_component,
+  std::uninitialized_copy(vect.storage(), vect.storage() + size_ * nb_component,
                           tmp);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_scal> class ArrayPrintHelper {
 public:
   template <typename T>
   static void print_content(const Array<T> & vect, std::ostream & stream,
                             int indent) {
     if (AKANTU_DEBUG_TEST(dblDump) || AKANTU_DEBUG_LEVEL_IS_TEST()) {
       std::string space;
       for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
         ;
 
       stream << space << " + values         : {";
-      for (UInt i = 0; i < vect.getSize(); ++i) {
+      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.getSize() - 1)
+        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 << " + 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; }
+inline void ArrayBase::empty() { size_ = 0; }
 
 /* -------------------------------------------------------------------------- */
 /* Iterators                                                                  */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <class R, class IR, bool is_r_scal>
 class Array<T, is_scal>::iterator_internal {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using proxy = typename R::proxy;
   using const_proxy = const typename R::proxy;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal() : initial(NULL), ret(NULL), ret_ptr(NULL){};
 
   iterator_internal(pointer_type data, UInt _offset)
       : _offset(_offset), initial(data), ret(NULL), ret_ptr(data) {
     AKANTU_DEBUG_ERROR(
         "The constructor should never be called it is just an ugly trick...");
   }
 
   iterator_internal(pointer wrapped)
       : _offset(wrapped->size()), initial(wrapped->storage()),
         ret(const_cast<internal_pointer>(wrapped)),
         ret_ptr(wrapped->storage()) {}
 
   iterator_internal(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       this->ret = new internal_value_type(*it.ret, false);
     }
   }
 
   virtual ~iterator_internal() { delete ret; };
 
   inline iterator_internal & operator=(const iterator_internal & it) {
     if (this != &it) {
       this->_offset = it._offset;
       this->initial = it.initial;
       this->ret_ptr = it.ret_ptr;
       if (this->ret)
         this->ret->shallowCopy(*it.ret);
       else
         this->ret = new internal_value_type(*it.ret, false);
     }
     return *this;
   }
 
   UInt getCurrentIndex() {
     return (this->ret_ptr - this->initial) / this->_offset;
   };
 
   inline reference operator*() {
     ret->values = ret_ptr;
     return *ret;
   };
   inline const_reference operator*() const {
     ret->values = ret_ptr;
     return *ret;
   };
   inline pointer operator->() {
     ret->values = ret_ptr;
     return ret;
   };
   inline iterator_internal & operator++() {
     ret_ptr += _offset;
     return *this;
   };
   inline iterator_internal & operator--() {
     ret_ptr -= _offset;
     return *this;
   };
 
   inline iterator_internal & operator+=(const UInt n) {
     ret_ptr += _offset * n;
     return *this;
   }
   inline iterator_internal & operator-=(const UInt n) {
     ret_ptr -= _offset * n;
     return *this;
   }
 
   inline proxy operator[](const UInt n) {
     ret->values = ret_ptr + n * _offset;
     return proxy(*ret);
   }
   inline const_proxy operator[](const UInt n) const {
     ret->values = ret_ptr + n * _offset;
     return const_proxy(*ret);
   }
 
   inline bool operator==(const iterator_internal & other) const {
     return this->ret_ptr == other.ret_ptr;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return this->ret_ptr != other.ret_ptr;
   }
   inline bool operator<(const iterator_internal & other) const {
     return this->ret_ptr < other.ret_ptr;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return this->ret_ptr <= other.ret_ptr;
   }
   inline bool operator>(const iterator_internal & other) const {
     return this->ret_ptr > other.ret_ptr;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return this->ret_ptr >= other.ret_ptr;
   }
 
   inline iterator_internal operator+(difference_type n) {
     iterator_internal tmp(*this);
     tmp += n;
     return tmp;
   }
   inline iterator_internal operator-(difference_type n) {
     iterator_internal tmp(*this);
     tmp -= n;
     return tmp;
   }
 
   inline difference_type operator-(const iterator_internal & b) {
     return (this->ret_ptr - b.ret_ptr) / _offset;
   }
 
   inline pointer_type data() const { return ret_ptr; }
   inline difference_type offset() const { return _offset; }
 
 protected:
   UInt _offset{0};
   pointer_type initial;
   internal_pointer ret;
   pointer_type ret_ptr;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Specialization for scalar types
  */
 template <class T, bool is_scal>
 template <class R, class IR>
 class Array<T, is_scal>::iterator_internal<R, IR, true> {
 public:
   using value_type = R;
   using pointer = R *;
   using reference = R &;
   using const_reference = const R &;
   using internal_value_type = IR;
   using internal_pointer = IR *;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::random_access_iterator_tag;
 
 public:
   iterator_internal(pointer data = nullptr, UInt _offset = 1)
       : _offset(_offset), 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) / this->_offset;
   };
 
   inline reference operator*() { return *ret; };
   inline const_reference operator*() const { return *ret; };
   inline pointer operator->() { return ret; };
   inline iterator_internal & operator++() {
     ++ret;
     return *this;
   };
   inline iterator_internal & operator--() {
     --ret;
     return *this;
   };
 
   inline iterator_internal & operator+=(const UInt n) {
     ret += n;
     return *this;
   }
   inline iterator_internal & operator-=(const UInt n) {
     ret -= n;
     return *this;
   }
 
   inline reference operator[](const UInt n) { return ret[n]; }
 
   inline bool operator==(const iterator_internal & other) const {
     return ret == other.ret;
   }
   inline bool operator!=(const iterator_internal & other) const {
     return ret != other.ret;
   }
   inline bool operator<(const iterator_internal & other) const {
     return ret < other.ret;
   }
   inline bool operator<=(const iterator_internal & other) const {
     return ret <= other.ret;
   }
   inline bool operator>(const iterator_internal & other) const {
     return ret > other.ret;
   }
   inline bool operator>=(const iterator_internal & other) const {
     return ret >= other.ret;
   }
 
   inline iterator_internal operator-(difference_type n) {
     return iterator_internal(ret - n);
   }
   inline iterator_internal operator+(difference_type n) {
     return iterator_internal(ret + n);
   }
 
   inline difference_type operator-(const iterator_internal & b) {
     return ret - b.ret;
   }
 
   inline pointer data() const { return ret; }
   inline difference_type offset() const { return _offset; }
 
 protected:
   difference_type _offset;
   pointer ret;
   pointer initial;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Begin/End functions implementation                                         */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  * @param n vector size. Has to be equal to nb_component. This unfortunate
  * redundancy is necessary to distinguish it from ::begin() which it
  * overloads. If compiled in debug mode, an incorrect value of n will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::begin(UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
   return vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size. see Array::begin(UInt n) for more
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::end(UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
-  return vector_iterator(new Vector<T>(values + nb_component * size, n));
+  return vector_iterator(new Vector<T>(values + nb_component * size_, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  * @param n vector size. see Array::begin(UInt n) for more
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::begin(UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
   return const_vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size. see Array::begin(UInt n) for more
  * @return a const_vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::end(UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n,
                       "The iterator is not compatible with the type Array("
                           << n << ")");
-  return const_vector_iterator(new Vector<T>(values + nb_component * size, n));
+  return const_vector_iterator(new Vector<T>(values + nb_component * size_, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  *
  * The reinterpret iterators allow to iterate over an array in any way that
  * preserves the number of entries of the array. This can for instance be use
  * full if the shape of the data in an array is not initially known.
  * @param n vector size.
  * @param size number of tuples in array. n times size must match the number
  * of entries of the array. If compiled in debug mode, an incorrect
  * combination of n and size will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::begin_reinterpret(UInt n,
                                      __attribute__((unused)) UInt size) {
-  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size.
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
  * UInt size)
  * @return a vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::vector_iterator
 Array<T, is_scal>::end_reinterpret(UInt n, UInt size) {
-  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return vector_iterator(new Vector<T>(values + n * size, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * to the
  * first tuple of the array.
  * @param n vector size.
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
  * UInt size)
  * @return a const_vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::begin_reinterpret(UInt n,
                                      __attribute__((unused)) UInt size) const {
-  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return const_vector_iterator(new Vector<T>(values, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Vector<T> * pointing
  * *past* the last tuple of the array.
  * @param n vector size.
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt n,
  * UInt size)
  * @return a const_vector_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_vector_iterator
 Array<T, is_scal>::end_reinterpret(UInt n, UInt size) const {
-  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << n
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return const_vector_iterator(new Vector<T>(values + n * size, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  * @param m number of rows
  * @param n number of columns. m times n has to equal nb_component.
  * If compiled in debug mode, an incorrect combination of m and n will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::begin(UInt m, UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
   return matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns. See Array::begin(UInt m, UInt n)
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::end(UInt m, UInt n) {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
-  return matrix_iterator(new Matrix<T>(values + nb_component * size, m, n));
+  return matrix_iterator(new Matrix<T>(values + nb_component * size_, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  * @param m number of rows
  * @param n number of columns. See Array::begin(UInt m, UInt n)
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::begin(UInt m, UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
   return const_matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns. See Array::begin(UInt m, UInt n)
  * @return a const_matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::end(UInt m, UInt n) const {
   AKANTU_DEBUG_ASSERT(nb_component == n * m,
                       "The iterator is not compatible with the type Matrix("
                           << m << "," << n << ")");
   return const_matrix_iterator(
-      new Matrix<T>(values + nb_component * size, m, n));
+      new Matrix<T>(values + nb_component * size_, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  *
  * The reinterpret iterators allow to iterate over an array in any way that
  * preserves the number of entries of the array. This can for instance be use
  * full if the shape of the data in an array is not initially known.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. m times n times size must match the
  *number
  * of entries of the array. If compiled in debug mode, an incorrect
  * combination of m, n and size will result
  * in an exception being thrown. Optimized code will fail in an unpredicted
  * manner.
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::begin_reinterpret(UInt m, UInt n,
                                      __attribute__((unused)) UInt size) {
-  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get an iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
  * UInt n, UInt size)
  * @return a matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::matrix_iterator
 Array<T, is_scal>::end_reinterpret(UInt m, UInt n, UInt size) {
-  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return matrix_iterator(new Matrix<T>(values + n * m * size, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * to the
  * first tuple of the array.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
  * UInt n, UInt size)
  * @return a const_matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::begin_reinterpret(UInt m, UInt n,
                                      __attribute__((unused)) UInt size) const {
-  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return const_matrix_iterator(new Matrix<T>(values, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Get a const iterator that behaves like a pointer akantu::Matrix<T> * pointing
  * *past* the last tuple of the array.
  * @param m number of rows
  * @param n number of columns
  * @param size number of tuples in array. See Array::begin_reinterpret(UInt m,
  * UInt n, UInt size)
  * @return a const_matrix_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_matrix_iterator
 Array<T, is_scal>::end_reinterpret(UInt m, UInt n, UInt size) const {
-  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(n * m * size == this->nb_component * this->size_,
                       "The new values for size ("
                           << size << ") and nb_component (" << m << "," << n
                           << " = " << n * m
                           << ") are not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return const_matrix_iterator(new Matrix<T>(values + n * m * size, m, n));
 }
 
 /* -------------------------------------------------------------------------- */
 /** Get an iterator that behaves like a pointer T * to the
  *  first entry in the member array values
  *  @return a scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator Array<T, is_scal>::begin() {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a vector which has nb_component != 1");
   return scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 /*! Get an iterator that behaves like a pointer T * that points *past* the
  *  last entry in the member array values
  *  @return a scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator Array<T, is_scal>::end() {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a array which has nb_component != 1");
-  return scalar_iterator(values + size);
+  return scalar_iterator(values + size_);
 }
 
 /* -------------------------------------------------------------------------- */
 /*! Get a const iterator that behaves like a pointer T * to the
  *  first entry in the member array values
  *  @return a const_scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::begin() const {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a array which has nb_component != 1");
   return const_scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 /*! Get a const iterator that behaves like a pointer T * that points *past* the
  *  last entry in the member array values
  *  @return a const_scalar_iterator
  */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::end() const {
   AKANTU_DEBUG_ASSERT(
       nb_component == 1,
       "this iterator cannot be used on a array which has nb_component != 1");
-  return const_scalar_iterator(values + size);
+  return const_scalar_iterator(values + size_);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator
 Array<T, is_scal>::begin_reinterpret(__attribute__((unused)) UInt new_size) {
-  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::scalar_iterator
 Array<T, is_scal>::end_reinterpret(UInt new_size) {
-  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return scalar_iterator(values + new_size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::begin_reinterpret(__attribute__((unused))
                                      UInt new_size) const {
-  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return const_scalar_iterator(values);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline typename Array<T, is_scal>::const_scalar_iterator
 Array<T, is_scal>::end_reinterpret(UInt new_size) const {
-  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size,
+  AKANTU_DEBUG_ASSERT(new_size == this->nb_component * this->size_,
                       "The new values for size ("
                           << new_size
                           << ") is not compatible with the one of this array("
-                          << this->size << "," << this->nb_component << ")");
+                          << this->size_ << "," << this->nb_component << ")");
   return const_scalar_iterator(values + new_size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::const_iterator : public iterator_internal<const R, R> {
 public:
   typedef iterator_internal<const R, R> parent;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   const_iterator() : parent(){};
   const_iterator(pointer_type data, UInt offset) : parent(data, offset) {}
   const_iterator(pointer warped) : parent(warped) {}
   const_iterator(const parent & it) : parent(it) {}
   //    const_iterator(const const_iterator<R> & it) : parent(it) {}
 
   inline const_iterator operator+(difference_type n) {
     return parent::operator+(n);
   }
   inline const_iterator operator-(difference_type n) {
     return parent::operator-(n);
   }
   inline difference_type operator-(const const_iterator & b) {
     return parent::operator-(b);
   }
 
   inline const_iterator & operator++() {
     parent::operator++();
     return *this;
   };
   inline const_iterator & operator--() {
     parent::operator--();
     return *this;
   };
   inline const_iterator & operator+=(const UInt n) {
     parent::operator+=(n);
     return *this;
   }
 };
 // #endif
 
 // #if defined(AKANTU_CORE_CXX11)
 //   template<class R> using iterator = iterator_internal<R>;
 // #else
 template <class T, class R, bool issame = is_same<T, R>::value>
 struct ConstConverterIteratorHelper {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(new R(*it, false));
   }
 };
 
 template <class T, class R> struct ConstConverterIteratorHelper<T, R, true> {
   using const_iterator = typename Array<T>::template const_iterator<R>;
   using iterator = typename Array<T>::template iterator<R>;
   static inline const_iterator convert(const iterator & it) {
     return const_iterator(it.data(), it.offset());
   }
 };
 
 template <class T, bool is_scal>
 template <typename R>
 class Array<T, is_scal>::iterator : public iterator_internal<R> {
 public:
   using parent = iterator_internal<R>;
   using value_type = typename parent::value_type;
   using pointer = typename parent::pointer;
   using reference = typename parent::reference;
   using difference_type = typename parent::difference_type;
   using iterator_category = typename parent::iterator_category;
 
 public:
   iterator() : parent(){};
   iterator(pointer_type data, UInt offset) : parent(data, offset){};
   iterator(pointer warped) : parent(warped) {}
   iterator(const parent & it) : parent(it) {}
   //    iterator(const iterator<R> & it) : parent(it) {}
 
   operator const_iterator<R>() {
     return ConstConverterIteratorHelper<T, R>::convert(*this);
   }
 
   inline iterator operator+(difference_type n) {
     return parent::operator+(n);
     ;
   }
   inline iterator operator-(difference_type n) {
     return parent::operator-(n);
     ;
   }
   inline difference_type operator-(const iterator & b) {
     return parent::operator-(b);
   }
 
   inline iterator & operator++() {
     parent::operator++();
     return *this;
   };
   inline iterator & operator--() {
     parent::operator--();
     return *this;
   };
   inline iterator & operator+=(const UInt n) {
     parent::operator+=(n);
     return *this;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename R>
 inline typename Array<T, is_scal>::template iterator<R>
 Array<T, is_scal>::erase(const iterator<R> & it) {
   T * curr = it.data();
   UInt pos = (curr - values) / nb_component;
   erase(pos);
   iterator<R> rit = it;
   return --rit;
 }
 
-
-} // akantu
+} // namespace akantu
 
 #endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */
diff --git a/src/common/aka_circular_array.hh b/src/common/aka_circular_array.hh
index 34ed0fb1b..f533430c0 100644
--- a/src/common/aka_circular_array.hh
+++ b/src/common/aka_circular_array.hh
@@ -1,140 +1,140 @@
 /**
  * @file   aka_circular_array.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  class of circular array
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_CIRCULAR_ARRAY_HH__
 #define __AKANTU_AKA_CIRCULAR_ARRAY_HH__
 
 /* -------------------------------------------------------------------------- */
 #include <typeinfo>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_array.hh"
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template<class T>
 class CircularArray : protected Array<T> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef typename Array<T>::value_type      value_type;
   typedef typename Array<T>::reference       reference;
   typedef typename Array<T>::pointer_type    pointer_type;
   typedef typename Array<T>::const_reference const_reference;
 
   /// Allocation of a new array with a default value
   CircularArray(UInt size, UInt nb_component = 1,
 		 const_reference value = value_type(), const ID & id = "") :
     Array<T>(size, nb_component, value, id),
     start_position(0),
     end_position(size-1) {
     AKANTU_DEBUG_IN();
 
     AKANTU_DEBUG_OUT();
   };
 
   virtual ~CircularArray() {
     AKANTU_DEBUG_IN();
 
     AKANTU_DEBUG_OUT();
   };
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /**
      advance start and end position by one: 
      the first element is now at the end of the array
   **/
   inline void makeStep();
 
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
 private:
 
   /* ------------------------------------------------------------------------ */
   /* Operators                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   inline reference operator()(UInt i, UInt j = 0);
   inline const_reference operator()(UInt i, UInt j = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
-  UInt getSize() const{ return this->size; };
+  UInt size() const{ return this->size_; };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// indice of first element in this circular array
   UInt start_position;
 
   /// indice of last element in this circular array
   UInt end_position;
 };
 
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #if defined (AKANTU_INCLUDE_INLINE_IMPL)
 #  include "aka_circular_array_inline_impl.cc"
 #endif
 
 /// standard output stream operator
 template <typename T>
 inline std::ostream & operator <<(std::ostream & stream, const CircularArray<T> & _this)
 {
   _this.printself(stream);
   return stream;
 }
 
 
 
 } // akantu
 
 
 
 #endif /* __AKANTU_AKA_CIRCULAR_ARRAY_HH__ */
 
 
diff --git a/src/common/aka_csr.hh b/src/common/aka_csr.hh
index 9e2d72a0b..e88f9a02c 100644
--- a/src/common/aka_csr.hh
+++ b/src/common/aka_csr.hh
@@ -1,259 +1,259 @@
 /**
  * @file   aka_csr.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Apr 20 2011
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  A compresed sparse row structure based on akantu Arrays
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_CSR_HH__
 #define __AKANTU_AKA_CSR_HH__
 
 namespace akantu {
 
 /**
  * This class  can be  used to  store the structure  of a  sparse matrix  or for
  * vectors with variable number of component per element
  *
  * @param nb_rows number of rows of a matrix or size of a vector.
  */
 template <typename T> class CSR {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   explicit CSR(UInt nb_rows = 0)
       : nb_rows(nb_rows), rows_offsets(nb_rows + 1, 1, "rows_offsets"),
         rows(0, 1, "rows") {
     rows_offsets.clear();
   };
 
   virtual ~CSR(){};
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// does nothing
   inline void beginInsertions(){};
 
   /// insert a new entry val in row row
   inline UInt insertInRow(UInt row, const T & val) {
     UInt pos = rows_offsets(row)++;
     rows(pos) = val;
     return pos;
   }
 
   /// access an element of the matrix
   inline const T & operator()(UInt row, UInt col) const {
     AKANTU_DEBUG_ASSERT(rows_offsets(row + 1) - rows_offsets(row) > col,
                         "This element is not present in this CSR");
     return rows(rows_offsets(row) + col);
   }
 
   /// access an element of the matrix
   inline T & operator()(UInt row, UInt col) {
     AKANTU_DEBUG_ASSERT(rows_offsets(row + 1) - rows_offsets(row) > col,
                         "This element is not present in this CSR");
     return rows(rows_offsets(row) + col);
   }
 
   inline void endInsertions() {
     for (UInt i = nb_rows; i > 0; --i)
       rows_offsets(i) = rows_offsets(i - 1);
     rows_offsets(0) = 0;
   }
 
   inline void countToCSR() {
     for (UInt i = 1; i < nb_rows; ++i)
       rows_offsets(i) += rows_offsets(i - 1);
     for (UInt i = nb_rows; i >= 1; --i)
       rows_offsets(i) = rows_offsets(i - 1);
     rows_offsets(0) = 0;
   }
 
   inline void clearRows() {
     rows_offsets.clear();
     rows.resize(0);
   };
 
   inline void resizeRows(UInt nb_rows) {
     this->nb_rows = nb_rows;
     rows_offsets.resize(nb_rows + 1);
     rows_offsets.clear();
   }
 
   inline void resizeCols() { rows.resize(rows_offsets(nb_rows)); }
 
   inline void copy(Array<UInt> & offsets, Array<T> & values) {
     offsets.copy(rows_offsets);
     values.copy(rows);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// returns the number of rows
-  inline UInt getNbRows() const { return rows_offsets.getSize() - 1; };
+  inline UInt getNbRows() const { return rows_offsets.size() - 1; };
 
   /// returns the number of non-empty columns in a given row
   inline UInt getNbCols(UInt row) const {
     return rows_offsets(row + 1) - rows_offsets(row);
   };
 
   /// returns the offset (start of columns) for a given row
   inline UInt & rowOffset(UInt row) { return rows_offsets(row); };
 
   /// iterator on a row
   template <class R>
   class iterator_internal
       : public std::iterator<std::bidirectional_iterator_tag, R> {
   public:
     typedef std::iterator<std::bidirectional_iterator_tag, R> _parent;
     typedef typename _parent::pointer pointer;
     typedef typename _parent::reference reference;
 
     explicit iterator_internal(pointer x = NULL) : pos(x){};
     iterator_internal(const iterator_internal & it) : pos(it.pos){};
 
     iterator_internal & operator++() {
       ++pos;
       return *this;
     };
     iterator_internal operator++(int) {
       iterator tmp(*this);
       operator++();
       return tmp;
     };
 
     iterator_internal & operator--() {
       --pos;
       return *this;
     };
     iterator_internal operator--(int) {
       iterator_internal tmp(*this);
       operator--();
       return tmp;
     };
 
     bool operator==(const iterator_internal & rhs) { return pos == rhs.pos; };
     bool operator!=(const iterator_internal & rhs) { return pos != rhs.pos; };
     reference operator*() { return *pos; };
     pointer operator->() const { return pos; };
 
   private:
     pointer pos;
   };
 
   typedef iterator_internal<T> iterator;
   typedef iterator_internal<const T> const_iterator;
 
   inline iterator begin(UInt row) {
     return iterator(rows.storage() + rows_offsets(row));
   };
   inline iterator end(UInt row) {
     return iterator(rows.storage() + rows_offsets(row + 1));
   };
 
   inline const_iterator begin(UInt row) const {
     return const_iterator(rows.storage() + rows_offsets(row));
   };
   inline const_iterator end(UInt row) const {
     return const_iterator(rows.storage() + rows_offsets(row + 1));
   };
 
   inline iterator rbegin(UInt row) {
     return iterator(rows.storage() + rows_offsets(row + 1) - 1);
   };
   inline iterator rend(UInt row) {
     return iterator(rows.storage() + rows_offsets(row) - 1);
   };
 
   inline const Array<UInt> & getRowsOffset() const { return rows_offsets; };
   inline const Array<T> & getRows() const { return rows; };
   inline Array<T> & getRows() { return rows; };
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   UInt nb_rows;
 
   /// array of size nb_rows containing the offset where the values are stored in
   Array<UInt> rows_offsets;
 
   /// compressed row values, values of row[i] are stored between rows_offsets[i]
   /// and rows_offsets[i+1]
   Array<T> rows;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Data CSR                                                                   */
 /* -------------------------------------------------------------------------- */
 
 /**
  * Inherits from  CSR<UInt> and  can contain information  such as  matrix values
  * where the mother class would be a CSR structure for row and cols
  *
  * @return nb_rows
  */
 template <class T> class DataCSR : public CSR<UInt> {
 public:
   DataCSR(UInt nb_rows = 0) : CSR<UInt>(nb_rows), data(0, 1){};
 
   inline void resizeCols() {
     CSR<UInt>::resizeCols();
     data.resize(rows_offsets(nb_rows));
   }
 
   inline const Array<T> & getData() const { return data; };
 
 private:
   Array<T> data;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 //#include "aka_csr_inline_impl.cc"
 
 /// standard output stream operator
 // inline std::ostream & operator <<(std::ostream & stream, const CSR & _this)
 // {
 //   _this.printself(stream);
 //   return stream;
 // }
 
 } // akantu
 
 #endif /* __AKANTU_AKA_CSR_HH__ */
diff --git a/src/common/aka_grid_dynamic.hh b/src/common/aka_grid_dynamic.hh
index ccc2bf128..81f4c10b4 100644
--- a/src/common/aka_grid_dynamic.hh
+++ b/src/common/aka_grid_dynamic.hh
@@ -1,472 +1,472 @@
 /**
  * @file   aka_grid_dynamic.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Sat Sep 26 2015
  *
  * @brief  Grid that is auto balanced
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_array.hh"
 #include "aka_types.hh"
 
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_GRID_DYNAMIC_HH__
 #define __AKANTU_AKA_GRID_DYNAMIC_HH__
 
 namespace akantu {
 
 class Mesh;
 
 template<typename T>
 class SpatialGrid {
 public:
   SpatialGrid(UInt dimension) : dimension(dimension),
                                 spacing(dimension),
                                 center(dimension),
                                 lower(dimension),
                                 upper(dimension),
                                 empty_cell() {}
 
   SpatialGrid(UInt dimension,
               const Vector<Real> & spacing,
               const Vector<Real> & center) : dimension(dimension),
                                                     spacing(spacing),
                                                     center(center),
                                                     lower(dimension),
                                                     upper(dimension),
                                                     empty_cell() {
     for (UInt i = 0; i < dimension; ++i) {
       lower(i) =   std::numeric_limits<Real>::max();
       upper(i) = - std::numeric_limits<Real>::max();
     }
   }
 
   virtual ~SpatialGrid() {};
 
   class neighbor_cells_iterator;
   class cells_iterator;
 
   class CellID {
   public:
     CellID() : ids() {}
     CellID(UInt dimention) : ids(dimention) {}
     void setID(UInt dir, Int id) { ids(dir) = id; }
     Int getID(UInt dir) const { return ids(dir); }
 
     bool operator<(const CellID & id) const {
       return std::lexicographical_compare(ids.storage(), ids.storage() + ids.size(),
                                           id.ids.storage(), id.ids.storage() + id.ids.size());
     }
 
     bool operator==(const CellID & id) const {
       return std::equal(ids.storage(), ids.storage() + ids.size(),
                         id.ids.storage());
     }
 
     bool operator!=(const CellID & id) const {
       return !(operator==(id));
     }
 
   private:
     friend class neighbor_cells_iterator;
     friend class cells_iterator;
     Vector<Int> ids;
   };
 
   /* -------------------------------------------------------------------------- */
   class Cell {
   public:
     typedef typename std::vector<T>::iterator iterator;
     typedef typename std::vector<T>::const_iterator const_iterator;
 
     Cell() : id(), data() { }
 
     Cell(const CellID &cell_id) : id(cell_id), data() { }
 
     bool operator==(const Cell & cell) const { return id == cell.id; }
     bool operator!=(const Cell & cell) const { return id != cell.id; }
 
     Cell & add(const T & d) { data.push_back(d); return *this; }
 
     iterator begin() { return data.begin(); }
     const_iterator begin() const { return data.begin(); }
 
     iterator end() { return data.end(); }
     const_iterator end() const { return data.end(); }
   private:
     CellID id;
     std::vector<T> data;
   };
 
 private:
   typedef std::map<CellID, Cell> cells_container;
 
 public:
 
   const Cell & getCell(const CellID & cell_id) const {
     typename cells_container::const_iterator it = cells.find(cell_id);
     if(it != cells.end()) return it->second;
     else return empty_cell;
   }
   
   typename Cell::iterator beginCell(const CellID & cell_id) {
     typename cells_container::iterator it = cells.find(cell_id);
     if(it != cells.end()) return it->second.begin();
     else return empty_cell.begin();
   }
 
   typename Cell::iterator endCell(const CellID & cell_id) {
     typename cells_container::iterator it = cells.find(cell_id);
     if(it != cells.end()) return it->second.end();
     else return empty_cell.end();
   }
 
   typename Cell::const_iterator beginCell(const CellID & cell_id) const {
     typename cells_container::const_iterator it = cells.find(cell_id);
     if(it != cells.end()) return it->second.begin();
     else return empty_cell.begin();
   }
 
   typename Cell::const_iterator endCell(const CellID & cell_id) const {
     typename cells_container::const_iterator it = cells.find(cell_id);
     if(it != cells.end()) return it->second.end();
     else return empty_cell.end();
   }
 
 
   class neighbor_cells_iterator : private std::iterator<std::forward_iterator_tag, UInt> {
   public:
     neighbor_cells_iterator(const CellID & cell_id, bool end) :
       cell_id(cell_id),
       position(cell_id.ids.size(), end ? 1 : -1) {
 
       this->updateIt();
       if(end) this->it++;
     }
 
     neighbor_cells_iterator& operator++() {
       UInt i = 0;
       for (; i < position.size() && position(i) == 1; ++i);
 
       if(i == position.size()) ++it;
       else {
         for (UInt j = 0; j < i; ++j) position(j) = -1;
         position(i)++;
         updateIt();
       }
 
       return *this;
     }
 
     neighbor_cells_iterator operator++(int) { neighbor_cells_iterator tmp(*this); operator++(); return tmp; };
 
     bool operator==(const neighbor_cells_iterator& rhs) const { return cell_id == rhs.cell_id && it == rhs.it; };
     bool operator!=(const neighbor_cells_iterator& rhs) const { return ! operator==(rhs); };
 
     CellID operator*() const {
       CellID cur_cell_id(cell_id);
       cur_cell_id.ids += position;
       return cur_cell_id;
     };
 
   private:
     void updateIt() {
       it = 0;
       for (UInt i = 0; i < position.size(); ++i) it = it * 3 + (position(i) + 1);
     }
 
   private:
     /// central cell id
     const CellID & cell_id;
 
     // number representing the current neighbor in base 3;
     UInt it;
 
     Vector<Int> position;
   };
 
 
   class cells_iterator : private std::iterator<std::forward_iterator_tag, CellID> {
   public:
     cells_iterator(typename std::map<CellID, Cell>::const_iterator it) :
       it(it) { }
 
     cells_iterator & operator++() {
       this->it++;
       return *this;
     }
 
 
     cells_iterator operator++(int) {cells_iterator tmp(*this); operator++(); return tmp; };
 
     bool operator==(const cells_iterator& rhs) const { return it == rhs.it; };
     bool operator!=(const cells_iterator& rhs) const { return ! operator==(rhs); };
 
     CellID operator*() const {
       CellID cur_cell_id(this->it->first);
       return cur_cell_id;
     };
 
   private:
 
     /// map iterator
     typename std::map<CellID, Cell>::const_iterator it;
 
   };
 
 
 
 
 public:
   template<class vector_type>
   Cell & insert(const T & d, const vector_type & position) {
     CellID cell_id = getCellID(position);
 
     typename cells_container::iterator it = cells.find(cell_id);
 
     if(it == cells.end()) {
       Cell cell(cell_id);
 // #if defined(AKANTU_NDEBUG)
       Cell & tmp = (cells[cell_id] = cell).add(d);
 // #else
 //       Cell & tmp = (cells[cell_id] = cell).add(d, position);
 // #endif
 
       for (UInt i = 0; i < dimension; ++i) {
         Real posl = center(i) + cell_id.getID(i) * spacing(i);
         Real posu = posl + spacing(i);
         if(posl < lower(i)) lower(i) = posl;
         if(posu > upper(i)) upper(i) = posu;
       }
       return tmp;
     } else {
 // #if defined(AKANTU_NDEBUG)
       return it->second.add(d);
 // #else
 //       return it->second.add(d, position);
 // #endif
     }
   }
 
 
   inline neighbor_cells_iterator beginNeighborCells(const CellID & cell_id) const {
     return neighbor_cells_iterator(cell_id, false);
   }
 
   inline neighbor_cells_iterator endNeighborCells(const CellID & cell_id) const {
     return neighbor_cells_iterator(cell_id, true);
   }
 
   inline cells_iterator beginCells() const {
     typename std::map<CellID, Cell>::const_iterator begin = this->cells.begin();
     return cells_iterator(begin);
   }
 
   inline cells_iterator endCells() const {
     typename std::map<CellID, Cell>::const_iterator end = this->cells.end();
     return cells_iterator(end);
   }
 
 
 
 
 
   template<class vector_type>
   CellID getCellID(const vector_type & position) const {
     CellID cell_id(dimension);
     for (UInt i = 0; i < dimension; ++i) {
       cell_id.setID(i, getCellID(position(i), i));
     }
     return cell_id;
   }
 
 
   void printself(std::ostream & stream, int indent = 0) const {
     std::string space;
     for(Int i = 0; i < indent; i++, space += AKANTU_INDENT);
 
     std::streamsize prec        = stream.precision();
     std::ios_base::fmtflags ff  = stream.flags();
 
     stream.setf (std::ios_base::showbase);
     stream.precision(5);
 
     stream << space << "SpatialGrid<" << debug::demangle(typeid(T).name()) << "> [" << std::endl;
     stream << space << " + dimension    : " << this->dimension << std::endl;
     stream << space << " + lower bounds : {";
     for (UInt i = 0; i < lower.size(); ++i) { if(i != 0) stream << ", "; stream << lower(i); };
     stream << "}" << std::endl;
     stream << space << " + upper bounds : {";
     for (UInt i = 0; i < upper.size(); ++i) { if(i != 0) stream << ", "; stream << upper(i); };
     stream << "}" << std::endl;
     stream << space << " + spacing : {";
     for (UInt i = 0; i < spacing.size(); ++i) { if(i != 0) stream << ", "; stream << spacing(i); };
     stream << "}" << std::endl;
     stream << space << " + center : {";
     for (UInt i = 0; i < center.size(); ++i) { if(i != 0) stream << ", "; stream << center(i); };
     stream << "}" << std::endl;
 
     stream << space << " + nb_cells     : " << this->cells.size() << "/";
     Vector<Real> dist(this->dimension);
     dist = upper;
     dist -= lower;
     for (UInt i = 0; i < this->dimension; ++i) {
       dist(i) /= spacing(i); 
     }
     UInt nb_cells = std::ceil(dist(0));
     for (UInt i = 1; i < this->dimension; ++i) {
       nb_cells *= std::ceil(dist(i));
     }
     stream << nb_cells << std::endl;
     stream << space << "]" << std::endl;
 
     stream.precision(prec);
     stream.flags(ff);
   }
 
   void saveAsMesh(Mesh & mesh) const;
 
 private:
   /* -------------------------------------------------------------------------- */
   inline UInt getCellID(Real position, UInt direction) const {
     AKANTU_DEBUG_ASSERT(direction < center.size(), "The direction asked ("
                         << direction << ") is out of range " << center.size());
     Real dist_center = position - center(direction);
     Int id = std::floor(dist_center / spacing(direction));
     //if(dist_center < 0) id--;
     return id;
   }
 
   friend class GridSynchronizer;
 public:
   AKANTU_GET_MACRO(LowerBounds, lower, const Vector<Real> &);
   AKANTU_GET_MACRO(UpperBounds, upper, const Vector<Real> &);
   AKANTU_GET_MACRO(Spacing, spacing, const Vector<Real> &);
 
 protected:
   UInt dimension;
 
   cells_container cells;
 
   Vector<Real> spacing;
   Vector<Real> center;
 
   Vector<Real> lower;
   Vector<Real> upper;
 
   Cell empty_cell;
 };
 
 /// standard output stream operator
 template<typename T>
 inline std::ostream & operator <<(std::ostream & stream, const SpatialGrid<T> & _this)
 {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 #include "mesh.hh"
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template<typename T>
 void SpatialGrid<T>::saveAsMesh(Mesh & mesh) const {
   Array<Real> & nodes = const_cast<Array<Real> &>(mesh.getNodes());
 
   ElementType type;
   switch(dimension) {
   case 1: type = _segment_2; break;
   case 2: type = _quadrangle_4; break;
   case 3: type = _hexahedron_8; break;
   }
 
   mesh.addConnectivityType(type);
   auto & connectivity = const_cast<Array<UInt> &>(mesh.getConnectivity(type));
   auto & uint_data = mesh.getDataPointer<UInt>("tag_1", type);
 
   Vector<Real> pos(dimension);
 
   UInt global_id = 0;
   for (auto & cell_pair : cells) {
-    UInt cur_node = nodes.getSize();
-    UInt cur_elem = connectivity.getSize();
+    UInt cur_node = nodes.size();
+    UInt cur_elem = connectivity.size();
     const CellID & cell_id = cell_pair.first;
 
     for (UInt i = 0; i < dimension; ++i)  pos(i) = center(i) + cell_id.getID(i) * spacing(i);
     nodes.push_back(pos);
     for (UInt i = 0; i < dimension; ++i)  pos(i) += spacing(i);
     nodes.push_back(pos);
 
     connectivity.push_back(cur_node);
     switch(dimension) {
     case 1:
       connectivity(cur_elem, 1) = cur_node + 1;
       break;
     case 2:
       pos(0) -= spacing(0); nodes.push_back(pos);
       pos(0) += spacing(0); pos(1) -= spacing(1); nodes.push_back(pos);
       connectivity(cur_elem, 1) = cur_node + 3;
       connectivity(cur_elem, 2) = cur_node + 1;
       connectivity(cur_elem, 3) = cur_node + 2;
       break;
     case 3:
                             pos(1) -= spacing(1); pos(2) -= spacing(2); nodes.push_back(pos);
                             pos(1) += spacing(1);                       nodes.push_back(pos);
       pos(0) -= spacing(0);                                             nodes.push_back(pos);
 
                             pos(1) -= spacing(1); pos(2) += spacing(2); nodes.push_back(pos);
       pos(0) += spacing(0);                                             nodes.push_back(pos);
       pos(0) -= spacing(0); pos(1) += spacing(1);                       nodes.push_back(pos);
 
 
       connectivity(cur_elem, 1) = cur_node + 2;
       connectivity(cur_elem, 2) = cur_node + 3;
       connectivity(cur_elem, 3) = cur_node + 4;
       connectivity(cur_elem, 4) = cur_node + 5;
       connectivity(cur_elem, 5) = cur_node + 6;
       connectivity(cur_elem, 6) = cur_node + 1;
       connectivity(cur_elem, 7) = cur_node + 7;
       break;
     }
     uint_data.push_back(global_id);
 
     ++global_id;
   }
 }
 
 } // akantu
 
 
 
 #endif /* __AKANTU_AKA_GRID_DYNAMIC_HH__ */
diff --git a/src/common/aka_math.cc b/src/common/aka_math.cc
index ae03ed59a..09ad498d8 100644
--- a/src/common/aka_math.cc
+++ b/src/common/aka_math.cc
@@ -1,251 +1,251 @@
 /**
  * @file   aka_math.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Marion Estelle Chambart <marion.chambart@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Leonardo Snozzi <leonardo.snozzi@epfl.ch>
  * @author Peter Spijker <peter.spijker@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Aug 04 2010
  * @date last modification: Fri May 15 2015
  *
  * @brief  Implementation of the math toolbox
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_math.hh"
 #include "aka_array.hh"
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void Math::matrix_vector(UInt m, UInt n, const Array<Real> & A,
                          const Array<Real> & x, Array<Real> & y, Real alpha) {
   AKANTU_DEBUG_IN();
 
-  AKANTU_DEBUG_ASSERT(A.getSize() == x.getSize(),
+  AKANTU_DEBUG_ASSERT(A.size() == x.size(),
                       "The vector A(" << A.getID() << ") and the vector x("
                                       << x.getID()
                                       << ") must have the same size");
 
   AKANTU_DEBUG_ASSERT(A.getNbComponent() == m * n,
                       "The vector A(" << A.getID()
                                       << ") has the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       x.getNbComponent() == n,
       "The vector x(" << x.getID() << ") do not the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       y.getNbComponent() == n,
       "The vector y(" << y.getID() << ") do not the good number of component.");
 
-  UInt nb_element = A.getSize();
+  UInt nb_element = A.size();
   UInt offset_A = A.getNbComponent();
   UInt offset_x = x.getNbComponent();
 
   y.resize(nb_element);
 
   Real * A_val = A.storage();
   Real * x_val = x.storage();
   Real * y_val = y.storage();
 
   for (UInt el = 0; el < nb_element; ++el) {
     matrix_vector(m, n, A_val, x_val, y_val, alpha);
 
     A_val += offset_A;
     x_val += offset_x;
     y_val += offset_x;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Math::matrix_matrix(UInt m, UInt n, UInt k, const Array<Real> & A,
                          const Array<Real> & B, Array<Real> & C, Real alpha) {
   AKANTU_DEBUG_IN();
 
-  AKANTU_DEBUG_ASSERT(A.getSize() == B.getSize(),
+  AKANTU_DEBUG_ASSERT(A.size() == B.size(),
                       "The vector A(" << A.getID() << ") and the vector B("
                                       << B.getID()
                                       << ") must have the same size");
 
   AKANTU_DEBUG_ASSERT(A.getNbComponent() == m * k,
                       "The vector A(" << A.getID()
                                       << ") has the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       B.getNbComponent() == k * n,
       "The vector B(" << B.getID() << ") do not the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       C.getNbComponent() == m * n,
       "The vector C(" << C.getID() << ") do not the good number of component.");
 
-  UInt nb_element = A.getSize();
+  UInt nb_element = A.size();
   UInt offset_A = A.getNbComponent();
   UInt offset_B = B.getNbComponent();
   UInt offset_C = C.getNbComponent();
 
   C.resize(nb_element);
 
   Real * A_val = A.storage();
   Real * B_val = B.storage();
   Real * C_val = C.storage();
 
   for (UInt el = 0; el < nb_element; ++el) {
     matrix_matrix(m, n, k, A_val, B_val, C_val, alpha);
 
     A_val += offset_A;
     B_val += offset_B;
     C_val += offset_C;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Math::matrix_matrixt(UInt m, UInt n, UInt k, const Array<Real> & A,
                           const Array<Real> & B, Array<Real> & C, Real alpha) {
   AKANTU_DEBUG_IN();
 
-  AKANTU_DEBUG_ASSERT(A.getSize() == B.getSize(),
+  AKANTU_DEBUG_ASSERT(A.size() == B.size(),
                       "The vector A(" << A.getID() << ") and the vector B("
                                       << B.getID()
                                       << ") must have the same size");
 
   AKANTU_DEBUG_ASSERT(A.getNbComponent() == m * k,
                       "The vector A(" << A.getID()
                                       << ") has the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       B.getNbComponent() == k * n,
       "The vector B(" << B.getID() << ") do not the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       C.getNbComponent() == m * n,
       "The vector C(" << C.getID() << ") do not the good number of component.");
 
-  UInt nb_element = A.getSize();
+  UInt nb_element = A.size();
   UInt offset_A = A.getNbComponent();
   UInt offset_B = B.getNbComponent();
   UInt offset_C = C.getNbComponent();
 
   C.resize(nb_element);
 
   Real * A_val = A.storage();
   Real * B_val = B.storage();
   Real * C_val = C.storage();
 
   for (UInt el = 0; el < nb_element; ++el) {
     matrix_matrixt(m, n, k, A_val, B_val, C_val, alpha);
 
     A_val += offset_A;
     B_val += offset_B;
     C_val += offset_C;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Math::compute_tangents(const Array<Real> & normals,
                             Array<Real> & tangents) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = normals.getNbComponent();
   UInt tangent_components = spatial_dimension * (spatial_dimension - 1);
 
   AKANTU_DEBUG_ASSERT(
       tangent_components == tangents.getNbComponent(),
       "Cannot compute the tangents, the storage array for tangents"
           << " does not have the good amount of components.");
 
-  UInt nb_normals = normals.getSize();
+  UInt nb_normals = normals.size();
   tangents.resize(nb_normals);
 
   Real * normal_it = normals.storage();
   Real * tangent_it = tangents.storage();
 
   /// compute first tangent
   for (UInt q = 0; q < nb_normals; ++q) {
     /// if normal is orthogonal to xy plane, arbitrarly define tangent
     if (Math::are_float_equal(Math::norm2(normal_it), 0))
       tangent_it[0] = 1;
     else
       Math::normal2(normal_it, tangent_it);
 
     normal_it += spatial_dimension;
     tangent_it += tangent_components;
   }
 
   /// compute second tangent (3D case)
   if (spatial_dimension == 3) {
     normal_it = normals.storage();
     tangent_it = tangents.storage();
 
     for (UInt q = 0; q < nb_normals; ++q) {
       Math::normal3(normal_it, tangent_it, tangent_it + spatial_dimension);
       normal_it += spatial_dimension;
       tangent_it += tangent_components;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real Math::reduce(Array<Real> & array) {
-  UInt nb_values = array.getSize();
+  UInt nb_values = array.size();
   if (nb_values == 0)
     return 0.;
 
   UInt nb_values_to_sum = nb_values >> 1;
 
   std::sort(array.begin(), array.end());
 
   // as long as the half is not empty
   while (nb_values_to_sum) {
     UInt remaining = (nb_values - 2 * nb_values_to_sum);
     if (remaining)
       array(nb_values - 2) += array(nb_values - 1);
 
     // sum to consecutive values and store the sum in the first half
     for (UInt i = 0; i < nb_values_to_sum; ++i) {
       array(i) = array(2 * i) + array(2 * i + 1);
     }
 
     nb_values = nb_values_to_sum;
     nb_values_to_sum >>= 1;
   }
 
   return array(0);
 }
 
 } // akantu
diff --git a/src/fe_engine/fe_engine_inline_impl.cc b/src/fe_engine/fe_engine_inline_impl.cc
index a4350ad4c..2eb5a757e 100644
--- a/src/fe_engine/fe_engine_inline_impl.cc
+++ b/src/fe_engine/fe_engine_inline_impl.cc
@@ -1,199 +1,199 @@
 /**
  * @file   fe_engine_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jul 20 2010
  * @date last modification: Sat Sep 05 2015
  *
  * @brief  Implementation of the inline functions of the FEEngine Class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "mesh.hh"
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_type_conversion.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_FE_ENGINE_INLINE_IMPL_CC__
 #define __AKANTU_FE_ENGINE_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline Real FEEngine::getElementInradius(const Matrix<Real> & coord,
                                          const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   Real inradius = 0;
 
 #define GET_INRADIUS(type) inradius = ElementClass<type>::getInradius(coord);
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_INRADIUS);
 #undef GET_INRADIUS
 
   AKANTU_DEBUG_OUT();
   return inradius;
 }
 
 /* -------------------------------------------------------------------------- */
 inline InterpolationType
 FEEngine::getInterpolationType(const ElementType & type) {
   return convertType<ElementType, InterpolationType>(type);
 }
 
 /* -------------------------------------------------------------------------- */
 /// @todo rewrite this function in order to get the cohesive element
 /// type directly from the facet
 #if defined(AKANTU_COHESIVE_ELEMENT)
 inline ElementType FEEngine::getCohesiveElementType(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   ElementType ctype;
 #define GET_COHESIVE_TYPE(type)                                                \
   ctype = CohesiveFacetProperty<type>::cohesive_type;
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_COHESIVE_TYPE);
 #undef GET_COHESIVE_TYPE
 
   AKANTU_DEBUG_OUT();
   return ctype;
 }
 #else
 inline ElementType
 FEEngine::getCohesiveElementType(__attribute__((unused))
                                  const ElementType & type_facet) {
   return _not_defined;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_IGFEM)
 } // akantu
 #include "igfem_helper.hh"
 namespace akantu {
 
 inline Vector<ElementType>
 FEEngine::getIGFEMElementTypes(const ElementType & type) {
 
 #define GET_IGFEM_ELEMENT_TYPES(type)                                          \
   return IGFEMHelper::getIGFEMElementTypes<type>();
 
   AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(GET_IGFEM_ELEMENT_TYPES);
 
 #undef GET_IGFEM_ELEMENT_TYPES
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void FEEngine::extractNodalToElementField(const Mesh & mesh,
                                           const Array<T> & nodal_f,
                                           Array<T> & elemental_f,
                                           const ElementType & type,
                                           const GhostType & ghost_type,
                                           const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom = nodal_f.getNbComponent();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt * conn_val = mesh.getConnectivity(type, ghost_type).storage();
 
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
   }
 
   elemental_f.resize(nb_element);
 
   T * nodal_f_val = nodal_f.storage();
   T * f_val = elemental_f.storage();
 
   UInt * el_conn;
   for (UInt el = 0; el < nb_element; ++el) {
     if (filter_elements != empty_filter)
       el_conn = conn_val + filter_elements(el) * nb_nodes_per_element;
     else
       el_conn = conn_val + el * nb_nodes_per_element;
 
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt node = *(el_conn + n);
       std::copy(nodal_f_val + node * nb_degree_of_freedom,
                 nodal_f_val + (node + 1) * nb_degree_of_freedom, f_val);
       f_val += nb_degree_of_freedom;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void FEEngine::filterElementalData(const Mesh & mesh, const Array<T> & elem_f,
                                    Array<T> & filtered_f,
                                    const ElementType & type,
                                    const GhostType & ghost_type,
                                    const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (nb_element == 0) {
     filtered_f.resize(0);
     return;
   }
 
   UInt nb_degree_of_freedom = elem_f.getNbComponent();
-  UInt nb_data_per_element = elem_f.getSize() / nb_element;
+  UInt nb_data_per_element = elem_f.size() / nb_element;
 
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
   }
 
   filtered_f.resize(nb_element * nb_data_per_element);
 
   T * elem_f_val = elem_f.storage();
   T * f_val = filtered_f.storage();
 
   UInt el_offset;
   for (UInt el = 0; el < nb_element; ++el) {
     if (filter_elements != empty_filter)
       el_offset = filter_elements(el);
     else
       el_offset = el;
 
     std::copy(elem_f_val +
                   el_offset * nb_data_per_element * nb_degree_of_freedom,
               elem_f_val +
                   (el_offset + 1) * nb_data_per_element * nb_degree_of_freedom,
               f_val);
     f_val += nb_degree_of_freedom * nb_data_per_element;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
 
 #endif /* __AKANTU_FE_ENGINE_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/fe_engine_template_cohesive.cc b/src/fe_engine/fe_engine_template_cohesive.cc
index 8e98c9058..f65a97684 100644
--- a/src/fe_engine/fe_engine_template_cohesive.cc
+++ b/src/fe_engine/fe_engine_template_cohesive.cc
@@ -1,176 +1,176 @@
 /**
  * @file   fe_engine_template_cohesive.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Oct 31 2012
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Specialization of the FEEngineTemplate for cohesive element
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine_template.hh"
 #include "shape_cohesive.hh"
 #include "integrator_gauss.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* compatibility functions */
 /* -------------------------------------------------------------------------- */
 template <>
 Real FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive,
                       DefaultIntegrationOrderFunctor>::
     integrate(const Array<Real> & f, const ElementType & type,
               const GhostType & ghost_type,
               const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
 #ifndef AKANTU_NDEBUG
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 
-  AKANTU_DEBUG_ASSERT(f.getSize() == nb_element * nb_quadrature_points,
+  AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f(" << f.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == 1,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
 #endif
 
   Real integral = 0.;
 
 #define INTEGRATE(type)                                                        \
   integral = integrator.integrate<type>(f, ghost_type, filter_elements);
 
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(INTEGRATE);
 #undef INTEGRATE
 
   AKANTU_DEBUG_OUT();
   return integral;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive,
                       DefaultIntegrationOrderFunctor>::
     integrate(const Array<Real> & f, Array<Real> & intf,
               UInt nb_degree_of_freedom, const ElementType & type,
               const GhostType & ghost_type,
               const Array<UInt> & filter_elements) const {
 
 #ifndef AKANTU_NDEBUG
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements == filter_elements)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 
-  AKANTU_DEBUG_ASSERT(f.getSize() == nb_element * nb_quadrature_points,
-                      "The vector f(" << f.getID() << " size " << f.getSize()
+  AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
+                      "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
-  AKANTU_DEBUG_ASSERT(intf.getSize() == nb_element,
+  AKANTU_DEBUG_ASSERT(intf.size() == nb_element,
                       "The vector intf(" << intf.getID()
                                          << ") has not the good size.");
 #endif
 
 #define INTEGRATE(type)                                                        \
   integrator.integrate<type>(f, intf, nb_degree_of_freedom, ghost_type,        \
                              filter_elements);
 
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(INTEGRATE);
 #undef INTEGRATE
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive,
                       DefaultIntegrationOrderFunctor>::
     gradientOnIntegrationPoints(const Array<Real> &, Array<Real> &, const UInt,
                                 const ElementType &, const GhostType &,
                                 const Array<UInt> &) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <>
 void FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive,
                       DefaultIntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints<_cohesive_1d_2>(
         const Array<Real> &, Array<Real> & normal,
         const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(
       mesh.getSpatialDimension() == 1,
       "Mesh dimension must be 1 to compute normals on 1D cohesive elements!");
   const ElementType type = _cohesive_1d_2;
   const ElementType facet_type = Mesh::getFacetType(type);
 
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   normal.resize(nb_element);
 
   Array<Element> & facets =
       mesh.getMeshFacets().getSubelementToElement(type, ghost_type);
   Array<std::vector<Element> > & segments =
       mesh.getMeshFacets().getElementToSubelement(facet_type, ghost_type);
 
   Real values[2];
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
 
     for (UInt p = 0; p < 2; ++p) {
       Element f = facets(elem, p);
       Element seg = segments(f.element)[0];
       mesh.getBarycenter(seg.element, seg.type, &(values[p]), seg.ghost_type);
     }
 
     Real difference = values[0] - values[1];
 
     AKANTU_DEBUG_ASSERT(difference != 0.,
                         "Error in normal computation for cohesive elements");
 
     normal(elem) = difference / std::abs(difference);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
diff --git a/src/fe_engine/fe_engine_template_tmpl.hh b/src/fe_engine/fe_engine_template_tmpl.hh
index 2f95e57c5..48637bec3 100644
--- a/src/fe_engine/fe_engine_template_tmpl.hh
+++ b/src/fe_engine/fe_engine_template_tmpl.hh
@@ -1,1301 +1,1301 @@
 /**
  * @file   fe_engine_template_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  Template implementation of FEEngineTemplate
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "dof_manager.hh"
 #include "fe_engine_template.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::FEEngineTemplate(
     Mesh & mesh, UInt spatial_dimension, ID id, MemoryID memory_id)
     : FEEngine(mesh, spatial_dimension, id, memory_id),
       integrator(mesh, id, memory_id), shape_functions(mesh, id, memory_id) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::~FEEngineTemplate() {}
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GradientOnIntegrationPointsHelper {
       template <class S>
       static void call(const S &, Mesh &, const Array<Real> &, Array<Real> &,
                        const UInt, const ElementType &, const GhostType &,
                        const Array<UInt> &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_GRADIENT(type)                                                 \
   if (element_dimension == ElementClass<type>::getSpatialDimension())          \
     shape_functions.template gradientOnIntegrationPoints<type>(                \
         u, nablauq, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER(kind)          \
   template <> struct GradientOnIntegrationPointsHelper<kind> {                 \
     template <class S>                                                         \
     static void call(const S & shape_functions, Mesh & mesh,                   \
                      const Array<Real> & u, Array<Real> & nablauq,             \
                      const UInt nb_degree_of_freedom,                          \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       UInt element_dimension = mesh.getSpatialDimension(type);                 \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_GRADIENT, kind);                \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER,
         AKANTU_FE_ENGINE_LIST_GRADIENT_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_GRADIENT_ON_INTEGRATION_POINTS_HELPER
 #undef COMPUTE_GRADIENT
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     gradientOnIntegrationPoints(const Array<Real> & u, Array<Real> & nablauq,
                                 const UInt nb_degree_of_freedom,
                                 const ElementType & type,
                                 const GhostType & ghost_type,
                                 const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
   UInt nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
 
 #ifndef AKANTU_NDEBUG
 
   UInt element_dimension = mesh.getSpatialDimension(type);
 
-  AKANTU_DEBUG_ASSERT(u.getSize() == mesh.getNbNodes(),
+  AKANTU_DEBUG_ASSERT(u.size() == mesh.getNbNodes(),
                       "The vector u(" << u.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(u.getNbComponent() == nb_degree_of_freedom,
                       "The vector u("
                           << u.getID()
                           << ") has not the good number of component.");
 
   AKANTU_DEBUG_ASSERT(
       nablauq.getNbComponent() == nb_degree_of_freedom * element_dimension,
       "The vector nablauq(" << nablauq.getID()
                             << ") has not the good number of component.");
 
-// AKANTU_DEBUG_ASSERT(nablauq.getSize() == nb_element * nb_points,
+// AKANTU_DEBUG_ASSERT(nablauq.size() == nb_element * nb_points,
 //                  "The vector nablauq(" << nablauq.getID()
 //                  << ") has not the good size.");
 #endif
 
   nablauq.resize(nb_element * nb_points);
 
   fe_engine::details::GradientOnIntegrationPointsHelper<kind>::call(
       shape_functions, mesh, u, nablauq, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::initShapeFunctions(
     const GhostType & ghost_type) {
   initShapeFunctions(mesh.getNodes(), ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::initShapeFunctions(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     integrator.initIntegrator(nodes, type, ghost_type);
     const auto & control_points = getIntegrationPoints(type, ghost_type);
     shape_functions.initShapeFunctions(nodes, control_points, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateHelper {};
 
 #define INTEGRATE(type)                                                        \
   integrator.template integrate<type>(f, intf, nb_degree_of_freedom,           \
                                       ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_HELPER(kind)                               \
   template <> struct IntegrateHelper<kind> {                                   \
     template <class I>                                                         \
     static void call(const I & integrator, const Array<Real> & f,              \
                      Array<Real> & intf, UInt nb_degree_of_freedom,            \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_INTEGRATE_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
     const ElementType & type, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 #ifndef AKANTU_NDEBUG
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 
-  AKANTU_DEBUG_ASSERT(f.getSize() == nb_element * nb_quadrature_points,
-                      "The vector f(" << f.getID() << " size " << f.getSize()
+  AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
+                      "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
 #endif
 
   intf.resize(nb_element);
 
   fe_engine::details::IntegrateHelper<kind>::call(integrator, f, intf,
                                                   nb_degree_of_freedom, type,
                                                   ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateScalarHelper {};
 
 #define INTEGRATE(type)                                                        \
   integral =                                                                   \
       integrator.template integrate<type>(f, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER(kind)                        \
   template <> struct IntegrateScalarHelper<kind> {                             \
     template <class I>                                                         \
     static Real call(const I & integrator, const Array<Real> & f,              \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       Real integral = 0.;                                                      \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
       return integral;                                                         \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_SCALAR_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 Real FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & f, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
 #ifndef AKANTU_NDEBUG
   //   std::stringstream sstr; sstr << ghost_type;
   //   AKANTU_DEBUG_ASSERT(sstr.str() == nablauq.getTag(),
   //                  "The vector " << nablauq.getID() << " is not taged " <<
   //                  ghost_type);
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 
   UInt nb_quadrature_points = getNbIntegrationPoints(type, ghost_type);
 
-  AKANTU_DEBUG_ASSERT(f.getSize() == nb_element * nb_quadrature_points,
+  AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
                       "The vector f("
                           << f.getID() << ") has not the good size. ("
-                          << f.getSize()
+                          << f.size()
                           << "!=" << nb_quadrature_points * nb_element << ")");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == 1,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
 #endif
 
   Real integral = fe_engine::details::IntegrateScalarHelper<kind>::call(
       integrator, f, type, ghost_type, filter_elements);
   AKANTU_DEBUG_OUT();
   return integral;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateScalarOnOneElementHelper {};
 
 #define INTEGRATE(type)                                                        \
   res = integrator.template integrate<type>(f, index, ghost_type);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER(kind)         \
   template <> struct IntegrateScalarOnOneElementHelper<kind> {                 \
     template <class I>                                                         \
     static Real call(const I & integrator, const Vector<Real> & f,             \
                      const ElementType & type, UInt index,                     \
                      const GhostType & ghost_type) {                           \
       Real res = 0.;                                                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
       return res;                                                              \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(
         AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_SCALAR_ON_ONE_ELEMENT_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 Real FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::integrate(
     const Vector<Real> & f, const ElementType & type, UInt index,
     const GhostType & ghost_type) const {
 
   Real res = fe_engine::details::IntegrateScalarOnOneElementHelper<kind>::call(
       integrator, f, type, index, ghost_type);
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct IntegrateOnIntegrationPointsHelper {};
 
 #define INTEGRATE(type)                                                        \
   integrator.template integrateOnIntegrationPoints<type>(                      \
       f, intf, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER(kind)         \
   template <> struct IntegrateOnIntegrationPointsHelper<kind> {                \
     template <class I>                                                         \
     static void call(const I & integrator, const Array<Real> & f,              \
                      Array<Real> & intf, UInt nb_degree_of_freedom,            \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTEGRATE, kind);                       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(
         AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_INTEGRATE_ON_INTEGRATION_POINTS_HELPER
 #undef INTEGRATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     integrateOnIntegrationPoints(const Array<Real> & f, Array<Real> & intf,
                                  UInt nb_degree_of_freedom,
                                  const ElementType & type,
                                  const GhostType & ghost_type,
                                  const Array<UInt> & filter_elements) const {
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
   UInt nb_quadrature_points = getNbIntegrationPoints(type);
 #ifndef AKANTU_NDEBUG
   //   std::stringstream sstr; sstr << ghost_type;
   //   AKANTU_DEBUG_ASSERT(sstr.str() == nablauq.getTag(),
   //                  "The vector " << nablauq.getID() << " is not taged " <<
   //                  ghost_type);
 
-  AKANTU_DEBUG_ASSERT(f.getSize() == nb_element * nb_quadrature_points,
-                      "The vector f(" << f.getID() << " size " << f.getSize()
+  AKANTU_DEBUG_ASSERT(f.size() == nb_element * nb_quadrature_points,
+                      "The vector f(" << f.getID() << " size " << f.size()
                                       << ") has not the good size ("
                                       << nb_element << ").");
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f("
                           << f.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(intf.getNbComponent() == nb_degree_of_freedom,
                       "The vector intf("
                           << intf.getID()
                           << ") has not the good number of component.");
 #endif
 
   intf.resize(nb_element * nb_quadrature_points);
   fe_engine::details::IntegrateOnIntegrationPointsHelper<kind>::call(
       integrator, f, intf, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct InterpolateOnIntegrationPointsHelper {
       template <class S>
       static void call(const S &, const Array<Real> &, Array<Real> &,
                        const UInt, const ElementType &, const GhostType &,
                        const Array<UInt> &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define INTERPOLATE(type)                                                      \
   shape_functions.template interpolateOnIntegrationPoints<type>(               \
       u, uq, nb_degree_of_freedom, ghost_type, filter_elements);
 
 #define AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER(kind)       \
   template <> struct InterpolateOnIntegrationPointsHelper<kind> {              \
     template <class S>                                                         \
     static void call(const S & shape_functions, const Array<Real> & u,         \
                      Array<Real> & uq, const UInt nb_degree_of_freedom,        \
                      const ElementType & type, const GhostType & ghost_type,   \
                      const Array<UInt> & filter_elements) {                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTERPOLATE, kind);                     \
     }                                                                          \
   };
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER,
         AKANTU_FE_ENGINE_LIST_INTERPOLATE_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_INTERPOLATE_ON_INTEGRATION_POINTS_HELPER
 #undef INTERPOLATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateOnIntegrationPoints(const Array<Real> & u, Array<Real> & uq,
                                    const UInt nb_degree_of_freedom,
                                    const ElementType & type,
                                    const GhostType & ghost_type,
                                    const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_points =
       shape_functions.getIntegrationPoints(type, ghost_type).cols();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 #ifndef AKANTU_NDEBUG
 
-  AKANTU_DEBUG_ASSERT(u.getSize() == mesh.getNbNodes(),
+  AKANTU_DEBUG_ASSERT(u.size() == mesh.getNbNodes(),
                       "The vector u(" << u.getID()
                                       << ") has not the good size.");
   AKANTU_DEBUG_ASSERT(u.getNbComponent() == nb_degree_of_freedom,
                       "The vector u("
                           << u.getID()
                           << ") has not the good number of component.");
   AKANTU_DEBUG_ASSERT(uq.getNbComponent() == nb_degree_of_freedom,
                       "The vector uq("
                           << uq.getID()
                           << ") has not the good number of component.");
 #endif
 
   uq.resize(nb_element * nb_points);
 
   fe_engine::details::InterpolateOnIntegrationPointsHelper<kind>::call(
       shape_functions, u, uq, nb_degree_of_freedom, type, ghost_type,
       filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateOnIntegrationPoints(
         const Array<Real> & u, ElementTypeMapArray<Real> & uq,
         const ElementTypeMapArray<UInt> * filter_elements) const {
   AKANTU_DEBUG_IN();
 
   const Array<UInt> * filter = NULL;
 
   for (auto ghost_type : ghost_types) {
     for (auto & type : uq.elementTypes(_all_dimensions, ghost_type, kind)) {
       UInt nb_quad_per_element = getNbIntegrationPoints(type, ghost_type);
 
       UInt nb_element = 0;
 
       if (filter_elements) {
         filter = &((*filter_elements)(type, ghost_type));
-        nb_element = filter->getSize();
+        nb_element = filter->size();
       } else {
         filter = &empty_filter;
         nb_element = mesh.getNbElement(type, ghost_type);
       }
 
       UInt nb_tot_quad = nb_quad_per_element * nb_element;
 
       Array<Real> & quad = uq(type, ghost_type);
       quad.resize(nb_tot_quad);
 
       interpolateOnIntegrationPoints(u, quad, quad.getNbComponent(), type,
                                      ghost_type, *filter);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         ElementTypeMapArray<Real> & quadrature_points_coordinates,
         const ElementTypeMapArray<UInt> * filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
 
   interpolateOnIntegrationPoints(
       nodes_coordinates, quadrature_points_coordinates, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeIntegrationPointsCoordinates(
         Array<Real> & quadrature_points_coordinates, const ElementType & type,
         const GhostType & ghost_type,
         const Array<UInt> & filter_elements) const {
 
   const Array<Real> & nodes_coordinates = mesh.getNodes();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   interpolateOnIntegrationPoints(
       nodes_coordinates, quadrature_points_coordinates, spatial_dimension, type,
       ghost_type, filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     initElementalFieldInterpolationFromIntegrationPoints(
         const ElementTypeMapArray<Real> & interpolation_points_coordinates,
         ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
         ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = this->mesh.getSpatialDimension();
 
   ElementTypeMapArray<Real> quadrature_points_coordinates(
       "quadrature_points_coordinates_for_interpolation", getID(),
       getMemoryID());
 
   quadrature_points_coordinates.initialize(*this,
                                            _nb_component = spatial_dimension);
 
   computeIntegrationPointsCoordinates(quadrature_points_coordinates,
                                       element_filter);
   shape_functions.initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates,
       interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, quadrature_points_coordinates,
       element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateElementalFieldFromIntegrationPoints(
         const ElementTypeMapArray<Real> & field,
         const ElementTypeMapArray<Real> & interpolation_points_coordinates,
         ElementTypeMapArray<Real> & result, const GhostType ghost_type,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   ElementTypeMapArray<Real> interpolation_points_coordinates_matrices(
       "interpolation_points_coordinates_matrices", id, memory_id);
   ElementTypeMapArray<Real> quad_points_coordinates_inv_matrices(
       "quad_points_coordinates_inv_matrices", id, memory_id);
 
   initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates,
       interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, element_filter);
 
   interpolateElementalFieldFromIntegrationPoints(
       field, interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, result, ghost_type, element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     interpolateElementalFieldFromIntegrationPoints(
         const ElementTypeMapArray<Real> & field,
         const ElementTypeMapArray<Real> &
             interpolation_points_coordinates_matrices,
         const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
         ElementTypeMapArray<Real> & result, const GhostType ghost_type,
         const ElementTypeMapArray<UInt> * element_filter) const {
 
   shape_functions.interpolateElementalFieldFromIntegrationPoints(
       field, interpolation_points_coordinates_matrices,
       quad_points_coordinates_inv_matrices, result, ghost_type, element_filter);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct InterpolateHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt,
                        const Matrix<Real> &, Vector<Real> &,
                        const ElementType &, const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define INTERPOLATE(type)                                                      \
   shape_functions.template interpolate<type>(                                  \
       real_coords, element, nodal_values, interpolated, ghost_type);
 
 #define AKANTU_SPECIALIZE_INTERPOLATE_HELPER(kind)                             \
   template <> struct InterpolateHelper<kind> {                                 \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const Matrix<Real> & nodal_values,                        \
                      Vector<Real> & interpolated, const ElementType & type,    \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INTERPOLATE, kind);                     \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_INTERPOLATE_HELPER,
                                AKANTU_FE_ENGINE_LIST_INTERPOLATE)
 
 #undef AKANTU_SPECIALIZE_INTERPOLATE_HELPER
 #undef INTERPOLATE
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::interpolate(
     const Vector<Real> & real_coords, const Matrix<Real> & nodal_values,
     Vector<Real> & interpolated, const Element & element) const {
 
   AKANTU_DEBUG_IN();
 
   fe_engine::details::InterpolateHelper<kind>::call(
       shape_functions, real_coords, element.element, nodal_values, interpolated,
       element.type, element.ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   computeNormalsOnIntegrationPoints(mesh.getNodes(), ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   //  Real * coord = mesh.getNodes().storage();
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   // allocate the normal arrays
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     UInt size = mesh.getNbElement(type, ghost_type);
     if (normals_on_integration_points.exists(type, ghost_type)) {
       normals_on_integration_points(type, ghost_type).resize(size);
     } else {
       normals_on_integration_points.alloc(size, spatial_dimension, type,
                                           ghost_type);
     }
   }
 
   // loop over the type to build the normals
   for (auto & type : mesh.elementTypes(element_dimension, ghost_type, kind)) {
     Array<Real> & normals_on_quad =
         normals_on_integration_points(type, ghost_type);
     computeNormalsOnIntegrationPoints(field, normals_on_quad, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeNormalsOnIntegrationPoints {
       template <template <ElementKind, class> class I,
                 template <ElementKind> class S, ElementKind k, class IOF>
       static void call(const FEEngineTemplate<I, S, k, IOF> &,
                        const Array<Real> &, Array<Real> &, const ElementType &,
                        const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_NORMALS_ON_INTEGRATION_POINTS(type)                            \
   fem.template computeNormalsOnIntegrationPoints<type>(field, normal,          \
                                                        ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS(kind)          \
   template <> struct ComputeNormalsOnIntegrationPoints<kind> {                 \
     template <template <ElementKind, class> class I,                           \
               template <ElementKind> class S, ElementKind k, class IOF>        \
     static void call(const FEEngineTemplate<I, S, k, IOF> & fem,               \
                      const Array<Real> & field, Array<Real> & normal,          \
                      const ElementType & type, const GhostType & ghost_type) { \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_NORMALS_ON_INTEGRATION_POINTS,  \
                                        kind);                                  \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS,
         AKANTU_FE_ENGINE_LIST_COMPUTE_NORMALS_ON_INTEGRATION_POINTS)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_NORMALS_ON_INTEGRATION_POINTS
 #undef COMPUTE_NORMALS_ON_INTEGRATION_POINTS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       Array<Real> & normal,
                                       const ElementType & type,
                                       const GhostType & ghost_type) const {
   fe_engine::details::ComputeNormalsOnIntegrationPoints<kind>::call(
       *this, field, normal, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                       Array<Real> & normal,
                                       const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   if(type == _point_1) {
     computeNormalsOnIntegrationPointsPoint1(field, normal, ghost_type);
     return;
   }
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_points = getNbIntegrationPoints(type, ghost_type);
 
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   normal.resize(nb_element * nb_points);
   Array<Real>::matrix_iterator normals_on_quad =
       normal.begin_reinterpret(spatial_dimension, nb_points, nb_element);
   Array<Real> f_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, field, f_el, type, ghost_type);
 
   const Matrix<Real> & quads =
       integrator.template getIntegrationPoints<type>(ghost_type);
 
   Array<Real>::matrix_iterator f_it =
       f_el.begin(spatial_dimension, nb_nodes_per_element);
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     ElementClass<type>::computeNormalsOnNaturalCoordinates(quads, *f_it,
                                                            *normals_on_quad);
     ++normals_on_quad;
     ++f_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 template <ElementKind kind> struct InverseMapHelper {
   template <class S>
   static void call(const S & shape_functions, const Vector<Real> & real_coords,
                    UInt element, const ElementType & type,
                    Vector<Real> & natural_coords,
                    const GhostType & ghost_type) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 };
 
 #define INVERSE_MAP(type)                                                      \
   shape_functions.template inverseMap<type>(real_coords, element,              \
                                             natural_coords, ghost_type);
 
 #define AKANTU_SPECIALIZE_INVERSE_MAP_HELPER(kind)                             \
   template <> struct InverseMapHelper<kind> {                                  \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType & type, Vector<Real> & natural_coords,  \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INVERSE_MAP, kind);                     \
     }                                                                          \
   };
 
 AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_INVERSE_MAP_HELPER,
                            AKANTU_FE_ENGINE_LIST_INVERSE_MAP)
 
 #undef AKANTU_SPECIALIZE_INVERSE_MAP_HELPER
 #undef INVERSE_MAP
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::inverseMap(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Vector<Real> & natural_coords, const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   InverseMapHelper<kind>::call(shape_functions, real_coords, element, type,
                                natural_coords, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ContainsHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt,
                        const ElementType &, const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define CONTAINS(type)                                                         \
   contain = shape_functions.template contains<type>(real_coords, element,      \
                                                     ghost_type);
 
 #define AKANTU_SPECIALIZE_CONTAINS_HELPER(kind)                                \
   template <> struct ContainsHelper<kind> {                                    \
     template <template <ElementKind> class S, ElementKind k>                   \
     static bool call(const S<k> & shape_functions,                             \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType & type, const GhostType & ghost_type) { \
       bool contain = false;                                                    \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(CONTAINS, kind);                        \
       return contain;                                                          \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_CONTAINS_HELPER,
                                AKANTU_FE_ENGINE_LIST_CONTAINS)
 
 #undef AKANTU_SPECIALIZE_CONTAINS_HELPER
 #undef CONTAINS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline bool FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::contains(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     const GhostType & ghost_type) const {
   return fe_engine::details::ContainsHelper<kind>::call(
       shape_functions, real_coords, element, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeShapesHelper {
       template <class S>
       static void call(const S &, const Vector<Real> &, UInt, const ElementType,
                        Vector<Real> &, const GhostType &) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_SHAPES(type)                                                   \
   shape_functions.template computeShapes<type>(real_coords, element, shapes,   \
                                                ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER(kind)                          \
   template <> struct ComputeShapesHelper<kind> {                               \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType type, Vector<Real> & shapes,            \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_SHAPES, kind);                  \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER,
                                AKANTU_FE_ENGINE_LIST_COMPUTE_SHAPES)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_SHAPES_HELPER
 #undef COMPUTE_SHAPES
   } // namespace details
 } // namespace fe_engine
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeShapes(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Vector<Real> & shapes, const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   fe_engine::details::ComputeShapesHelper<kind>::call(
       shape_functions, real_coords, element, type, shapes, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct ComputeShapeDerivativesHelper {
       template <class S>
       static void call(__attribute__((unused)) const S & shape_functions,
                        __attribute__((unused)) const Vector<Real> & real_coords,
                        __attribute__((unused)) UInt element,
                        __attribute__((unused)) const ElementType type,
                        __attribute__((unused)) Matrix<Real> & shape_derivatives,
                        __attribute__((unused)) const GhostType & ghost_type) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define COMPUTE_SHAPE_DERIVATIVES(type)                                        \
   Matrix<Real> coords_mat(real_coords.storage(), shape_derivatives.rows(), 1); \
   Tensor3<Real> shapesd_tensor(shape_derivatives.storage(),                    \
                                shape_derivatives.rows(),                       \
                                shape_derivatives.cols(), 1);                   \
   shape_functions.template computeShapeDerivatives<type>(                      \
       coords_mat, element, shapesd_tensor, ghost_type);
 
 #define AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER(kind)               \
   template <> struct ComputeShapeDerivativesHelper<kind> {                     \
     template <class S>                                                         \
     static void call(const S & shape_functions,                                \
                      const Vector<Real> & real_coords, UInt element,           \
                      const ElementType type, Matrix<Real> & shape_derivatives, \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(COMPUTE_SHAPE_DERIVATIVES, kind);       \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(
         AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER,
         AKANTU_FE_ENGINE_LIST_COMPUTE_SHAPES_DERIVATIVES)
 
 #undef AKANTU_SPECIALIZE_COMPUTE_SHAPE_DERIVATIVES_HELPER
 #undef COMPUTE_SHAPE_DERIVATIVES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::computeShapeDerivatives(
     const Vector<Real> & real_coords, UInt element, const ElementType & type,
     Matrix<Real> & shape_derivatives, const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   fe_engine::details::ComputeShapeDerivativesHelper<kind>::call(
       shape_functions, real_coords, element, type, shape_derivatives,
       ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetNbIntegrationPointsHelper {};
 
 #define GET_NB_INTEGRATION_POINTS(type)                                        \
   nb_quad_points = integrator.template getNbIntegrationPoints<type>(ghost_type);
 
 #define AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER(kind)               \
   template <> struct GetNbIntegrationPointsHelper<kind> {                      \
     template <template <ElementKind, class> class I, ElementKind k, class IOF> \
     static UInt call(const I<k, IOF> & integrator, const ElementType type,     \
                      const GhostType & ghost_type) {                           \
       UInt nb_quad_points = 0;                                                 \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_NB_INTEGRATION_POINTS, kind);       \
       return nb_quad_points;                                                   \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_NB_INTEGRATION_POINTS_HELPER
 #undef GET_NB_INTEGRATION
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline UInt
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getNbIntegrationPoints(
     const ElementType & type, const GhostType & ghost_type) const {
   return fe_engine::details::GetNbIntegrationPointsHelper<kind>::call(
       integrator, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetShapesHelper {};
 
 #define GET_SHAPES(type) ret = &(shape_functions.getShapes(type, ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_SHAPES_HELPER(kind)                              \
   template <> struct GetShapesHelper<kind> {                                   \
     template <class S>                                                         \
     static const Array<Real> & call(const S & shape_functions,                 \
                                     const ElementType type,                    \
                                     const GhostType & ghost_type) {            \
       const Array<Real> * ret = NULL;                                          \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_SHAPES, kind);                      \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_SHAPES_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_SHAPES_HELPER
 #undef GET_SHAPES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Array<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getShapes(
     const ElementType & type, const GhostType & ghost_type,
     __attribute__((unused)) UInt id) const {
   return fe_engine::details::GetShapesHelper<kind>::call(shape_functions, type,
                                                          ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetShapesDerivativesHelper {
       template <template <ElementKind> class S, ElementKind k>
       static const Array<Real> & call(const S<k> &, const ElementType &,
                                       const GhostType &, UInt) {
         AKANTU_DEBUG_TO_IMPLEMENT();
       }
     };
 
 #define GET_SHAPES_DERIVATIVES(type)                                           \
   ret = &(shape_functions.getShapesDerivatives(type, ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_SHAPES_DERIVATIVES_HELPER(kind)                  \
   template <> struct GetShapesDerivativesHelper<kind> {                        \
     template <template <ElementKind> class S, ElementKind k>                   \
     static const Array<Real> &                                                 \
     call(const S<k> & shape_functions, const ElementType type,                 \
          const GhostType & ghost_type, __attribute__((unused)) UInt id) {      \
       const Array<Real> * ret = NULL;                                          \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_SHAPES_DERIVATIVES, kind);          \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND_LIST(AKANTU_SPECIALIZE_GET_SHAPES_DERIVATIVES_HELPER,
                                AKANTU_FE_ENGINE_LIST_GET_SHAPES_DERIVATIVES)
 
 #undef AKANTU_SPECIALIZE_GET_SHAPE_DERIVATIVES_HELPER
 #undef GET_SHAPES_DERIVATIVES
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Array<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getShapesDerivatives(
     const ElementType & type, const GhostType & ghost_type,
     __attribute__((unused)) UInt id) const {
   return fe_engine::details::GetShapesDerivativesHelper<kind>::call(
       shape_functions, type, ghost_type, id);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct GetIntegrationPointsHelper {};
 
 #define GET_INTEGRATION_POINTS(type)                                           \
   ret = &(integrator.template getIntegrationPoints<type>(ghost_type));
 
 #define AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER(kind)                  \
   template <> struct GetIntegrationPointsHelper<kind> {                        \
     template <template <ElementKind, class> class I, ElementKind k, class IOF> \
     static const Matrix<Real> & call(const I<k, IOF> & integrator,             \
                                      const ElementType type,                   \
                                      const GhostType & ghost_type) {           \
       const Matrix<Real> * ret = NULL;                                         \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_INTEGRATION_POINTS, kind);          \
       return *ret;                                                             \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER)
 
 #undef AKANTU_SPECIALIZE_GET_INTEGRATION_POINTS_HELPER
 #undef GET_INTEGRATION_POINTS
   } // namespace details
 } // namespace fe_engine
 
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline const Matrix<Real> &
 FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::getIntegrationPoints(
     const ElementType & type, const GhostType & ghost_type) const {
   return fe_engine::details::GetIntegrationPointsHelper<kind>::call(
       integrator, type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::printself(
     std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "FEEngineTemplate [" << std::endl;
   stream << space << " + parent [" << std::endl;
   FEEngine::printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << " + shape functions [" << std::endl;
   shape_functions.printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << " + integrator [" << std::endl;
   integrator.printself(stream, indent + 3);
   stream << space << "   ]" << std::endl;
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsAdded(
     const Array<Element> & new_elements, const NewElementsEvent &) {
   integrator.onElementsAdded(new_elements);
   shape_functions.onElementsAdded(new_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsRemoved(
     const Array<Element> &, const ElementTypeMapArray<UInt> &,
     const RemovedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::onElementsChanged(
     const Array<Element> &, const Array<Element> &,
     const ElementTypeMapArray<UInt> &, const ChangedElementsEvent &) {}
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 inline void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     computeNormalsOnIntegrationPointsPoint1(
         const Array<Real> &, Array<Real> & normal,
         const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(mesh.getSpatialDimension() == 1,
                       "Mesh dimension must be 1 to compute normals on points!");
   const ElementType type = _point_1;
   UInt spatial_dimension = mesh.getSpatialDimension();
   // UInt nb_nodes_per_element  = Mesh::getNbNodesPerElement(type);
   UInt nb_points = getNbIntegrationPoints(type, ghost_type);
 
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   normal.resize(nb_element * nb_points);
   Array<Real>::matrix_iterator normals_on_quad =
       normal.begin_reinterpret(spatial_dimension, nb_points, nb_element);
   const Array<std::vector<Element>> & segments =
       mesh.getElementToSubelement(type, ghost_type);
   const Array<Real> & coords = mesh.getNodes();
 
   const Mesh * mesh_segment;
   if (mesh.isMeshFacets())
     mesh_segment = &(mesh.getMeshParent());
   else
     mesh_segment = &mesh;
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     UInt nb_segment = segments(elem).size();
 
     AKANTU_DEBUG_ASSERT(
         nb_segment > 0,
         "Impossible to compute a normal on a point connected to 0 segments");
 
     Real normal_value = 1;
     if (nb_segment == 1) {
       const Element & segment = segments(elem)[0];
       const Array<UInt> & segment_connectivity =
           mesh_segment->getConnectivity(segment.type, segment.ghost_type);
       // const Vector<UInt> & segment_points =
       // segment_connectivity.begin(Mesh::getNbNodesPerElement(segment.type))[segment.element];
       Real difference;
       if (segment_connectivity(0) == elem) {
         difference = coords(elem) - coords(segment_connectivity(1));
       } else {
         difference = coords(elem) - coords(segment_connectivity(0));
       }
       normal_value = difference / std::abs(difference);
     }
 
     for (UInt n(0); n < nb_points; ++n) {
       (*normals_on_quad)(0, n) = normal_value;
     }
     ++normals_on_quad;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/fe_engine_template_tmpl_field.hh b/src/fe_engine/fe_engine_template_tmpl_field.hh
index 2ffca27e8..225c145ec 100644
--- a/src/fe_engine/fe_engine_template_tmpl_field.hh
+++ b/src/fe_engine/fe_engine_template_tmpl_field.hh
@@ -1,428 +1,428 @@
 /**
  * @file   fe_engine_template_tmpl_field.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  Tue Jul 25 2017
  *
  * @brief implementation of the assemble field s functions
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fe_engine_template.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_FE_ENGINE_TEMPLATE_TMPL_FIELD_HH__
 #define __AKANTU_FE_ENGINE_TEMPLATE_TMPL_FIELD_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Matrix lumping functions                                                   */
 /* -------------------------------------------------------------------------- */
 namespace fe_engine {
   namespace details {
     namespace {
       template <class Functor>
       void fillField(const Functor & field_funct, Array<Real> & field,
                      UInt nb_element, UInt nb_integration_points,
                      const ElementType & type, const GhostType & ghost_type) {
         UInt nb_degree_of_freedom = field.getNbComponent();
         field.resize(nb_integration_points * nb_element);
 
         auto field_it = field.begin_reinterpret(
             nb_degree_of_freedom, nb_integration_points, nb_element);
 
         Element el(type, 0, ghost_type);
         for (; el.element < nb_element; ++el.element, ++field_it) {
           field_funct(*field_it, el);
         }
       }
     } // namespace
   }   // namespace details
 } // namespace fe_engine
 
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct AssembleLumpedTemplateHelper {};
 
 #define ASSEMBLE_LUMPED(type)                                                  \
   fem.template assembleFieldLumped<Functor, type>(field_funct, lumped, dof_id, \
                                                   dof_manager, ghost_type)
 
 #define AKANTU_SPECIALIZE_ASSEMBLE_HELPER(kind)                                \
   template <> struct AssembleLumpedTemplateHelper<kind> {                      \
     template <template <ElementKind, class> class I,                           \
               template <ElementKind> class S, ElementKind k, class IOF,        \
               class Functor>                                                   \
     static void call(const FEEngineTemplate<I, S, k, IOF> & fem,               \
                      const Functor & field_funct, const ID & lumped,           \
                      const ID & dof_id, DOFManager & dof_manager,              \
                      ElementType type, const GhostType & ghost_type) {         \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(ASSEMBLE_LUMPED, kind);                 \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_ASSEMBLE_HELPER)
 
 #undef AKANTU_SPECIALIZE_ASSEMBLE_HELPER
 #undef ASSEMBLE_LUMPED
   } // namespace details
 } // namespace fe_engine
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IOF>
 template <class Functor>
 void FEEngineTemplate<I, S, kind, IOF>::assembleFieldLumped(
     const Functor & field_funct, const ID & matrix_id, const ID & dof_id,
     DOFManager & dof_manager, ElementType type,
     const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   fe_engine::details::AssembleLumpedTemplateHelper<kind>::call(
       *this, field_funct, matrix_id, dof_id, dof_manager, type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <class Functor, ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::assembleFieldLumped(
     const Functor & field_funct, const ID & matrix_id, const ID & dof_id,
     DOFManager & dof_manager, const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_degree_of_freedom = dof_manager.getDOFs(dof_id).getNbComponent();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt nb_integration_points = this->getNbIntegrationPoints(type);
 
   Array<Real> field(0, nb_degree_of_freedom);
   fe_engine::details::fillField(field_funct, field, nb_element,
                                 nb_integration_points, type, ghost_type);
 
   switch (type) {
   case _triangle_6:
   case _quadrangle_8:
   case _tetrahedron_10:
   case _hexahedron_20:
   case _pentahedron_15:
     this->template assembleLumpedDiagonalScaling<type>(field, matrix_id, dof_id,
                                                        dof_manager, ghost_type);
   default:
     this->template assembleLumpedRowSum<type>(field, matrix_id, dof_id,
                                               dof_manager, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j dV =
  * \int \rho \varphi_i dV @f$
  */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     assembleLumpedRowSum(const Array<Real> & field, const ID & matrix_id,
                          const ID & dof_id, DOFManager & dof_manager,
                          const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   UInt shapes_size = ElementClass<type>::getShapeSize();
   UInt nb_degree_of_freedom = field.getNbComponent();
 
   Array<Real> * field_times_shapes =
       new Array<Real>(0, shapes_size * nb_degree_of_freedom);
 
   shape_functions.template fieldTimesShapes<type>(field, *field_times_shapes,
                                                   ghost_type);
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   Array<Real> * int_field_times_shapes = new Array<Real>(
       nb_element, shapes_size * nb_degree_of_freedom, "inte_rho_x_shapes");
 
   integrator.template integrate<type>(
       *field_times_shapes, *int_field_times_shapes,
       nb_degree_of_freedom * shapes_size, ghost_type, empty_filter);
 
   delete field_times_shapes;
 
   dof_manager.assembleElementalArrayToLumpedMatrix(
       dof_id, *int_field_times_shapes, matrix_id, type, ghost_type);
 
   delete int_field_times_shapes;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * @f$ \tilde{M}_{i} = c * M_{ii} = \int_{V_e} \rho dV @f$
  */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::
     assembleLumpedDiagonalScaling(const Array<Real> & field,
                                   const ID & matrix_id, const ID & dof_id,
                                   DOFManager & dof_manager,
                                   const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   const ElementType & type_p1 = ElementClass<type>::getP1ElementType();
   UInt nb_nodes_per_element_p1 = Mesh::getNbNodesPerElement(type_p1);
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom = field.getNbComponent();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
 
   Vector<Real> nodal_factor(nb_nodes_per_element);
 
 #define ASSIGN_WEIGHT_TO_NODES(corner, mid)                                    \
   {                                                                            \
     for (UInt n = 0; n < nb_nodes_per_element_p1; n++)                         \
       nodal_factor(n) = corner;                                                \
     for (UInt n = nb_nodes_per_element_p1; n < nb_nodes_per_element; n++)      \
       nodal_factor(n) = mid;                                                   \
   }
 
   if (type == _triangle_6)
     ASSIGN_WEIGHT_TO_NODES(1. / 12., 1. / 4.);
   if (type == _tetrahedron_10)
     ASSIGN_WEIGHT_TO_NODES(1. / 32., 7. / 48.);
   if (type == _quadrangle_8)
     ASSIGN_WEIGHT_TO_NODES(
         3. / 76.,
         16. / 76.); /** coeff. derived by scaling
                      * the diagonal terms of the corresponding
                      * consistent mass computed with 3x3 gauss points;
                      * coeff. are (1./36., 8./36.) for 2x2 gauss points */
   if (type == _hexahedron_20)
     ASSIGN_WEIGHT_TO_NODES(
         7. / 248.,
         16. / 248.); /** coeff. derived by scaling
                       * the diagonal terms of the corresponding
                       * consistent mass computed with 3x3x3 gauss points;
                       * coeff. are (1./40.,
                       * 1./15.) for 2x2x2 gauss points */
   if (type == _pentahedron_15) {
     // coefficients derived by scaling the diagonal terms of the corresponding
     // consistent mass computed with 8 gauss points;
     for (UInt n = 0; n < nb_nodes_per_element_p1; n++)
       nodal_factor(n) = 51. / 2358.;
 
     Real mid_triangle = 192. / 2358.;
     Real mid_quadrangle = 300. / 2358.;
 
     nodal_factor(6) = mid_triangle;
     nodal_factor(7) = mid_triangle;
     nodal_factor(8) = mid_triangle;
     nodal_factor(9) = mid_quadrangle;
     nodal_factor(10) = mid_quadrangle;
     nodal_factor(11) = mid_quadrangle;
     nodal_factor(12) = mid_triangle;
     nodal_factor(13) = mid_triangle;
     nodal_factor(14) = mid_triangle;
   }
 
   if (nb_element == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
 #undef ASSIGN_WEIGHT_TO_NODES
 
   /// compute @f$ \int \rho dV = \rho V @f$ for each element
   Array<Real> * int_field =
-      new Array<Real>(field.getSize(), nb_degree_of_freedom, "inte_rho_x");
+      new Array<Real>(field.size(), nb_degree_of_freedom, "inte_rho_x");
   integrator.template integrate<type>(field, *int_field, nb_degree_of_freedom,
                                       ghost_type, empty_filter);
 
   /// distribute the mass of the element to the nodes
   Array<Real> * lumped_per_node = new Array<Real>(
       nb_element, nb_degree_of_freedom * nb_nodes_per_element, "mass_per_node");
   Array<Real>::const_vector_iterator int_field_it =
       int_field->begin(nb_degree_of_freedom);
   Array<Real>::matrix_iterator lumped_per_node_it =
       lumped_per_node->begin(nb_degree_of_freedom, nb_nodes_per_element);
 
   for (UInt e = 0; e < nb_element; ++e) {
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       Vector<Real> l = (*lumped_per_node_it)(n);
       l = *int_field_it;
       l *= nodal_factor(n);
     }
     ++int_field_it;
     ++lumped_per_node_it;
   }
   delete int_field;
 
   dof_manager.assembleElementalArrayToLumpedMatrix(dof_id, *lumped_per_node,
                                                    matrix_id, type, ghost_type);
   delete lumped_per_node;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Helper class to be able to write a partial specialization on the element kind
  */
 namespace fe_engine {
   namespace details {
     template <ElementKind kind> struct AssembleFieldMatrixHelper {};
 
 #define ASSEMBLE_MATRIX(type)                                                  \
   fem.template assembleFieldMatrix<Functor, type>(                             \
       field_funct, matrix_id, dof_id, dof_manager, ghost_type)
 
 #define AKANTU_SPECIALIZE_ASSEMBLE_FIELD_MATRIX_HELPER(kind)                   \
   template <> struct AssembleFieldMatrixHelper<kind> {                         \
     template <template <ElementKind, class> class I,                           \
               template <ElementKind> class S, ElementKind k, class IOF,        \
               class Functor>                                                   \
     static void call(const FEEngineTemplate<I, S, k, IOF> & fem,               \
                      const Functor & field_funct, const ID & matrix_id,        \
                      const ID & dof_id, DOFManager & dof_manager,              \
                      ElementType type, const GhostType & ghost_type) {         \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(ASSEMBLE_MATRIX, kind);                 \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_SPECIALIZE_ASSEMBLE_FIELD_MATRIX_HELPER)
 
 #undef AKANTU_SPECIALIZE_ASSEMBLE_FIELD_MATRIX_HELPER
 #undef ASSEMBLE_MATRIX
   } // namespace details
 } // namespace fe_engine
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IOF>
 template <class Functor>
 void FEEngineTemplate<I, S, kind, IOF>::assembleFieldMatrix(
     const Functor & field_funct, const ID & matrix_id, const ID & dof_id,
     DOFManager & dof_manager, ElementType type,
     const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
   fe_engine::details::AssembleFieldMatrixHelper<kind>::template call(
       *this, field_funct, matrix_id, dof_id, dof_manager, type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j dV =
  * \int \rho \varphi_i dV @f$
  */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind, class IntegrationOrderFunctor>
 template <class Functor, ElementType type>
 void FEEngineTemplate<I, S, kind, IntegrationOrderFunctor>::assembleFieldMatrix(
     const Functor & field_funct, const ID & matrix_id, const ID & dof_id,
     DOFManager & dof_manager, const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   UInt shapes_size = ElementClass<type>::getShapeSize();
   UInt nb_degree_of_freedom = dof_manager.getDOFs(dof_id).getNbComponent();
   UInt lmat_size = nb_degree_of_freedom * shapes_size;
   UInt nb_element = mesh.getNbElement(type, ghost_type);
 
   // \int N * N  so degree 2 * degree of N
   const UInt polynomial_degree =
       2 * ElementClassProperty<type>::polynomial_degree;
 
   // getting the integration points
   Matrix<Real> integration_points =
       integrator.template getIntegrationPoints<type, polynomial_degree>();
 
   UInt nb_integration_points = integration_points.cols();
   UInt vect_size = nb_integration_points * nb_element;
 
   // getting the shapes on the integration points
   Array<Real> shapes(0, shapes_size);
   shape_functions.template computeShapesOnIntegrationPoints<type>(
       mesh.getNodes(), integration_points, shapes, ghost_type);
 
   // Extending the shape functions
   Array<Real> modified_shapes(vect_size, lmat_size * nb_degree_of_freedom, 0.);
   Array<Real> local_mat(vect_size, lmat_size * lmat_size);
   auto mshapes_it = modified_shapes.begin(nb_degree_of_freedom, lmat_size);
   auto shapes_it = shapes.begin(shapes_size);
 
   for (UInt q = 0; q < vect_size; ++q, ++mshapes_it, ++shapes_it) {
     for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
       for (UInt s = 0; s < shapes_size; ++s) {
         (*mshapes_it)(d, s * nb_degree_of_freedom + d) = (*shapes_it)(s);
       }
     }
   }
 
   // getting the value to assemble on the integration points
   Array<Real> field(vect_size, nb_degree_of_freedom);
   fe_engine::details::fillField(field_funct, field, nb_element,
                                 nb_integration_points, type, ghost_type);
 
   // computing \rho * N
   mshapes_it = modified_shapes.begin(nb_degree_of_freedom, lmat_size);
   auto lmat = local_mat.begin(lmat_size, lmat_size);
   auto field_it =
-      field.begin_reinterpret(nb_degree_of_freedom, field.getSize());
+      field.begin_reinterpret(nb_degree_of_freedom, field.size());
 
   for (UInt q = 0; q < vect_size; ++q, ++lmat, ++mshapes_it, ++field_it) {
     const auto & rho = *field_it;
     const auto & N = *mshapes_it;
     auto & mat = *lmat;
 
     Matrix<Real> Nt = N.transpose();
     for (UInt d = 0; d < Nt.cols(); ++d) {
       Nt(d) *= rho(d);
     }
 
     mat.mul<false, false>(Nt, N);
   }
 
   // integrate the elemental values
   Array<Real> int_field_times_shapes(nb_element, lmat_size * lmat_size,
                                      "inte_rho_x_shapes");
   this->integrator.template integrate<type, polynomial_degree>(
       local_mat, int_field_times_shapes, lmat_size * lmat_size, ghost_type);
 
   // assemble the elemental values to the matrix
   dof_manager.assembleElementalMatricesToMatrix(
       matrix_id, dof_id, int_field_times_shapes, type, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_FE_ENGINE_TEMPLATE_TMPL_FIELD_HH__ */
diff --git a/src/fe_engine/integrator_gauss_inline_impl.cc b/src/fe_engine/integrator_gauss_inline_impl.cc
index e1a987fb7..d066b82fc 100644
--- a/src/fe_engine/integrator_gauss_inline_impl.cc
+++ b/src/fe_engine/integrator_gauss_inline_impl.cc
@@ -1,645 +1,645 @@
 /**
  * @file   integrator_gauss_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Feb 15 2011
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  inline function of gauss integrator
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "mesh_iterators.hh"
 #if defined(AKANTU_DEBUG_TOOLS)
 #include "aka_debug_tools.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::integrateOnElement(
     const Array<Real> & f, Real * intf, UInt nb_degree_of_freedom,
     const UInt elem, const GhostType & ghost_type) const {
   Array<Real> & jac_loc = jacobians(type, ghost_type);
 
   UInt nb_quadrature_points = ElementClass<type>::getNbQuadraturePoints();
   AKANTU_DEBUG_ASSERT(f.getNbComponent() == nb_degree_of_freedom,
                       "The vector f do not have the good number of component.");
 
   Real * f_val = f.storage() + elem * f.getNbComponent();
   Real * jac_val = jac_loc.storage() + elem * nb_quadrature_points;
 
   integrate(f_val, jac_val, intf, nb_degree_of_freedom, nb_quadrature_points);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline Real IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Vector<Real> & in_f, UInt index, const GhostType & ghost_type) const {
   const Array<Real> & jac_loc = jacobians(type, ghost_type);
 
   UInt nb_quadrature_points =
       GaussIntegrationElement<type>::getNbQuadraturePoints();
   AKANTU_DEBUG_ASSERT(in_f.size() == nb_quadrature_points,
                       "The vector f do not have nb_quadrature_points entries.");
 
   Real * jac_val = jac_loc.storage() + index * nb_quadrature_points;
   Real intf;
 
   integrate(in_f.storage(), jac_val, &intf, 1, nb_quadrature_points);
 
   return intf;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     Real * f, Real * jac, Real * inte, UInt nb_degree_of_freedom,
     UInt nb_quadrature_points) const {
   memset(inte, 0, nb_degree_of_freedom * sizeof(Real));
 
   Real * cjac = jac;
   for (UInt q = 0; q < nb_quadrature_points; ++q) {
     for (UInt dof = 0; dof < nb_degree_of_freedom; ++dof) {
       inte[dof] += *f * *cjac;
       ++f;
     }
     ++cjac;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline const Matrix<Real> &
 IntegratorGauss<kind, IntegrationOrderFunctor>::getIntegrationPoints(
     const GhostType & ghost_type) const {
   AKANTU_DEBUG_ASSERT(
       quadrature_points.exists(type, ghost_type),
       "Quadrature points for type "
           << quadrature_points.printType(type, ghost_type)
           << " have not been initialized."
           << " Did you use 'computeQuadraturePoints' function ?");
   return quadrature_points(type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline UInt
 IntegratorGauss<kind, IntegrationOrderFunctor>::getNbIntegrationPoints(
     const GhostType & ghost_type) const {
   AKANTU_DEBUG_ASSERT(
       quadrature_points.exists(type, ghost_type),
       "Quadrature points for type "
           << quadrature_points.printType(type, ghost_type)
           << " have not been initialized."
           << " Did you use 'computeQuadraturePoints' function ?");
   return quadrature_points(type, ghost_type).cols();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, UInt polynomial_degree>
 inline Matrix<Real>
 IntegratorGauss<kind, IntegrationOrderFunctor>::getIntegrationPoints() const {
   return GaussIntegrationElement<type,
                                  polynomial_degree>::getQuadraturePoints();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, UInt polynomial_degree>
 inline Vector<Real>
 IntegratorGauss<kind, IntegrationOrderFunctor>::getIntegrationWeights() const {
   return GaussIntegrationElement<type, polynomial_degree>::getWeights();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void
 IntegratorGauss<kind, IntegrationOrderFunctor>::computeQuadraturePoints(
     const GhostType & ghost_type) {
   Matrix<Real> & quads = quadrature_points(type, ghost_type);
   const UInt polynomial_degree =
       IntegrationOrderFunctor::template getOrder<type>();
   quads =
       GaussIntegrationElement<type, polynomial_degree>::getQuadraturePoints();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::
     computeJacobianOnQuadPointsByElement(const Matrix<Real> & node_coords,
                                          const Matrix<Real> & quad,
                                          Vector<Real> & jacobians) const {
   // jacobian
   ElementClass<type>::computeJacobian(quad, node_coords, jacobians);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 IntegratorGauss<kind, IntegrationOrderFunctor>::IntegratorGauss(
     const Mesh & mesh, const ID & id, const MemoryID & memory_id)
     : Integrator(mesh, id, memory_id) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::checkJacobians(
     const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_quadrature_points = this->quadrature_points(type, ghost_type).cols();
 
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
 
   Real * jacobians_val = jacobians(type, ghost_type).storage();
 
   for (UInt i = 0; i < nb_element * nb_quadrature_points;
        ++i, ++jacobians_val) {
     if (*jacobians_val < 0)
       AKANTU_DEBUG_ERROR(
           "Negative jacobian computed,"
           << " possible problem in the element node ordering (Quadrature Point "
           << i % nb_quadrature_points << ":" << i / nb_quadrature_points << ":"
           << type << ":" << ghost_type << ")");
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     computeJacobiansOnIntegrationPoints(
         const Array<Real> & nodes, const Matrix<Real> & quad_points,
         Array<Real> & jacobians, const GhostType & ghost_type,
         const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = quad_points.cols();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   jacobians.resize(nb_element * nb_quadrature_points);
 
   auto jacobians_it =
       jacobians.begin_reinterpret(nb_quadrature_points, nb_element);
   auto jacobians_begin = jacobians_it;
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type,
                                        filter_elements);
 
   auto x_it = x_el.begin(spatial_dimension, nb_nodes_per_element);
 
-  nb_element = x_el.getSize();
+  nb_element = x_el.size();
 
   //  Matrix<Real> local_coord(spatial_dimension, nb_nodes_per_element);
   for (UInt elem = 0; elem < nb_element; ++elem, ++x_it) {
     const Matrix<Real> & x = *x_it;
     Vector<Real> & J = *jacobians_it;
     computeJacobianOnQuadPointsByElement<type>(x, quad_points, J);
 
     if (filter_elements == empty_filter) {
       ++jacobians_it;
     } else {
       jacobians_it = jacobians_begin + filter_elements(elem);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_COHESIVE_ELEMENT)
 template <>
 template <ElementType type>
 void IntegratorGauss<_ek_cohesive, DefaultIntegrationOrderFunctor>::
     computeJacobiansOnIntegrationPoints(
         const Array<Real> & nodes, const Matrix<Real> & quad_points,
         Array<Real> & jacobians, const GhostType & ghost_type,
         const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = quad_points.cols();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
 
   jacobians.resize(nb_element * nb_quadrature_points);
 
   auto jacobians_it =
       jacobians.begin_reinterpret(nb_quadrature_points, nb_element);
   auto jacobians_begin = jacobians_it;
 
   Vector<Real> weights = GaussIntegrationElement<type>::getWeights();
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type,
                                        filter_elements);
 
   auto x_it = x_el.begin(spatial_dimension, nb_nodes_per_element);
 
   UInt nb_nodes_per_subelement = nb_nodes_per_element / 2;
   Matrix<Real> x(spatial_dimension, nb_nodes_per_subelement);
 
-  nb_element = x_el.getSize();
+  nb_element = x_el.size();
 
   for (UInt elem = 0; elem < nb_element; ++elem, ++x_it) {
 
     for (UInt s = 0; s < spatial_dimension; ++s)
       for (UInt n = 0; n < nb_nodes_per_subelement; ++n)
         x(s, n) =
             ((*x_it)(s, n) + (*x_it)(s, n + nb_nodes_per_subelement)) * .5;
 
     Vector<Real> & J = *jacobians_it;
 
     if (type == _cohesive_1d_2)
       J(0) = 1;
     else
       computeJacobianOnQuadPointsByElement<type>(x, quad_points, J);
 
     if (filter_elements == empty_filter) {
       ++jacobians_it;
     } else {
       jacobians_it = jacobians_begin + filter_elements(elem);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     precomputeJacobiansOnQuadraturePoints(const Array<Real> & nodes,
                                           const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<Real> & jacobians_tmp = jacobians.alloc(0, 1, type, ghost_type);
 
   this->computeJacobiansOnIntegrationPoints<type>(
       nodes, quadrature_points(type, ghost_type), jacobians_tmp, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, UInt polynomial_degree>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::multiplyJacobiansByWeights(
     Array<Real> & jacobians) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_quadrature_points =
       GaussIntegrationElement<type, polynomial_degree>::getNbQuadraturePoints();
-  UInt nb_element = jacobians.getSize() / nb_quadrature_points;
+  UInt nb_element = jacobians.size() / nb_quadrature_points;
 
   Vector<Real> weights =
       GaussIntegrationElement<type, polynomial_degree>::getWeights();
 
   Array<Real>::vector_iterator jacobians_it =
       jacobians.begin_reinterpret(nb_quadrature_points, nb_element);
   Array<Real>::vector_iterator jacobians_end =
       jacobians.end_reinterpret(nb_quadrature_points, nb_element);
 
   for (; jacobians_it != jacobians_end; ++jacobians_it) {
     Vector<Real> & J = *jacobians_it;
     J *= weights;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, Array<Real> & intf, UInt nb_degree_of_freedom,
     const Array<Real> & jacobians, UInt nb_element) const {
   AKANTU_DEBUG_IN();
 
   intf.resize(nb_element);
   if (nb_element == 0)
     return;
 
-  UInt nb_points = jacobians.getSize() / nb_element;
+  UInt nb_points = jacobians.size() / nb_element;
 
   Array<Real>::const_matrix_iterator J_it;
   Array<Real>::matrix_iterator inte_it;
   Array<Real>::const_matrix_iterator f_it;
 
   f_it = in_f.begin_reinterpret(nb_degree_of_freedom, nb_points, nb_element);
   inte_it = intf.begin_reinterpret(nb_degree_of_freedom, 1, nb_element);
   J_it = jacobians.begin_reinterpret(nb_points, 1, nb_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++J_it, ++f_it, ++inte_it) {
     const Matrix<Real> & f = *f_it;
     const Matrix<Real> & J = *J_it;
     Matrix<Real> & inte_f = *inte_it;
 
     inte_f.mul<false, false>(f, J);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, Array<Real> & intf, UInt nb_degree_of_freedom,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(jacobians.exists(type, ghost_type),
                       "No jacobians for the type "
                           << jacobians.printType(type, ghost_type));
 
   const Array<Real> & jac_loc = jacobians(type, ghost_type);
   if (filter_elements != empty_filter) {
-    UInt nb_element = filter_elements.getSize();
+    UInt nb_element = filter_elements.size();
     Array<Real> * filtered_J = new Array<Real>(0, jac_loc.getNbComponent());
     FEEngine::filterElementalData(mesh, jac_loc, *filtered_J, type, ghost_type,
                                   filter_elements);
     this->integrate(in_f, intf, nb_degree_of_freedom, *filtered_J, nb_element);
     delete filtered_J;
   } else {
     UInt nb_element = mesh.getNbElement(type, ghost_type);
     this->integrate(in_f, intf, nb_degree_of_freedom, jac_loc, nb_element);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, UInt polynomial_degree>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, Array<Real> & intf, UInt nb_degree_of_freedom,
     const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   Matrix<Real> quads = this->getIntegrationPoints<type, polynomial_degree>();
 
   Array<Real> jacobians;
   this->computeJacobiansOnIntegrationPoints<type>(mesh.getNodes(), quads,
                                                   jacobians, ghost_type);
   this->multiplyJacobiansByWeights<type, polynomial_degree>(jacobians);
 
   this->integrate(in_f, intf, nb_degree_of_freedom, jacobians,
                   mesh.getNbElement(type, ghost_type));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type, UInt polynomial_degree>
 Real IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, const GhostType & ghost_type) const {
   AKANTU_DEBUG_IN();
 
   Array<Real> intfv(0, 1);
   integrate<type, polynomial_degree>(in_f, intfv, 1, ghost_type);
 
   Real res = Math::reduce(intfv);
 
   AKANTU_DEBUG_OUT();
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 Real IntegratorGauss<kind, IntegrationOrderFunctor>::integrate(
     const Array<Real> & in_f, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(jacobians.exists(type, ghost_type),
                       "No jacobians for the type "
                           << jacobians.printType(type, ghost_type));
 
   Array<Real> intfv(0, 1);
   integrate<type>(in_f, intfv, 1, ghost_type, filter_elements);
 
   Real res = Math::reduce(intfv);
 
   AKANTU_DEBUG_OUT();
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     integrateOnIntegrationPoints(const Array<Real> & in_f, Array<Real> & intf,
                                  UInt nb_degree_of_freedom,
                                  const Array<Real> & jacobians,
                                  UInt nb_element) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_points = jacobians.getSize() / nb_element;
+  UInt nb_points = jacobians.size() / nb_element;
 
   Array<Real>::const_scalar_iterator J_it;
   Array<Real>::vector_iterator inte_it;
   Array<Real>::const_vector_iterator f_it;
 
   intf.resize(nb_element * nb_points);
 
   J_it = jacobians.begin();
   f_it = in_f.begin(nb_degree_of_freedom);
   inte_it = intf.begin(nb_degree_of_freedom);
 
   for (UInt el = 0; el < nb_element; ++el, ++J_it, ++f_it, ++inte_it) {
     const Real & J = *J_it;
     const Vector<Real> & f = *f_it;
     Vector<Real> & inte_f = *inte_it;
 
     inte_f = f;
     inte_f *= J;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     integrateOnIntegrationPoints(const Array<Real> & in_f, Array<Real> & intf,
                                  UInt nb_degree_of_freedom,
                                  const GhostType & ghost_type,
                                  const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(jacobians.exists(type, ghost_type),
                       "No jacobians for the type "
                           << jacobians.printType(type, ghost_type));
 
   const Array<Real> & jac_loc = this->jacobians(type, ghost_type);
 
   if (filter_elements != empty_filter) {
 
-    UInt nb_element = filter_elements.getSize();
+    UInt nb_element = filter_elements.size();
     Array<Real> * filtered_J = new Array<Real>(0, jac_loc.getNbComponent());
     FEEngine::filterElementalData(mesh, jac_loc, *filtered_J, type, ghost_type,
                                   filter_elements);
 
     this->integrateOnIntegrationPoints(in_f, intf, nb_degree_of_freedom,
                                        *filtered_J, nb_element);
   } else {
     UInt nb_element = mesh.getNbElement(type, ghost_type);
     this->integrateOnIntegrationPoints(in_f, intf, nb_degree_of_freedom,
                                        jac_loc, nb_element);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::onElementsAdded(
     const Array<Element> & elements) {
 
   const auto & nodes = mesh.getNodes();
 
   for (auto elements_range : MeshElementsByTypes(elements)) {
     auto type = elements_range.getType();
     auto ghost_type = elements_range.getGhostType();
 
     if (mesh.getKind(type) != kind)
       continue;
 
     auto & elements = elements_range.getElements();
 
     if (not jacobians.exists(type, ghost_type))
       jacobians.alloc(0, 1, type, ghost_type);
 
     this->computeJacobiansOnIntegrationPoints(
         nodes, quadrature_points(type, ghost_type), jacobians(type, ghost_type),
         type, ghost_type, elements);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind, class IntegrationOrderFunctor>
 template <ElementType type>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::initIntegrator(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   computeQuadraturePoints<type>(ghost_type);
   precomputeJacobiansOnQuadraturePoints<type>(nodes, ghost_type);
   checkJacobians<type>(ghost_type);
   constexpr UInt polynomial_degree =
       IntegrationOrderFunctor::template getOrder<type>();
   multiplyJacobiansByWeights<type, polynomial_degree>(
       this->jacobians(type, ghost_type));
 }
 
 namespace integrator {
   namespace details {
     template <ElementKind kind> struct GaussIntegratorInitHelper {};
 
 #define INIT_INTEGRATOR(type)                                                  \
   _int.template initIntegrator<type>(nodes, ghost_type)
 
 #define AKANTU_GAUSS_INTERGRATOR_INIT_HELPER(kind)                             \
   template <> struct GaussIntegratorInitHelper<kind> {                         \
     template <ElementKind k, class IOF>                                        \
     static void call(IntegratorGauss<k, IOF> & _int,                           \
                      const Array<Real> & nodes, const ElementType & type,      \
                      const GhostType & ghost_type) {                           \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(INIT_INTEGRATOR, kind);                 \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_GAUSS_INTERGRATOR_INIT_HELPER)
 
 #undef AKANTU_GAUSS_INTERGRATOR_INIT_HELPER
 #undef INIT_INTEGRATOR
   } // namespace details
 } // namespace integrator
 
 template <ElementKind kind, class IntegrationOrderFunctor>
 inline void IntegratorGauss<kind, IntegrationOrderFunctor>::initIntegrator(
     const Array<Real> & nodes, const ElementType & type,
     const GhostType & ghost_type) {
   integrator::details::GaussIntegratorInitHelper<kind>::call(*this, nodes, type,
                                                              ghost_type);
 }
 
 namespace integrator {
   namespace details {
     template <ElementKind kind> struct GaussIntegratorComputeJacobiansHelper {};
 
 #define AKANTU_COMPUTE_JACOBIANS(type)                                         \
   _int.template computeJacobiansOnIntegrationPoints<type>(                     \
       nodes, quad_points, jacobians, ghost_type, filter_elements);
 
 #define AKANTU_GAUSS_INTERGRATOR_COMPUTE_JACOBIANS(kind)                       \
   template <> struct GaussIntegratorComputeJacobiansHelper<kind> {             \
     template <ElementKind k, class IOF>                                        \
     static void                                                                \
     call(const IntegratorGauss<k, IOF> & _int, const Array<Real> & nodes,      \
          const Matrix<Real> & quad_points, Array<Real> & jacobians,            \
          const ElementType & type, const GhostType & ghost_type,               \
          const Array<UInt> & filter_elements) {                                \
       AKANTU_BOOST_KIND_ELEMENT_SWITCH(AKANTU_COMPUTE_JACOBIANS, kind);        \
     }                                                                          \
   };
 
     AKANTU_BOOST_ALL_KIND(AKANTU_GAUSS_INTERGRATOR_COMPUTE_JACOBIANS)
 
 #undef AKANTU_GAUSS_INTERGRATOR_COMPUTE_JACOBIANS
 #undef AKANTU_COMPUTE_JACOBIANS
   } // namespace details
 } // namespace integrator
 
 template <ElementKind kind, class IntegrationOrderFunctor>
 void IntegratorGauss<kind, IntegrationOrderFunctor>::
     computeJacobiansOnIntegrationPoints(
         const Array<Real> & nodes, const Matrix<Real> & quad_points,
         Array<Real> & jacobians, const ElementType & type,
         const GhostType & ghost_type,
         const Array<UInt> & filter_elements) const {
   integrator::details::GaussIntegratorComputeJacobiansHelper<kind>::call(
       *this, nodes, quad_points, jacobians, type, ghost_type, filter_elements);
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/shape_cohesive_inline_impl.cc b/src/fe_engine/shape_cohesive_inline_impl.cc
index b9963fd3b..fd10aa7f3 100644
--- a/src/fe_engine/shape_cohesive_inline_impl.cc
+++ b/src/fe_engine/shape_cohesive_inline_impl.cc
@@ -1,310 +1,310 @@
 /**
  * @file   shape_cohesive_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Feb 03 2012
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  ShapeCohesive inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "shape_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_COHESIVE_INLINE_IMPL_CC__
 #define __AKANTU_SHAPE_COHESIVE_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline ShapeLagrange<_ek_cohesive>::ShapeLagrange(const Mesh & mesh,
                                                   const ID & id,
                                                   const MemoryID & memory_id)
     : ShapeLagrangeBase(mesh, _ek_cohesive, id, memory_id) {}
 
 #define INIT_SHAPE_FUNCTIONS(type)                                             \
   setIntegrationPointsByType<type>(integration_points, ghost_type);            \
   precomputeShapesOnIntegrationPoints<type>(nodes, ghost_type);                \
   precomputeShapeDerivativesOnIntegrationPoints<type>(nodes, ghost_type);
 
 /* -------------------------------------------------------------------------- */
 inline void ShapeLagrange<_ek_cohesive>::initShapeFunctions(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     const ElementType & type, const GhostType & ghost_type) {
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(INIT_SHAPE_FUNCTIONS);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeLagrange<_ek_cohesive>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> &, const Matrix<Real> & integration_points,
     Array<Real> & shape_derivatives, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   UInt nb_points = integration_points.cols();
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
   UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
 
   AKANTU_DEBUG_ASSERT(shape_derivatives.getNbComponent() == size_of_shapesd,
                       "The shapes_derivatives array does not have the correct "
                           << "number of component");
 
   shape_derivatives.resize(nb_element * nb_points);
 
   Real * shapesd_val = shape_derivatives.storage();
 
   if (filter_elements == empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     Tensor3<Real> B(shapesd_val, spatial_dimension, nb_nodes_per_element,
                     nb_points);
     ElementClass<type>::computeDNDS(integration_points, B);
 
     if (filter_elements != empty_filter)
       shapesd_val += size_of_shapesd * nb_points;
     else {
       shapesd_val = shape_derivatives.storage() +
                     filter_elements(elem) * size_of_shapesd * nb_points;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 ShapeLagrange<_ek_cohesive>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shape_derivatives, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
 #define AKANTU_COMPUTE_SHAPES(type)                                            \
   computeShapeDerivativesOnIntegrationPoints<type>(                            \
       nodes, integration_points, shape_derivatives, ghost_type,                \
       filter_elements);
 
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(AKANTU_COMPUTE_SHAPES);
 
 #undef AKANTU_COMPUTE_SHAPES
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeLagrange<_ek_cohesive>::precomputeShapesOnIntegrationPoints(
     const Array<Real> & nodes, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
 
   Array<Real> & shapes_tmp =
       shapes.alloc(0, size_of_shapes, itp_type, ghost_type);
 
   this->computeShapesOnIntegrationPoints<type>(nodes, natural_coords,
                                                shapes_tmp, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeLagrange<_ek_cohesive>::precomputeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
 
   Array<Real> & shapes_derivatives_tmp =
       shapes_derivatives.alloc(0, size_of_shapesd, itp_type, ghost_type);
 
   this->computeShapeDerivativesOnIntegrationPoints<type>(
       nodes, natural_coords, shapes_derivatives_tmp, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::extractNodalToElementField(
     const Array<Real> & nodal_f, Array<Real> & elemental_f,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_itp_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
   UInt nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
   UInt nb_degree_of_freedom = nodal_f.getNbComponent();
   UInt nb_element = this->mesh.getNbElement(type, ghost_type);
   UInt * conn_val = this->mesh.getConnectivity(type, ghost_type).storage();
 
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
   }
 
   elemental_f.resize(nb_element);
 
   Array<Real>::matrix_iterator u_it =
       elemental_f.begin(nb_degree_of_freedom, nb_nodes_per_itp_element);
 
   UInt * el_conn;
   ReduceFunction reduce_function;
 
   for (UInt el = 0; el < nb_element; ++el, ++u_it) {
     Matrix<Real> & u = *u_it;
     if (filter_elements != empty_filter)
       el_conn = conn_val + filter_elements(el) * nb_nodes_per_element;
     else
       el_conn = conn_val + el * nb_nodes_per_element;
 
     // compute the average/difference of the nodal field loaded from cohesive
     // element
     for (UInt n = 0; n < nb_nodes_per_itp_element; ++n) {
       UInt node_plus = *(el_conn + n);
       UInt node_minus = *(el_conn + n + nb_nodes_per_itp_element);
       for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
         Real u_plus = nodal_f(node_plus, d);
         Real u_minus = nodal_f(node_minus, d);
         u(d, n) = reduce_function(u_plus, u_minus);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_degree_of_freedom,
     GhostType ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
 
   AKANTU_DEBUG_ASSERT(this->shapes.exists(itp_type, ghost_type),
                       "No shapes for the type "
                           << this->shapes.printType(itp_type, ghost_type));
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   this->extractNodalToElementField<type, ReduceFunction>(in_u, u_el, ghost_type,
                                                          filter_elements);
 
   this->template interpolateElementalFieldOnIntegrationPoints<type>(
       u_el, out_uq, ghost_type, shapes(itp_type, ghost_type), filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::variationOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & nablauq, UInt nb_degree_of_freedom,
     GhostType ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
 
   AKANTU_DEBUG_ASSERT(
       this->shapes_derivatives.exists(itp_type, ghost_type),
       "No shapes for the type "
           << this->shapes_derivatives.printType(itp_type, ghost_type));
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   this->extractNodalToElementField<type, ReduceFunction>(in_u, u_el, ghost_type,
                                                          filter_elements);
 
   this->template gradientElementalFieldOnIntegrationPoints<type>(
       u_el, nablauq, ghost_type, shapes_derivatives(itp_type, ghost_type),
       filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <ElementType type, class ReduceFunction>
 void ShapeLagrange<_ek_cohesive>::computeNormalsOnIntegrationPoints(
     const Array<Real> & u, Array<Real> & normals_u, GhostType ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = this->mesh.getNbElement(type, ghost_type);
   UInt nb_points = this->integration_points(type, ghost_type).cols();
   UInt spatial_dimension = this->mesh.getSpatialDimension();
 
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 
   normals_u.resize(nb_points * nb_element);
 
   Array<Real> tangents_u(nb_element * nb_points,
                          (spatial_dimension * (spatial_dimension - 1)));
 
   this->template variationOnIntegrationPoints<type, ReduceFunction>(
       u, tangents_u, spatial_dimension, ghost_type, filter_elements);
 
   Array<Real>::vector_iterator normal = normals_u.begin(spatial_dimension);
   Array<Real>::vector_iterator normal_end = normals_u.end(spatial_dimension);
 
   Real * tangent = tangents_u.storage();
 
   if (spatial_dimension == 3)
     for (; normal != normal_end; ++normal) {
       Math::vectorProduct3(tangent, tangent + spatial_dimension,
                            normal->storage());
 
       (*normal) /= normal->norm();
       tangent += spatial_dimension * 2;
     }
   else if (spatial_dimension == 2)
     for (; normal != normal_end; ++normal) {
       Vector<Real> a1(tangent, spatial_dimension);
 
       (*normal)(0) = -a1(1);
       (*normal)(1) = a1(0);
       (*normal) /= normal->norm();
 
       tangent += spatial_dimension;
     }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 #endif /* __AKANTU_SHAPE_COHESIVE_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/shape_functions.cc b/src/fe_engine/shape_functions.cc
index 70fb66702..3bb25cffd 100644
--- a/src/fe_engine/shape_functions.cc
+++ b/src/fe_engine/shape_functions.cc
@@ -1,238 +1,238 @@
 /**
  * @file   shape_functions.cc
  *
  * @author Nicolas Richart
  *
  * @date creation  Thu Jul 27 2017
  *
  * @brief implementation of th shape functions interface
  *
  * @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 "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void
 ShapeFunctions::initElementalFieldInterpolationFromIntegrationPoints(
     const Array<Real> & interpolation_points_coordinates,
     ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
     ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
     const Array<Real> & quadrature_points_coordinates, const GhostType & ghost_type,
     const Array<UInt> & element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = this->mesh.getSpatialDimension();
   UInt nb_element = this->mesh.getNbElement(type, ghost_type);
   UInt nb_element_filter;
 
   if (element_filter == empty_filter)
     nb_element_filter = nb_element;
   else
-    nb_element_filter = element_filter.getSize();
+    nb_element_filter = element_filter.size();
 
   UInt nb_quad_per_element =
       GaussIntegrationElement<type>::getNbQuadraturePoints();
   UInt nb_interpolation_points_per_elem =
-      interpolation_points_coordinates.getSize() / nb_element;
+      interpolation_points_coordinates.size() / nb_element;
 
-  AKANTU_DEBUG_ASSERT(interpolation_points_coordinates.getSize() % nb_element ==
+  AKANTU_DEBUG_ASSERT(interpolation_points_coordinates.size() % nb_element ==
                           0,
                       "Number of interpolation points should be a multiple of "
                       "total number of elements");
 
   if (!quad_points_coordinates_inv_matrices.exists(type, ghost_type))
     quad_points_coordinates_inv_matrices.alloc(
         nb_element_filter, nb_quad_per_element * nb_quad_per_element, type,
         ghost_type);
   else
     quad_points_coordinates_inv_matrices(type, ghost_type)
         .resize(nb_element_filter);
 
   if (!interpolation_points_coordinates_matrices.exists(type, ghost_type))
     interpolation_points_coordinates_matrices.alloc(
         nb_element_filter,
         nb_interpolation_points_per_elem * nb_quad_per_element, type,
         ghost_type);
   else
     interpolation_points_coordinates_matrices(type, ghost_type)
         .resize(nb_element_filter);
 
   Array<Real> & quad_inv_mat =
       quad_points_coordinates_inv_matrices(type, ghost_type);
   Array<Real> & interp_points_mat =
       interpolation_points_coordinates_matrices(type, ghost_type);
 
   Matrix<Real> quad_coord_matrix(nb_quad_per_element, nb_quad_per_element);
 
   Array<Real>::const_matrix_iterator quad_coords_it =
       quadrature_points_coordinates.begin_reinterpret(
           spatial_dimension, nb_quad_per_element, nb_element_filter);
 
   Array<Real>::const_matrix_iterator points_coords_begin =
       interpolation_points_coordinates.begin_reinterpret(
           spatial_dimension, nb_interpolation_points_per_elem, nb_element);
 
   Array<Real>::matrix_iterator inv_quad_coord_it =
       quad_inv_mat.begin(nb_quad_per_element, nb_quad_per_element);
 
   Array<Real>::matrix_iterator int_points_mat_it = interp_points_mat.begin(
       nb_interpolation_points_per_elem, nb_quad_per_element);
 
   /// loop over the elements of the current material and element type
   for (UInt el = 0; el < nb_element_filter;
        ++el, ++inv_quad_coord_it, ++int_points_mat_it, ++quad_coords_it) {
     /// matrix containing the quadrature points coordinates
     const Matrix<Real> & quad_coords = *quad_coords_it;
     /// matrix to store the matrix inversion result
     Matrix<Real> & inv_quad_coord_matrix = *inv_quad_coord_it;
 
     /// insert the quad coordinates in a matrix compatible with the
     /// interpolation
     buildElementalFieldInterpolationMatrix<type>(quad_coords,
                                                  quad_coord_matrix);
 
     /// invert the interpolation matrix
     inv_quad_coord_matrix.inverse(quad_coord_matrix);
 
     /// matrix containing the interpolation points coordinates
     const Matrix<Real> & points_coords =
         points_coords_begin[element_filter(el)];
     /// matrix to store the interpolation points coordinates
     /// compatible with these functions
     Matrix<Real> & inv_points_coord_matrix = *int_points_mat_it;
 
     /// insert the quad coordinates in a matrix compatible with the
     /// interpolation
     buildElementalFieldInterpolationMatrix<type>(points_coords,
                                                  inv_points_coord_matrix);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeFunctions::initElementalFieldInterpolationFromIntegrationPoints(
     const ElementTypeMapArray<Real> & interpolation_points_coordinates,
     ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
     ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
     const ElementTypeMapArray<Real> & quadrature_points_coordinates,
     const ElementTypeMapArray<UInt> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = this->mesh.getSpatialDimension();
 
   for (auto ghost_type : ghost_types) {
     Mesh::type_iterator it, last;
     if (element_filter) {
       it = element_filter->firstType(spatial_dimension, ghost_type);
       last = element_filter->lastType(spatial_dimension, ghost_type);
     } else {
       it = mesh.firstType(spatial_dimension, ghost_type);
       last = mesh.lastType(spatial_dimension, ghost_type);
     }
     for (; it != last; ++it) {
 
       ElementType type = *it;
       UInt nb_element = mesh.getNbElement(type, ghost_type);
       if (nb_element == 0)
         continue;
 
       const Array<UInt> * elem_filter;
       if (element_filter)
         elem_filter = &((*element_filter)(type, ghost_type));
       else
         elem_filter = &(empty_filter);
 
 #define AKANTU_INIT_ELEMENTAL_FIELD_INTERPOLATION_FROM_C_POINTS(type)          \
   this->initElementalFieldInterpolationFromIntegrationPoints<type>(            \
       interpolation_points_coordinates(type, ghost_type),                      \
       interpolation_points_coordinates_matrices,                               \
       quad_points_coordinates_inv_matrices,                                    \
       quadrature_points_coordinates(type, ghost_type), ghost_type,             \
       *elem_filter)
 
       AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(
           AKANTU_INIT_ELEMENTAL_FIELD_INTERPOLATION_FROM_C_POINTS);
 #undef AKANTU_INIT_ELEMENTAL_FIELD_INTERPOLATION_FROM_C_POINTS
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ShapeFunctions::interpolateElementalFieldFromIntegrationPoints(
     const ElementTypeMapArray<Real> & field,
     const ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
     const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
     ElementTypeMapArray<Real> & result, const GhostType & ghost_type,
     const ElementTypeMapArray<UInt> * element_filter) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = this->mesh.getSpatialDimension();
 
   Mesh::type_iterator it, last;
 
   if (element_filter) {
     it = element_filter->firstType(spatial_dimension, ghost_type);
     last = element_filter->lastType(spatial_dimension, ghost_type);
   } else {
     it = mesh.firstType(spatial_dimension, ghost_type);
     last = mesh.lastType(spatial_dimension, ghost_type);
   }
 
   for (; it != last; ++it) {
 
     ElementType type = *it;
     UInt nb_element = mesh.getNbElement(type, ghost_type);
     if (nb_element == 0)
       continue;
 
     const Array<UInt> * elem_filter;
     if (element_filter)
       elem_filter = &((*element_filter)(type, ghost_type));
     else
       elem_filter = &(empty_filter);
 
 #define AKANTU_INTERPOLATE_ELEMENTAL_FIELD_FROM_C_POINTS(type)                 \
   interpolateElementalFieldFromIntegrationPoints<type>(                        \
       field(type, ghost_type),                                                 \
       interpolation_points_coordinates_matrices(type, ghost_type),             \
       quad_points_coordinates_inv_matrices(type, ghost_type), result,          \
       ghost_type, *elem_filter)
 
     AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(
         AKANTU_INTERPOLATE_ELEMENTAL_FIELD_FROM_C_POINTS);
 #undef AKANTU_INTERPOLATE_ELEMENTAL_FIELD_FROM_C_POINTS
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/fe_engine/shape_functions_inline_impl.cc b/src/fe_engine/shape_functions_inline_impl.cc
index 75f729ebd..031f8060c 100644
--- a/src/fe_engine/shape_functions_inline_impl.cc
+++ b/src/fe_engine/shape_functions_inline_impl.cc
@@ -1,393 +1,393 @@
 /**
  * @file   shape_functions_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Oct 27 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  ShapeFunctions inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_CC__
 #define __AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline UInt ShapeFunctions::getShapeSize(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   UInt shape_size = 0;
 #define GET_SHAPE_SIZE(type) shape_size = ElementClass<type>::getShapeSize()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_SHAPE_SIZE); // ,
 
 #undef GET_SHAPE_SIZE
 
   AKANTU_DEBUG_OUT();
   return shape_size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt ShapeFunctions::getShapeDerivativesSize(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   UInt shape_derivatives_size = 0;
 #define GET_SHAPE_DERIVATIVES_SIZE(type)                                       \
   shape_derivatives_size = ElementClass<type>::getShapeDerivativesSize()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_SHAPE_DERIVATIVES_SIZE); // ,
 
 #undef GET_SHAPE_DERIVATIVES_SIZE
 
   AKANTU_DEBUG_OUT();
   return shape_derivatives_size;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeFunctions::setIntegrationPointsByType(const Matrix<Real> & points,
                                                 const GhostType & ghost_type) {
   if (not this->integration_points.exists(type, ghost_type))
     this->integration_points(type, ghost_type).shallowCopy(points);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 ShapeFunctions::buildInterpolationMatrix(const Matrix<Real> & coordinates,
                                          Matrix<Real> & coordMatrix,
                                          UInt integration_order) const {
   switch (integration_order) {
   case 1: {
     for (UInt i = 0; i < coordinates.cols(); ++i)
       coordMatrix(i, 0) = 1;
     break;
   }
   case 2: {
     UInt nb_quadrature_points = coordMatrix.cols();
 
     for (UInt i = 0; i < coordinates.cols(); ++i) {
       coordMatrix(i, 0) = 1;
       for (UInt j = 1; j < nb_quadrature_points; ++j)
         coordMatrix(i, j) = coordinates(j - 1, i);
     }
     break;
   }
   default: {
     AKANTU_DEBUG_TO_IMPLEMENT();
     break;
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix(
     const Matrix<Real> &, Matrix<Real> &, UInt) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_segment_2>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_segment_3>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_triangle_3>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ShapeFunctions::buildElementalFieldInterpolationMatrix<_triangle_6>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_tetrahedron_4>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_tetrahedron_10>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
   buildInterpolationMatrix(coordinates, coordMatrix, integration_order);
 }
 
 /**
  * @todo Write a more efficient interpolation for quadrangles by
  * dropping unnecessary quadrature points
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_quadrangle_4>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
 
   if (integration_order !=
       ElementClassProperty<_quadrangle_4>::polynomial_degree) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   } else {
     for (UInt i = 0; i < coordinates.cols(); ++i) {
       Real x = coordinates(0, i);
       Real y = coordinates(1, i);
 
       coordMatrix(i, 0) = 1;
       coordMatrix(i, 1) = x;
       coordMatrix(i, 2) = y;
       coordMatrix(i, 3) = x * y;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ShapeFunctions::buildElementalFieldInterpolationMatrix<_quadrangle_8>(
     const Matrix<Real> & coordinates, Matrix<Real> & coordMatrix,
     UInt integration_order) const {
 
   if (integration_order !=
       ElementClassProperty<_quadrangle_8>::polynomial_degree) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   } else {
     for (UInt i = 0; i < coordinates.cols(); ++i) {
       UInt j = 0;
       Real x = coordinates(0, i);
       Real y = coordinates(1, i);
 
       for (UInt e = 0; e <= 2; ++e) {
         for (UInt n = 0; n <= 2; ++n) {
           coordMatrix(i, j) = std::pow(x, e) * std::pow(y, n);
           ++j;
         }
       }
     }
   }
 }
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void ShapeFunctions::interpolateElementalFieldFromIntegrationPoints(
     const Array<Real> & field,
     const Array<Real> & interpolation_points_coordinates_matrices,
     const Array<Real> & quad_points_coordinates_inv_matrices,
     ElementTypeMapArray<Real> & result, const GhostType & ghost_type,
     const Array<UInt> & element_filter) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = this->mesh.getNbElement(type, ghost_type);
 
   UInt nb_quad_per_element =
       GaussIntegrationElement<type>::getNbQuadraturePoints();
   UInt nb_interpolation_points_per_elem =
       interpolation_points_coordinates_matrices.getNbComponent() /
       nb_quad_per_element;
 
   if (!result.exists(type, ghost_type))
     result.alloc(nb_element * nb_interpolation_points_per_elem,
                  field.getNbComponent(), type, ghost_type);
 
   if (element_filter != empty_filter)
-    nb_element = element_filter.getSize();
+    nb_element = element_filter.size();
 
   Matrix<Real> coefficients(nb_quad_per_element, field.getNbComponent());
 
   Array<Real> & result_vec = result(type, ghost_type);
 
   Array<Real>::const_matrix_iterator field_it = field.begin_reinterpret(
       field.getNbComponent(), nb_quad_per_element, nb_element);
 
   Array<Real>::const_matrix_iterator interpolation_points_coordinates_it =
       interpolation_points_coordinates_matrices.begin(
           nb_interpolation_points_per_elem, nb_quad_per_element);
 
   Array<Real>::matrix_iterator result_begin = result_vec.begin_reinterpret(
       field.getNbComponent(), nb_interpolation_points_per_elem,
-      result_vec.getSize() / nb_interpolation_points_per_elem);
+      result_vec.size() / nb_interpolation_points_per_elem);
 
   Array<Real>::const_matrix_iterator inv_quad_coord_it =
       quad_points_coordinates_inv_matrices.begin(nb_quad_per_element,
                                                  nb_quad_per_element);
 
   /// loop over the elements of the current filter and element type
   for (UInt el = 0; el < nb_element; ++el, ++field_it, ++inv_quad_coord_it,
             ++interpolation_points_coordinates_it) {
     /**
      * matrix containing the inversion of the quadrature points'
      * coordinates
      */
     const Matrix<Real> & inv_quad_coord_matrix = *inv_quad_coord_it;
 
     /**
      * multiply it by the field values over quadrature points to get
      * the interpolation coefficients
      */
     coefficients.mul<false, true>(inv_quad_coord_matrix, *field_it);
 
     /// matrix containing the points' coordinates
     const Matrix<Real> & coord = *interpolation_points_coordinates_it;
 
     /// multiply the coordinates matrix by the coefficients matrix and store the
     /// result
     Matrix<Real> res(result_begin[element_filter(el)]);
     res.mul<true, true>(coefficients, coord);
   }
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 inline void ShapeFunctions::interpolateElementalFieldOnIntegrationPoints(
     const Array<Real> & u_el, Array<Real> & uq, const GhostType & ghost_type,
     const Array<Real> & shapes, const Array<UInt> & filter_elements) const {
   UInt nb_element;
   UInt nb_nodes_per_element = ElementClass<type>::getShapeSize();
 
-  UInt nb_points = shapes.getSize() / mesh.getNbElement(type, ghost_type);
+  UInt nb_points = shapes.size() / mesh.getNbElement(type, ghost_type);
   UInt nb_degree_of_freedom = u_el.getNbComponent() / nb_nodes_per_element;
 
   Array<Real>::const_matrix_iterator N_it;
   Array<Real>::const_matrix_iterator u_it;
   Array<Real>::matrix_iterator inter_u_it;
 
   Array<Real> * filtered_N = NULL;
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
     filtered_N = new Array<Real>(0, shapes.getNbComponent());
     FEEngine::filterElementalData(mesh, shapes, *filtered_N, type, ghost_type,
                                   filter_elements);
     N_it = filtered_N->begin_reinterpret(nb_nodes_per_element, nb_points,
                                          nb_element);
   } else {
     nb_element = mesh.getNbElement(type, ghost_type);
     N_it =
         shapes.begin_reinterpret(nb_nodes_per_element, nb_points, nb_element);
   }
 
   uq.resize(nb_element * nb_points);
 
   u_it = u_el.begin(nb_degree_of_freedom, nb_nodes_per_element);
   inter_u_it =
       uq.begin_reinterpret(nb_degree_of_freedom, nb_points, nb_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++N_it, ++u_it, ++inter_u_it) {
     const Matrix<Real> & u = *u_it;
     const Matrix<Real> & N = *N_it;
     Matrix<Real> & inter_u = *inter_u_it;
 
     inter_u.mul<false, false>(u, N);
   }
 
   delete filtered_N;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeFunctions::gradientElementalFieldOnIntegrationPoints(
     const Array<Real> & u_el, Array<Real> & out_nablauq,
     const GhostType & ghost_type, const Array<Real> & shapes_derivatives,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
   UInt nb_points = integration_points(type, ghost_type).cols();
   UInt element_dimension = ElementClass<type>::getNaturalSpaceDimension();
   UInt nb_degree_of_freedom = u_el.getNbComponent() / nb_nodes_per_element;
 
   Array<Real>::const_matrix_iterator B_it;
   Array<Real>::const_matrix_iterator u_it;
   Array<Real>::matrix_iterator nabla_u_it;
 
   UInt nb_element;
   Array<Real> * filtered_B = NULL;
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
     filtered_B = new Array<Real>(0, shapes_derivatives.getNbComponent());
     FEEngine::filterElementalData(mesh, shapes_derivatives, *filtered_B, type,
                                   ghost_type, filter_elements);
     B_it = filtered_B->begin(element_dimension, nb_nodes_per_element);
   } else {
     B_it = shapes_derivatives.begin(element_dimension, nb_nodes_per_element);
     nb_element = mesh.getNbElement(type, ghost_type);
   }
 
   out_nablauq.resize(nb_element * nb_points);
 
   u_it = u_el.begin(nb_degree_of_freedom, nb_nodes_per_element);
   nabla_u_it = out_nablauq.begin(nb_degree_of_freedom, element_dimension);
 
   for (UInt el = 0; el < nb_element; ++el, ++u_it) {
     const Matrix<Real> & u = *u_it;
     for (UInt q = 0; q < nb_points; ++q, ++B_it, ++nabla_u_it) {
       const Matrix<Real> & B = *B_it;
       Matrix<Real> & nabla_u = *nabla_u_it;
 
       nabla_u.mul<false, true>(u, B);
     }
   }
 
   delete filtered_B;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* __AKANTU_SHAPE_FUNCTIONS_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/shape_lagrange_base_inline_impl.cc b/src/fe_engine/shape_lagrange_base_inline_impl.cc
index 8831340ba..e9dd7163b 100644
--- a/src/fe_engine/shape_lagrange_base_inline_impl.cc
+++ b/src/fe_engine/shape_lagrange_base_inline_impl.cc
@@ -1,97 +1,97 @@
 /**
  * @file   shape_lagrange_base_inline_impl.cc
  *
  * @author Nicolas Richart
  *
  * @date creation  Thu Jul 27 2017
  *
  * @brief A Documented file.
  *
  * @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 "shape_lagrange_base.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_LAGRANGE_BASE_INLINE_IMPL_CC__
 #define __AKANTU_SHAPE_LAGRANGE_BASE_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Real> &
 ShapeLagrangeBase::getShapes(const ElementType & el_type,
                              const GhostType & ghost_type) const {
   return shapes(FEEngine::getInterpolationType(el_type), ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Real> &
 ShapeLagrangeBase::getShapesDerivatives(const ElementType & el_type,
                                         const GhostType & ghost_type) const {
   return shapes_derivatives(FEEngine::getInterpolationType(el_type),
                             ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void ShapeLagrangeBase::computeShapesOnIntegrationPoints(
     const Array<Real> &, const Matrix<Real> & integration_points,
     Array<Real> & shapes, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_points = integration_points.cols();
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
 
   shapes.resize(nb_element * nb_points);
 
 #if !defined(AKANTU_NDEBUG)
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
   AKANTU_DEBUG_ASSERT(shapes.getNbComponent() == size_of_shapes,
                       "The shapes array does not have the correct "
                           << "number of component");
 #endif
 
   auto shapes_it = shapes.begin_reinterpret(
       ElementClass<type>::getNbNodesPerInterpolationElement(), nb_points,
       nb_element);
   auto shapes_begin = shapes_it;
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
   }
 
   for (UInt elem = 0; elem < nb_element; ++elem) {
     Matrix<Real> & N = *shapes_it;
     ElementClass<type>::computeShapes(integration_points, N);
 
     if (filter_elements == empty_filter) {
       ++shapes_it;
     } else {
       shapes_it = shapes_begin + filter_elements(elem);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_SHAPE_LAGRANGE_BASE_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/shape_lagrange_inline_impl.cc b/src/fe_engine/shape_lagrange_inline_impl.cc
index 947f4cd76..367a894fd 100644
--- a/src/fe_engine/shape_lagrange_inline_impl.cc
+++ b/src/fe_engine/shape_lagrange_inline_impl.cc
@@ -1,411 +1,411 @@
 /**
  * @file   shape_lagrange_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Oct 27 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  ShapeLagrange inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "shape_lagrange.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_CC__
 #define __AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 #define INIT_SHAPE_FUNCTIONS(type)                                             \
   setIntegrationPointsByType<type>(integration_points, ghost_type);            \
   precomputeShapesOnIntegrationPoints<type>(nodes, ghost_type);                \
   if (ElementClass<type>::getNaturalSpaceDimension() ==                        \
           mesh.getSpatialDimension() ||                                        \
       kind != _ek_regular)                                                     \
     precomputeShapeDerivativesOnIntegrationPoints<type>(nodes, ghost_type);
 
 template <ElementKind kind>
 inline void ShapeLagrange<kind>::initShapeFunctions(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     const ElementType & type, const GhostType & ghost_type) {
   AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(INIT_SHAPE_FUNCTIONS);
 }
 
 #undef INIT_SHAPE_FUNCTIONS
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 inline void ShapeLagrange<kind>::computeShapeDerivativesOnCPointsByElement(
     const Matrix<Real> & node_coords, const Matrix<Real> & natural_coords,
     Tensor3<Real> & shapesd) const {
   AKANTU_DEBUG_IN();
 
   // compute dnds
   Tensor3<Real> dnds(node_coords.rows(), node_coords.cols(),
                      natural_coords.cols());
   ElementClass<type>::computeDNDS(natural_coords, dnds);
   // compute dxds
   Tensor3<Real> J(node_coords.rows(), natural_coords.rows(),
                   natural_coords.cols());
   ElementClass<type>::computeJMat(dnds, node_coords, J);
 
   // compute shape derivatives
   ElementClass<type>::computeShapeDerivatives(J, dnds, shapesd);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::inverseMap(const Vector<Real> & real_coords,
                                      UInt elem, Vector<Real> & natural_coords,
                                      const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   UInt * elem_val = mesh.getConnectivity(type, ghost_type).storage();
   Matrix<Real> nodes_coord(spatial_dimension, nb_nodes_per_element);
 
   mesh.extractNodalValuesFromElement(mesh.getNodes(), nodes_coord.storage(),
                                      elem_val + elem * nb_nodes_per_element,
                                      nb_nodes_per_element, spatial_dimension);
 
   ElementClass<type>::inverseMap(real_coords, nodes_coord, natural_coords);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 bool ShapeLagrange<kind>::contains(const Vector<Real> & real_coords, UInt elem,
                                    const GhostType & ghost_type) const {
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   Vector<Real> natural_coords(spatial_dimension);
 
   inverseMap<type>(real_coords, elem, natural_coords, ghost_type);
   return ElementClass<type>::contains(natural_coords);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::interpolate(const Vector<Real> & real_coords,
                                       UInt elem,
                                       const Matrix<Real> & nodal_values,
                                       Vector<Real> & interpolated,
                                       const GhostType & ghost_type) const {
   UInt nb_shapes = ElementClass<type>::getShapeSize();
   Vector<Real> shapes(nb_shapes);
   computeShapes<type>(real_coords, elem, shapes, ghost_type);
   ElementClass<type>::interpolate(nodal_values, shapes, interpolated);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeShapes(const Vector<Real> & real_coords,
                                         UInt elem, Vector<Real> & shapes,
                                         const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   Vector<Real> natural_coords(spatial_dimension);
 
   inverseMap<type>(real_coords, elem, natural_coords, ghost_type);
   ElementClass<type>::computeShapes(natural_coords, shapes);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeShapeDerivatives(
     const Matrix<Real> & real_coords, UInt elem, Tensor3<Real> & shapesd,
     const GhostType & ghost_type) const {
 
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_points = real_coords.cols();
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   AKANTU_DEBUG_ASSERT(mesh.getSpatialDimension() == shapesd.size(0) &&
                           nb_nodes_per_element == shapesd.size(1),
                       "Shape size doesn't match");
   AKANTU_DEBUG_ASSERT(nb_points == shapesd.size(2),
                       "Number of points doesn't match shapes size");
 
   Matrix<Real> natural_coords(spatial_dimension, nb_points);
 
   // Creates the matrix of natural coordinates
   for (UInt i = 0; i < nb_points; i++) {
     Vector<Real> real_point = real_coords(i);
     Vector<Real> natural_point = natural_coords(i);
 
     inverseMap<type>(real_point, elem, natural_point, ghost_type);
   }
 
   UInt * elem_val = mesh.getConnectivity(type, ghost_type).storage();
   Matrix<Real> nodes_coord(spatial_dimension, nb_nodes_per_element);
 
   mesh.extractNodalValuesFromElement(mesh.getNodes(), nodes_coord.storage(),
                                      elem_val + elem * nb_nodes_per_element,
                                      nb_nodes_per_element, spatial_dimension);
 
   computeShapeDerivativesOnCPointsByElement<type>(nodes_coord, natural_coords,
                                                   shapesd);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 ShapeLagrange<kind>::ShapeLagrange(const Mesh & mesh, const ID & id,
                                    const MemoryID & memory_id)
     : ShapeLagrangeBase(mesh, kind, id, memory_id) {}
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shape_derivatives, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   UInt nb_points = integration_points.cols();
-  UInt nb_element = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_element = mesh.getConnectivity(type, ghost_type).size();
 
   UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
   AKANTU_DEBUG_ASSERT(shape_derivatives.getNbComponent() == size_of_shapesd,
                       "The shapes_derivatives array does not have the correct "
                           << "number of component");
   shape_derivatives.resize(nb_element * nb_points);
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type,
                                        filter_elements);
 
   Real * shapesd_val = shape_derivatives.storage();
   Array<Real>::matrix_iterator x_it =
       x_el.begin(spatial_dimension, nb_nodes_per_element);
 
   if (filter_elements != empty_filter)
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
 
   for (UInt elem = 0; elem < nb_element; ++elem, ++x_it) {
     Matrix<Real> & X = *x_it;
     Tensor3<Real> B(shapesd_val, spatial_dimension, nb_nodes_per_element,
                     nb_points);
     computeShapeDerivativesOnCPointsByElement<type>(X, integration_points, B);
 
     if (filter_elements == empty_filter)
       shapesd_val += size_of_shapesd * nb_points;
     else {
       shapesd_val = shape_derivatives.storage() +
                     filter_elements(elem) * size_of_shapesd * nb_points;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 void ShapeLagrange<kind>::computeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const Matrix<Real> & integration_points,
     Array<Real> & shape_derivatives, const ElementType & type,
     const GhostType & ghost_type, const Array<UInt> & filter_elements) const {
 #define AKANTU_COMPUTE_SHAPES(type)                                            \
   computeShapeDerivativesOnIntegrationPoints<type>(                            \
       nodes, integration_points, shape_derivatives, ghost_type,                \
       filter_elements);
 
   AKANTU_BOOST_REGULAR_ELEMENT_SWITCH(AKANTU_COMPUTE_SHAPES);
 
 #undef AKANTU_COMPUTE_SHAPES
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::precomputeShapesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
 
   Array<Real> & shapes_tmp =
       shapes.alloc(0, size_of_shapes, itp_type, ghost_type);
 
   this->computeShapesOnIntegrationPoints<type>(nodes, natural_coords,
                                                shapes_tmp, ghost_type);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::precomputeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
 
   Array<Real> & shapes_derivatives_tmp =
       shapes_derivatives.alloc(0, size_of_shapesd, itp_type, ghost_type);
 
   this->computeShapeDerivativesOnIntegrationPoints<type>(
       nodes, natural_coords, shapes_derivatives_tmp, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_degree_of_freedom,
     const Array<Real> & shapes, GhostType ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   this->interpolateElementalFieldOnIntegrationPoints<type>(
       u_el, out_uq, ghost_type, shapes, filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq, UInt nb_degree_of_freedom,
     GhostType ghost_type, const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   AKANTU_DEBUG_ASSERT(shapes.exists(itp_type, ghost_type),
                       "No shapes for the type "
                           << shapes.printType(itp_type, ghost_type));
 
   this->interpolateOnIntegrationPoints<type>(in_u, out_uq, nb_degree_of_freedom,
                                              shapes(itp_type, ghost_type),
                                              ghost_type, filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::gradientOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_nablauq,
     UInt nb_degree_of_freedom, GhostType ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   AKANTU_DEBUG_ASSERT(
       shapes_derivatives.exists(itp_type, ghost_type),
       "No shapes derivatives for the type "
           << shapes_derivatives.printType(itp_type, ghost_type));
 
   UInt nb_nodes_per_element =
       ElementClass<type>::getNbNodesPerInterpolationElement();
 
   Array<Real> u_el(0, nb_degree_of_freedom * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, in_u, u_el, type, ghost_type,
                                        filter_elements);
 
   this->gradientElementalFieldOnIntegrationPoints<type>(
       u_el, out_nablauq, ghost_type, shapes_derivatives(itp_type, ghost_type),
       filter_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLagrange<kind>::fieldTimesShapes(const Array<Real> & field,
                                            Array<Real> & field_times_shapes,
                                            GhostType ghost_type) const {
   AKANTU_DEBUG_IN();
 
-  field_times_shapes.resize(field.getSize());
+  field_times_shapes.resize(field.size());
 
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
   InterpolationType itp_type = ElementClassProperty<type>::interpolation_type;
   UInt nb_degree_of_freedom = field.getNbComponent();
 
   const auto & shape = shapes(itp_type, ghost_type);
 
   auto field_it = field.begin(nb_degree_of_freedom, 1);
   auto shapes_it = shape.begin(1, size_of_shapes);
 
   auto it = field_times_shapes.begin(nb_degree_of_freedom, size_of_shapes);
   auto end = field_times_shapes.end(nb_degree_of_freedom, size_of_shapes);
 
   for (; it != end; ++it, ++field_it, ++shapes_it) {
     it->mul<false, false>(*field_it, *shapes_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_SHAPE_LAGRANGE_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/shape_linked_inline_impl.cc b/src/fe_engine/shape_linked_inline_impl.cc
index 332b28603..2112762e6 100644
--- a/src/fe_engine/shape_linked_inline_impl.cc
+++ b/src/fe_engine/shape_linked_inline_impl.cc
@@ -1,319 +1,319 @@
 /**
  * @file   shape_linked_inline_impl.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  ShapeLinked inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 template <ElementKind kind>
 inline void ShapeLinked<kind>::initShapeFunctions(
     __attribute__((unused)) const Array<Real> & nodes,
     __attribute__((unused)) const Matrix<Real> & integration_points,
     __attribute__((unused)) const ElementType & type,
     __attribute__((unused)) const GhostType & ghost_type) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 #undef INIT_SHAPE_FUNCTIONS
 
 /* -------------------------------------------------------------------------- */
 #define INIT_SHAPE_FUNCTIONS(type)                                             \
   setIntegrationPointsByType<type>(integration_points, ghost_type);            \
   precomputeShapesOnIntegrationPoints<type>(nodes, ghost_type);                \
   precomputeShapeDerivativesOnIntegrationPoints<type>(nodes, ghost_type);
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 template <>
 inline void ShapeLinked<_ek_structural>::initShapeFunctions(
     __attribute__((unused)) const Array<Real> & nodes,
     __attribute__((unused)) const Matrix<Real> & integration_points,
     __attribute__((unused)) const ElementType & type,
     __attribute__((unused)) const GhostType & ghost_type) {
   AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(INIT_SHAPE_FUNCTIONS);
 }
 #endif
 
 #undef INIT_SHAPE_FUNCTIONS
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 inline const Array<Real> &
 ShapeLinked<kind>::getShapes(const ElementType & type,
                              const GhostType & ghost_type, UInt id) const {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(shapes.exists(type, ghost_type),
                       "No shapes of type " << type << " in " << this->id);
   AKANTU_DEBUG_OUT();
   return *(shapes(type, ghost_type)[id]);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 inline const Array<Real> & ShapeLinked<kind>::getShapesDerivatives(
     const ElementType & type, const GhostType & ghost_type, UInt id) const {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(shapes_derivatives.exists(type, ghost_type),
                       "No shapes_derivatives of type " << type << " in "
                                                        << this->id);
   AKANTU_DEBUG_OUT();
   return *(shapes_derivatives(type, ghost_type)[id]);
 }
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 /* -------------------------------------------------------------------------- */
 template <>
 template <ElementType type>
 void ShapeLinked<_ek_structural>::precomputeShapesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   //  Real * coord = mesh.getNodes().storage();
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt nb_points = integration_points(type, ghost_type).cols();
 
   UInt size_of_shapes = ElementClass<type>::getShapeSize();
 
   std::string ghost = "";
   if (ghost_type == _ghost) {
     ghost = "ghost_";
   }
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt nb_shape_functions =
       ElementClass<type, _ek_structural>::getNbShapeFunctions();
 
   Array<Real> ** shapes_tmp = new Array<Real> * [nb_shape_functions];
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type);
 
   for (UInt s = 0; s < nb_shape_functions; ++s) {
     std::stringstream sstr_shapes;
     sstr_shapes << id << ":" << ghost << "shapes:" << type << ":" << s;
     shapes_tmp[s] = &(alloc<Real>(sstr_shapes.str(), nb_element * nb_points,
                                   size_of_shapes));
     Array<Real>::matrix_iterator x_it =
         x_el.begin(spatial_dimension, nb_nodes_per_element);
     Array<Real>::matrix_iterator shapes_it =
         shapes_tmp[s]->begin_reinterpret(size_of_shapes, nb_points, nb_element);
 
     for (UInt elem = 0; elem < nb_element; ++elem, ++shapes_it, ++x_it) {
       Matrix<Real> & X = *x_it;
       Matrix<Real> & N = *shapes_it;
       ElementClass<type>::computeShapes(natural_coords, N, X, s);
     }
   }
 
   shapes(type, ghost_type) = shapes_tmp;
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLinked<kind>::precomputeShapeDerivativesOnIntegrationPoints(
     const Array<Real> & nodes, const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   // Real * coord = mesh.getNodes().storage();
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt natural_spatial_dimension =
       ElementClass<type>::getNaturalSpaceDimension();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt size_of_shapesd = ElementClass<type>::getShapeDerivativesSize();
   Matrix<Real> & natural_coords = integration_points(type, ghost_type);
   UInt nb_points = natural_coords.cols();
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   std::string ghost = "";
 
   if (ghost_type == _ghost) {
     ghost = "ghost_";
   }
 
   Array<Real> x_el(0, spatial_dimension * nb_nodes_per_element);
   FEEngine::extractNodalToElementField(mesh, nodes, x_el, type, ghost_type);
 
   UInt nb_shape_functions = ElementClass<type>::getNbShapeDerivatives();
 
   Array<Real> ** shapes_derivatives_tmp =
       new Array<Real> * [nb_shape_functions];
   for (UInt s = 0; s < nb_shape_functions; ++s) {
     std::stringstream sstr_shapesd;
     sstr_shapesd << id << ":" << ghost << "shapes_derivatives:" << type << ":"
                  << s;
     shapes_derivatives_tmp[s] = &(alloc<Real>(
         sstr_shapesd.str(), nb_element * nb_points, size_of_shapesd));
     Real * shapesd_val = shapes_derivatives_tmp[s]->storage();
 
     Array<Real>::matrix_iterator x_it =
         x_el.begin(spatial_dimension, nb_nodes_per_element);
 
     for (UInt elem = 0; elem < nb_element; ++elem, ++x_it) {
       // compute shape derivatives
       Matrix<Real> & X = *x_it;
       Tensor3<Real> B(shapesd_val, natural_spatial_dimension,
                       nb_nodes_per_element, nb_points);
       ElementClass<type>::computeShapeDerivatives(natural_coords, B, X, s);
 
       shapesd_val += size_of_shapesd * nb_points;
     }
   }
 
   shapes_derivatives(type, ghost_type) = shapes_derivatives_tmp;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLinked<kind>::extractNodalToElementField(
     const Array<Real> & nodal_f, Array<Real> & elemental_f,
     UInt num_degre_of_freedom_to_extract, const GhostType & ghost_type,
     const Array<UInt> & filter_elements) const {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom = nodal_f.getNbComponent();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt * conn_val = mesh.getConnectivity(type, ghost_type).storage();
 
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
   }
 
   elemental_f.resize(nb_element);
 
   Real * nodal_f_val = nodal_f.storage();
   Real * f_val = elemental_f.storage();
 
   UInt * el_conn;
   for (UInt el = 0; el < nb_element; ++el) {
     if (filter_elements != empty_filter)
       el_conn = conn_val + filter_elements(el) * nb_nodes_per_element;
     else
       el_conn = conn_val + el * nb_nodes_per_element;
 
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt node = *(el_conn + n);
       *f_val = nodal_f_val[node * nb_degree_of_freedom +
                            num_degre_of_freedom_to_extract];
       f_val += 1;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLinked<kind>::interpolateOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_uq,
     __attribute__((unused)) UInt nb_degree_of_freedom,
     const GhostType & ghost_type, const Array<UInt> & filter_elements,
     bool accumulate, UInt id_shape, UInt num_degre_of_freedom_to_interpolate,
     __attribute__((unused)) UInt num_degre_of_freedom_interpolated) const {
   AKANTU_DEBUG_IN();
 
   Array<Real> * shapes_loc = shapes(type, ghost_type)[id_shape];
 
   AKANTU_DEBUG_ASSERT(shapes_loc != NULL, "No shapes for the type " << type);
 
   UInt nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
   Array<Real> u_el(0, nb_nodes_per_element);
   extractNodalToElementField<type>(in_u, u_el,
                                    num_degre_of_freedom_to_interpolate,
                                    ghost_type, filter_elements);
 
   if (!accumulate)
     out_uq.clear();
 
-  UInt nb_points = integration_points(type, ghost_type).cols() * u_el.getSize();
+  UInt nb_points = integration_points(type, ghost_type).cols() * u_el.size();
   Array<Real> uq(nb_points, 1, 0.);
 
   this->template interpolateElementalFieldOnIntegrationPoints<type>(
       u_el, uq, ghost_type, *shapes_loc, filter_elements);
 
   for (UInt q = 0; q < nb_points; ++q) {
     out_uq(q, num_degre_of_freedom_to_interpolate) += uq(q);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementKind kind>
 template <ElementType type>
 void ShapeLinked<kind>::gradientOnIntegrationPoints(
     const Array<Real> & in_u, Array<Real> & out_nablauq,
     UInt nb_degree_of_freedom, const GhostType & ghost_type,
     const Array<UInt> & filter_elements, bool accumulate, UInt id_shape,
     UInt num_degre_of_freedom_to_interpolate,
     __attribute__((unused)) UInt num_degre_of_freedom_interpolated) const {
   AKANTU_DEBUG_IN();
 
   Array<Real> * shapesd_loc = shapes_derivatives(type, ghost_type)[id_shape];
 
   AKANTU_DEBUG_ASSERT(shapesd_loc != NULL, "No shapes for the type " << type);
 
   UInt nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement();
   Array<Real> u_el(0, nb_nodes_per_element);
   extractNodalToElementField<type>(in_u, u_el,
                                    num_degre_of_freedom_to_interpolate,
                                    ghost_type, filter_elements);
 
-  UInt nb_points = integration_points(type, ghost_type).cols() * u_el.getSize();
+  UInt nb_points = integration_points(type, ghost_type).cols() * u_el.size();
   UInt element_dimension = ElementClass<type>::getSpatialDimension();
 
   Array<Real> nablauq(nb_points, element_dimension, 0.);
 
   if (!accumulate)
     out_nablauq.clear();
   this->template gradientElementalFieldOnIntegrationPoints<type>(
       u_el, nablauq, ghost_type, *shapesd_loc, filter_elements);
 
   Array<Real>::matrix_iterator nabla_u_it = nablauq.begin(1, element_dimension);
   Array<Real>::matrix_iterator out_nabla_u_it =
       out_nablauq.begin(nb_degree_of_freedom, element_dimension);
   for (UInt q = 0; q < nb_points; ++q, ++nabla_u_it, ++out_nabla_u_it) {
     for (UInt s = 0; s < element_dimension; ++s) {
       (*out_nabla_u_it)(num_degre_of_freedom_to_interpolate, s) +=
           (*nabla_u_it)(0, s);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
diff --git a/src/geometry/mesh_sphere_intersector_tmpl.hh b/src/geometry/mesh_sphere_intersector_tmpl.hh
index 07b2745fe..ff815fd40 100644
--- a/src/geometry/mesh_sphere_intersector_tmpl.hh
+++ b/src/geometry/mesh_sphere_intersector_tmpl.hh
@@ -1,196 +1,196 @@
 /**
  * @file   mesh_sphere_intersector_tmpl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jun 23 2015
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Computation of mesh intersection with spheres
  *
  * @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/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_SPHERE_INTERSECTOR_TMPL_HH__
 #define __AKANTU_MESH_SPHERE_INTERSECTOR_TMPL_HH__
 
 #include "aka_common.hh"
 #include "mesh_geom_common.hh"
 #include "tree_type_helper.hh"
 #include "mesh_sphere_intersector.hh"
 #include "static_communicator.hh"
 
 namespace akantu {
 
 template<UInt dim, ElementType type>
 MeshSphereIntersector<dim, type>::MeshSphereIntersector(Mesh & mesh):
   parent_type(mesh),
   tol_intersection_on_node(1e-10)
 {
 #if defined(AKANTU_IGFEM)
   if( (type == _triangle_3) || (type == _igfem_triangle_4) || (type == _igfem_triangle_5) ){
     const_cast<UInt &>(this->nb_seg_by_el) = 3;
   } else {
     AKANTU_DEBUG_ERROR("Not ready for mesh type " << type);
   }
 #else
   if( (type != _triangle_3) )
     AKANTU_DEBUG_ERROR("Not ready for mesh type " << type);
 #endif
 
   // initialize the intersection pointsss array with the spatial dimension
   this->intersection_points = new Array<Real>(0,dim);
   //  A maximum is set to the number of intersection nodes per element to limit the size of new_node_per_elem: 2 in 2D and 4 in 3D
   this->new_node_per_elem = new Array<UInt>(0, 1 + 4 * (dim-1));
 }
 
 template<UInt dim, ElementType type>
 MeshSphereIntersector<dim, type>::~MeshSphereIntersector() {
   delete this->new_node_per_elem;
   delete this->intersection_points;
 }
 
 template<UInt dim, ElementType type>
 void MeshSphereIntersector<dim, type>::constructData(GhostType ghost_type) {
 
   this->new_node_per_elem->resize(this->mesh.getNbElement(type, ghost_type));
   this->new_node_per_elem->clear();
 
   MeshGeomIntersector<dim, type, Line_arc<SK>, SK::Sphere_3, SK>::constructData(ghost_type);
 }
 
 template<UInt dim, ElementType type>
 void MeshSphereIntersector<dim, type>:: computeMeshQueryIntersectionPoint(const SK::Sphere_3 & query,
 									  UInt nb_old_nodes) {
   /// function to replace computeIntersectionQuery in a more generic geometry module version
   // The newNodeEvent is not send from this method who only compute the intersection points
   AKANTU_DEBUG_IN();
 
   Array<Real> & nodes = this->mesh.getNodes();
-  UInt nb_node = nodes.getSize() + this->intersection_points->getSize();
+  UInt nb_node = nodes.size() + this->intersection_points->size();
 
   // Tolerance for proximity checks should be defined by user
   Real global_tolerance = Math::getTolerance();
   Math::setTolerance(tol_intersection_on_node);
   typedef boost::variant<pair_type> sk_inter_res;
 
   TreeTypeHelper<Line_arc<Spherical>, Spherical>::const_iterator
     it = this->factory.getPrimitiveList().begin(),
     end= this->factory.getPrimitiveList().end();
 
   for (; it != end ; ++it) { // loop on the primitives (segments)
     std::list<sk_inter_res> s_results;
     CGAL::intersection(*it, query, std::back_inserter(s_results));
 
     if (s_results.size() == 1) { // just one point
       if (pair_type * pair = boost::get<pair_type>(&s_results.front())) {
         if (pair->second == 1) { // not a point tangent to the sphere
           // the intersection point written as a vector
           Vector<Real> new_node(dim, 0.0);
           Cartesian::Point_3 point(CGAL::to_double(pair->first.x()),
                                    CGAL::to_double(pair->first.y()),
                                    CGAL::to_double(pair->first.z()));
           for (UInt i = 0 ; i < dim ; i++) {
             new_node(i) = point[i];
           }
 
 	  /// boolean to decide wheter intersection point is on a standard node of the mesh or not
           bool is_on_mesh = false;
 	  /// boolean to decide if this intersection point has been already computed for a neighbor element
 	  bool is_new = true;
         
 	  /// check if intersection point has already been computed
 	  UInt n = nb_old_nodes;
 
           // check if we already compute this intersection and add it as a node for a neighboor element of another type
 	  Array<Real>::vector_iterator existing_node = nodes.begin(dim);
 
-	  for (; n < nodes.getSize() ; ++n) {// loop on the nodes from nb_old_nodes
+	  for (; n < nodes.size() ; ++n) {// loop on the nodes from nb_old_nodes
 	    if (Math::are_vector_equal(dim, new_node.storage(), existing_node[n].storage())) {
 	      is_new = false;
 	      break;
 	    }
 	  }
 	  if(is_new){
 	    Array<Real>::vector_iterator intersection_points_it = this->intersection_points->begin(dim);
 	    Array<Real>::vector_iterator intersection_points_end = this->intersection_points->end(dim);
 	    for (; intersection_points_it != intersection_points_end ; ++intersection_points_it, ++n) {
 	      if (Math::are_vector_equal(dim, new_node.storage(), intersection_points_it->storage())) {
 		is_new = false;
 		break;
 	      }
 	    }
 	  }
 	  
 	  // get the initial and final points of the primitive (segment) and write them as vectors
 	  Cartesian::Point_3 source_cgal(CGAL::to_double(it->source().x()),
 					 CGAL::to_double(it->source().y()),
 					 CGAL::to_double(it->source().z()));
 	  Cartesian::Point_3 target_cgal(CGAL::to_double(it->target().x()),
 					 CGAL::to_double(it->target().y()),
 					 CGAL::to_double(it->target().z()));
 	  Vector<Real> source(dim), target(dim);
 	  for (UInt i = 0 ; i < dim ; i++) {
 	    source(i) = source_cgal[i];
 	    target(i) = target_cgal[i];
 	  }
 
 	  // Check if we are close from a node of the primitive (segment)
 	  if (Math::are_vector_equal(dim, source.storage(), new_node.storage()) ||
 	      Math::are_vector_equal(dim, target.storage(), new_node.storage())) {
 	    is_on_mesh = true;
 	    is_new = false;
 	  }
 
 	  if (is_new) {// if the intersection point is a new one add it to the list
 	    this->intersection_points->push_back(new_node);
 	    nb_node++;
 	  }
 
 	  // deduce the element id
 	  UInt element_id = it->id();
 
 	  // fill the new_node_per_elem array
 	  if (!is_on_mesh) { // if the node is not on a mesh node
 	    UInt & nb_new_nodes_per_el = (*this->new_node_per_elem)(element_id, 0);
 	    nb_new_nodes_per_el += 1;
 	    AKANTU_DEBUG_ASSERT(2 * nb_new_nodes_per_el < this->new_node_per_elem->getNbComponent(),
 				"You might have to interface crossing the same material");
 	    (*this->new_node_per_elem)(element_id, (2 * nb_new_nodes_per_el) - 1) = n;
 	    (*this->new_node_per_elem)(element_id, 2 * nb_new_nodes_per_el) = it->segId();
 	  } 
 	}
       }
     }
   }
 
   Math::setTolerance(global_tolerance);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
 
 #endif // __AKANTU_MESH_SPHERE_INTERSECTOR_TMPL_HH__
diff --git a/src/io/dumper/dumper_element_iterator.hh b/src/io/dumper/dumper_element_iterator.hh
index 5daeff6b3..8cd40ff1e 100644
--- a/src/io/dumper/dumper_element_iterator.hh
+++ b/src/io/dumper/dumper_element_iterator.hh
@@ -1,193 +1,193 @@
 /**
  * @file   dumper_element_iterator.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Fri May 15 2015
  *
  * @brief  Iterators for elemental fields
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_ELEMENT_ITERATOR_HH__
 #define __AKANTU_DUMPER_ELEMENT_ITERATOR_HH__
 /* -------------------------------------------------------------------------- */
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 template<class types, template <class> class final_iterator>
 class element_iterator {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   typedef typename types::it_type      it_type;
   typedef typename types::field_type field_type;
   typedef typename types::array_type array_type;
   typedef typename types::array_iterator array_iterator;
   typedef final_iterator<types> iterator;
 
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   element_iterator(const field_type & field,
                    const typename field_type::type_iterator & t_it,
                    const typename field_type::type_iterator & t_it_end,
                    const array_iterator & array_it,
                    const array_iterator & array_it_end,
                    const GhostType ghost_type = _not_ghost)
     : field(field),
       tit(t_it),
       tit_end(t_it_end),
       array_it(array_it),
       array_it_end(array_it_end),
       ghost_type(ghost_type) {
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
 public:
 
   bool operator!=(const iterator & it) const {
     return (ghost_type != it.ghost_type)
       || (tit != it.tit || (array_it != it.array_it));
   }
 
   iterator & operator++() {
     ++array_it;
     while(array_it == array_it_end && tit != tit_end) {
       ++tit;
       if(tit != tit_end) {
 
         const array_type & vect = field(*tit, ghost_type);
         UInt _nb_data_per_elem = getNbDataPerElem(*tit);
         UInt nb_component = vect.getNbComponent();
-        UInt size = (vect.getSize() * nb_component) / _nb_data_per_elem;
+        UInt size = (vect.size() * nb_component) / _nb_data_per_elem;
 
         array_it       = vect.begin_reinterpret(_nb_data_per_elem,size);
         array_it_end   = vect.end_reinterpret  (_nb_data_per_elem,size);
       }
     }
     return *(static_cast<iterator *>(this));
   };
 
   ElementType getType() { return *tit; }
 
   UInt element_type() { return getIOHelperType(*tit); }
 
   Element getCurrentElement(){
     return Element(*tit,array_it.getCurrentIndex());
   }
 
   UInt getNbDataPerElem(const ElementType & type) const {
     if (!nb_data_per_elem.exists(type, ghost_type))
       return field(type,ghost_type).getNbComponent();
     
     return nb_data_per_elem(type,ghost_type);
   }
 
   void setNbDataPerElem(const ElementTypeMap<UInt> & nb_data){
     this->nb_data_per_elem = nb_data;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 protected:
 
   /// the field to iterate on
   const field_type & field;
   /// field iterator
   typename field_type::type_iterator tit;
   /// field iterator end
   typename field_type::type_iterator tit_end;
   /// array iterator
   array_iterator array_it;
   /// internal iterator end
   array_iterator array_it_end;
   /// ghost type identification
   const GhostType ghost_type;
   /// number of data per element
   ElementTypeMap<UInt> nb_data_per_elem;
 
 };
 
 /* -------------------------------------------------------------------------- */
 template<typename types>
 class elemental_field_iterator
   : public element_iterator<types, elemental_field_iterator> {
 public:
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
   typedef element_iterator<types, ::akantu::dumper::elemental_field_iterator> parent;
   typedef typename types::it_type     it_type;
   typedef typename types::return_type return_type;
   typedef typename types::field_type  field_type;
   typedef typename types::array_iterator array_iterator;
 
 public:
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   elemental_field_iterator(const field_type & field,
                            const typename field_type::type_iterator & t_it,
                            const typename field_type::type_iterator & t_it_end,
                            const array_iterator & array_it,
                            const array_iterator & array_it_end,
                            const GhostType ghost_type = _not_ghost) :
     parent(field, t_it, t_it_end, array_it, array_it_end, ghost_type) { }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   return_type operator*(){
     return *this->array_it;
   }
 
 private:
 
 };
 
 /* -------------------------------------------------------------------------- */
 __END_AKANTU_DUMPER__
 } // akantu
 /* -------------------------------------------------------------------------- */
 
 
 
 #endif /* __AKANTU_DUMPER_ELEMENT_ITERATOR_HH__ */
diff --git a/src/io/dumper/dumper_generic_elemental_field.hh b/src/io/dumper/dumper_generic_elemental_field.hh
index da45b65e4..383b8b575 100644
--- a/src/io/dumper/dumper_generic_elemental_field.hh
+++ b/src/io/dumper/dumper_generic_elemental_field.hh
@@ -1,224 +1,224 @@
 /**
  * @file   dumper_generic_elemental_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Generic interface for elemental fields
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_GENERIC_ELEMENTAL_FIELD_HH__
 #define __AKANTU_DUMPER_GENERIC_ELEMENTAL_FIELD_HH__
 /* -------------------------------------------------------------------------- */
 #include "dumper_field.hh"
 #include "element_type_map_filter.hh"
 #include "dumper_element_iterator.hh"
 #include "dumper_homogenizing_field.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 /* -------------------------------------------------------------------------- */
 
 template <class _types, template <class> class iterator_type>
 class GenericElementalField : public Field {
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   // check dumper_type_traits.hh for additional information over these types
   typedef _types types;
   typedef typename types::data_type data_type;
   typedef typename types::it_type it_type;
   typedef typename types::field_type field_type;
   typedef typename types::array_type array_type;
   typedef typename types::array_iterator array_iterator;
   typedef typename field_type::type_iterator field_type_iterator;
   typedef iterator_type<types> iterator;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   GenericElementalField(const field_type & field,
                         UInt spatial_dimension = _all_dimensions,
                         GhostType ghost_type = _not_ghost,
                         ElementKind element_kind = _ek_not_defined)
       : field(field), spatial_dimension(spatial_dimension),
         ghost_type(ghost_type), element_kind(element_kind) {
     this->checkHomogeneity();
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of components of the hosted field
   virtual ElementTypeMap<UInt>
   getNbComponents(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                   ElementKind kind = _ek_not_defined) {
     return this->field.getNbComponents(dim, ghost_type, kind);
   };
 
   /// return the size of the contained data: i.e. the number of elements ?
   virtual UInt size() {
     checkHomogeneity();
     return this->nb_total_element;
   }
 
   /// return the iohelper datatype to be dumped
   iohelper::DataType getDataType() {
     return iohelper::getDataType<data_type>();
   }
 
 protected:
   /// return the number of entries per element
   UInt getNbDataPerElem(const ElementType & type,
                         const GhostType & ghost_type = _not_ghost) const {
     if (!nb_data_per_elem.exists(type, ghost_type))
       return field(type, ghost_type).getNbComponent();
 
     return nb_data_per_elem(type, this->ghost_type);
   }
 
   /// check if the same quantity of data for all element types
   virtual void checkHomogeneity();
 
 public:
   virtual void registerToDumper(const std::string & id,
                                 iohelper::Dumper & dumper) {
     dumper.addElemDataField(id, *this);
   };
 
   /// for connection to a FieldCompute
   inline virtual Field * connect(FieldComputeProxy & proxy) {
     return proxy.connectToField(this);
   }
 
   /// for connection to a Homogenizer
   inline virtual ComputeFunctorInterface * connect(HomogenizerProxy & proxy) {
     return proxy.connectToField(this);
   };
 
   virtual iterator begin() {
     field_type_iterator tit;
     field_type_iterator end;
 
     /// type iterators on the elemental field
     tit = this->field.firstType(this->spatial_dimension, this->ghost_type,
                                 this->element_kind);
     end = this->field.lastType(this->spatial_dimension, this->ghost_type,
                                this->element_kind);
 
     /// skip all types without data
     ElementType type = *tit;
-    for (; tit != end && this->field(*tit, this->ghost_type).getSize() == 0;
+    for (; tit != end && this->field(*tit, this->ghost_type).size() == 0;
          ++tit) {
     }
 
     type = *tit;
 
     if (tit == end)
       return this->end();
 
     /// getting information for the field of the given type
     const array_type & vect = this->field(type, this->ghost_type);
     UInt nb_data_per_elem = this->getNbDataPerElem(type);
     UInt nb_component = vect.getNbComponent();
-    UInt size = (vect.getSize() * nb_component) / nb_data_per_elem;
+    UInt size = (vect.size() * nb_component) / nb_data_per_elem;
 
     /// define element-wise iterator
     array_iterator it = vect.begin_reinterpret(nb_data_per_elem, size);
     array_iterator it_end = vect.end_reinterpret(nb_data_per_elem, size);
     /// define data iterator
     iterator rit =
         iterator(this->field, tit, end, it, it_end, this->ghost_type);
     rit.setNbDataPerElem(this->nb_data_per_elem);
     return rit;
   }
 
   virtual iterator end() {
     field_type_iterator tit;
     field_type_iterator end;
 
     tit = this->field.firstType(this->spatial_dimension, this->ghost_type,
                                 this->element_kind);
     end = this->field.lastType(this->spatial_dimension, this->ghost_type,
                                this->element_kind);
 
     ElementType type = *tit;
     for (; tit != end; ++tit)
       type = *tit;
 
     const array_type & vect = this->field(type, this->ghost_type);
     UInt nb_data = this->getNbDataPerElem(type);
     UInt nb_component = vect.getNbComponent();
-    UInt size = (vect.getSize() * nb_component) / nb_data;
+    UInt size = (vect.size() * nb_component) / nb_data;
     array_iterator it = vect.end_reinterpret(nb_data, size);
 
     iterator rit = iterator(this->field, end, end, it, it, this->ghost_type);
     rit.setNbDataPerElem(this->nb_data_per_elem);
     return rit;
   }
 
   virtual UInt getDim() {
     if (this->homogeneous) {
       field_type_iterator tit = this->field.firstType(
           this->spatial_dimension, this->ghost_type, this->element_kind);
       return this->getNbDataPerElem(*tit);
     }
 
     throw;
     return 0;
   }
 
   void setNbDataPerElem(const ElementTypeMap<UInt> & nb_data) {
     nb_data_per_elem = nb_data;
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// the ElementTypeMapArray embedded in the field
   const field_type & field;
   /// total number of elements
   UInt nb_total_element;
   /// the spatial dimension of the problem
   UInt spatial_dimension;
   /// whether this is a ghost field or not (for type selection)
   GhostType ghost_type;
   /// The element kind to operate on
   ElementKind element_kind;
   /// The number of data per element type
   ElementTypeMap<UInt> nb_data_per_elem;
 };
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_generic_elemental_field_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 
 __END_AKANTU_DUMPER__ } // akantu
 
 #endif /* __AKANTU_DUMPER_GENERIC_ELEMENTAL_FIELD_HH__ */
diff --git a/src/io/dumper/dumper_generic_elemental_field_tmpl.hh b/src/io/dumper/dumper_generic_elemental_field_tmpl.hh
index ee491bd10..e21d67e9d 100644
--- a/src/io/dumper/dumper_generic_elemental_field_tmpl.hh
+++ b/src/io/dumper/dumper_generic_elemental_field_tmpl.hh
@@ -1,67 +1,67 @@
 /**
  * @file   dumper_generic_elemental_field_tmpl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Implementation of the template functions of the ElementalField
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 template<class types, template <class> class iterator>
 void GenericElementalField<types,iterator>::checkHomogeneity() {
   typedef typename field_type::type_iterator field_type_iterator;
   typedef typename field_type::array_type array_type;
 
   field_type_iterator tit;
   field_type_iterator end;
 
   tit = field.firstType(spatial_dimension, ghost_type, element_kind);
   end = field.lastType(spatial_dimension, ghost_type, element_kind);
 
   this->nb_total_element = 0;
   UInt nb_comp = 0;
 
   bool homogen = true;
   if(tit != end) {
     nb_comp = this->field(*tit, ghost_type).getNbComponent();
     for(;tit != end; ++tit) {
       const array_type & vect = this->field(*tit, ghost_type);
-      UInt nb_element = vect.getSize();
+      UInt nb_element = vect.size();
       UInt nb_comp_cur = vect.getNbComponent();
       if(homogen && nb_comp != nb_comp_cur) homogen = false;
       this->nb_total_element += nb_element;
 
       //      this->nb_data_per_elem(*tit,this->ghost_type) = nb_comp_cur;
     }
 
     if(!homogen) nb_comp = 0;
   }
 
   this->homogeneous = homogen;
 }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/io/dumper/dumper_nodal_field.hh b/src/io/dumper/dumper_nodal_field.hh
index ead527197..c462adc14 100644
--- a/src/io/dumper/dumper_nodal_field.hh
+++ b/src/io/dumper/dumper_nodal_field.hh
@@ -1,240 +1,240 @@
 /**
  * @file   dumper_nodal_field.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Oct 26 2012
  * @date last modification: Tue Jan 06 2015
  *
  * @brief  Description of nodal fields
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_DUMPER_NODAL_FIELD_HH__
 #define __AKANTU_DUMPER_NODAL_FIELD_HH__
 
 #include "dumper_field.hh"
 #include <io_helper.hh>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 __BEGIN_AKANTU_DUMPER__
 
 // This represents a iohelper compatible field
 template<typename T, bool filtered = false,
 	 class Container = Array<T>, class Filter = Array<UInt> >
 class NodalField;
 
 /* -------------------------------------------------------------------------- */
 template<typename T, class Container, class Filter>
 class NodalField<T, false, Container, Filter> : public dumper::Field {
 public:
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */  
  
   /// associated iterator with any nodal field (non filetered)
   class iterator : public iohelper::iterator< T, iterator, Vector<T> > {
   public:
     iterator(T * vect, UInt offset, UInt n, UInt stride,
 	     __attribute__ ((unused)) const UInt * filter = NULL) :
 
       internal_it(vect), offset(offset), n(n), stride(stride) {}
 
     bool operator!=(const iterator & it) const { return internal_it != it.internal_it; }
     iterator & operator++() { internal_it += offset; return *this; };
     Vector<T> operator* (){ return Vector<T>(internal_it + stride, n); };
   private:
     T * internal_it;
     UInt offset, n, stride;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   NodalField(const Container & field, UInt n = 0, UInt stride = 0,
 	     __attribute__ ((unused)) const Filter * filter = NULL) :
 
     field(field), n(n), stride(stride), padding(0) {
     AKANTU_DEBUG_ASSERT(filter == NULL, "Filter passed to unfiltered NodalField!");
     if(n == 0) { this->n = field.getNbComponent() - stride; }
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
   
   virtual void registerToDumper(const std::string & id,
 				iohelper::Dumper & dumper) {
     dumper.addNodeDataField(id, *this);
   }
 
   inline iterator begin() {
     return iterator(field.storage(), field.getNbComponent(), n, stride);
   }
 
   inline iterator end  () {
-    return iterator(field.storage() + field.getNbComponent()*field.getSize(),
+    return iterator(field.storage() + field.getNbComponent()*field.size(),
 		    field.getNbComponent(), n, stride);
   }
 
   bool isHomogeneous() { return true; }
   void checkHomogeneity() { this->homogeneous = true; }
 
   virtual UInt getDim() {
     if(this->padding) return this->padding;
     else              return n;
   }
 
   void setPadding(UInt padding){this->padding = padding;}
 
-  UInt size() { return field.getSize(); }
+  UInt size() { return field.size(); }
 
   iohelper::DataType getDataType() { return iohelper::getDataType<T>(); }
 
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
   
 
 private:
   const Container & field;
   UInt n, stride;
   UInt padding;
 };
 
 
 
 /* -------------------------------------------------------------------------- */
 template<typename T, class Container, class Filter>
 class NodalField<T, true, Container, Filter> : public dumper::Field {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */  
   
 public:
   class iterator : public iohelper::iterator< T, iterator, Vector<T> > {
 
   public:
     iterator(T * const vect, UInt _offset, UInt _n, 
 	     UInt _stride, const UInt * filter) :
 
       internal_it(vect), offset(_offset), n(_n), stride(_stride),
       filter(filter) {}
 
     bool operator!=(const iterator & it) const {
       return filter != it.filter;
     }
 
     iterator & operator++() {
       ++filter;
       return *this;
     }
 
     Vector<T> operator* () {
       return Vector<T>(internal_it + *(filter)*offset + stride, n);
     }
   private:
     T * const internal_it;
     UInt offset, n, stride;
     const UInt * filter;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   NodalField(const Container & _field,
              UInt _n = 0, UInt _stride = 0,
              const Filter * filter = NULL)
     : field(_field), n(_n), stride(_stride), filter(filter), padding(0) {
     AKANTU_DEBUG_ASSERT(this->filter != NULL, 
 			"No filter passed to filtered NodalField!");
 
     AKANTU_DEBUG_ASSERT(this->filter->getNbComponent()==1, 
 			"Multi-component filter given to NodalField (" 
 			<< this->filter->getNbComponent() 
 			<< " components detected, sould be 1");
     if(n == 0) {
       this->n = field.getNbComponent() - stride;
     }
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
   
   virtual void registerToDumper(const std::string & id, iohelper::Dumper & dumper) {
     dumper.addNodeDataField(id, *this);
   }
 
   inline iterator begin() {
     return iterator(field.storage(), field.getNbComponent(), 
 		    n, stride, filter->storage());
   }
 
   inline iterator end() {
     return iterator(field.storage(), field.getNbComponent(), 
-		    n, stride, filter->storage()+filter->getSize());
+		    n, stride, filter->storage()+filter->size());
   }
 
   bool isHomogeneous() {
     return true;
   }
   void checkHomogeneity() { this->homogeneous = true; }
 
   virtual UInt getDim() {
     if(this->padding) return this->padding;
     else              return n;
   }
 
   void setPadding(UInt padding){this->padding = padding;}
 
   UInt size() {
-    return filter->getSize();
+    return filter->size();
   }
 
   iohelper::DataType getDataType() {
     return iohelper::getDataType<T>();
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
   
 private:
   const Container & field;
   UInt n, stride;
   const Filter * filter;
 
   UInt padding;
 };
 
  
 __END_AKANTU_DUMPER__
 } // akantu
 /* -------------------------------------------------------------------------- */
 #endif /* __AKANTU_DUMPER_NODAL_FIELD_HH__ */
diff --git a/src/io/mesh_io/mesh_io_abaqus.cc b/src/io/mesh_io/mesh_io_abaqus.cc
index 7c3461a79..15ee70a23 100644
--- a/src/io/mesh_io/mesh_io_abaqus.cc
+++ b/src/io/mesh_io/mesh_io_abaqus.cc
@@ -1,475 +1,475 @@
 /**
  * @file   mesh_io_abaqus.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jan 04 2013
  * @date last modification: Fri Dec 11 2015
  *
  * @brief  read a mesh from an abaqus input file
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // std library header files
 #include <fstream>
 
 // akantu header files
 #include "mesh_io_abaqus.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 
 #include "element_group.hh"
 #include "node_group.hh"
 
 
 #if defined(__INTEL_COMPILER)
 //#pragma warning ( disable : 383 )
 #elif defined (__clang__) // test clang to be sure that when we test for gnu it is only gnu
 #elif (defined(__GNUC__) || defined(__GNUG__))
 #  define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #  if GCC_VERSION > 40600
 #    pragma GCC diagnostic push
 #  endif
 #  pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include <boost/config/warning_disable.hpp>
 #include <boost/spirit/include/qi.hpp>
 #include <boost/spirit/include/phoenix.hpp>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MeshIOAbaqus::MeshIOAbaqus() {}
 
 /* -------------------------------------------------------------------------- */
 MeshIOAbaqus::~MeshIOAbaqus() {}
 
 /* -------------------------------------------------------------------------- */
 namespace spirit = boost::spirit;
 namespace qi = boost::spirit::qi;
 namespace ascii = boost::spirit::ascii;
 namespace lbs = boost::spirit::qi::labels;
 namespace phx = boost::phoenix;
 
 /* -------------------------------------------------------------------------- */
 void element_read(Mesh & mesh, const ElementType & type, UInt id, const std::vector<Int> & conn,
                   const std::map<UInt, UInt> & nodes_mapping,
                   std::map<UInt, Element> & elements_mapping) {
   Vector<UInt> tmp_conn(Mesh::getNbNodesPerElement(type));
 
   AKANTU_DEBUG_ASSERT(conn.size() == tmp_conn.size(),
 		      "The nodes in the Abaqus file have too many coordinates"
 		      << " for the mesh you try to fill.");
 
   mesh.addConnectivityType(type);
   Array<UInt> & connectivity = mesh.getConnectivity(type);
 
   UInt i = 0;
   for (std::vector<Int>::const_iterator it = conn.begin(); it != conn.end(); ++it) {
     std::map<UInt, UInt>::const_iterator nit = nodes_mapping.find(*it);
     AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
 			"There is an unknown node in the connectivity.");
     tmp_conn[i++] = nit->second;
   }
-  Element el(type, connectivity.getSize());
+  Element el(type, connectivity.size());
   elements_mapping[id] = el;
   connectivity.push_back(tmp_conn);
 }
 
 
 void node_read(Mesh & mesh, UInt id, const std::vector<Real> & pos,
 	       std::map<UInt, UInt> & nodes_mapping) {
   Vector<Real> tmp_pos(mesh.getSpatialDimension());
   UInt i = 0;
   for (std::vector<Real>::const_iterator it = pos.begin();
        it != pos.end() || i < mesh.getSpatialDimension(); ++it)
     tmp_pos[i++] = *it;
 
   nodes_mapping[id] = mesh.getNbNodes();
   mesh.getNodes().push_back(tmp_pos);
 }
 
 
 /* ------------------------------------------------------------------------ */
 void add_element_to_group(ElementGroup * el_grp, UInt element,
 			  const std::map<UInt, Element> & elements_mapping) {
   std::map<UInt, Element>::const_iterator eit = elements_mapping.find(element);
   AKANTU_DEBUG_ASSERT(eit != elements_mapping.end(),
 		      "There is an unknown element ("
 		      << element << ") in the in the ELSET "
 		      << el_grp->getName() << ".");
 
   el_grp->add(eit->second, true, false);
 }
 
 ElementGroup * element_group_create(Mesh & mesh, const ID & name) {
   Mesh::element_group_iterator eg_it = mesh.element_group_find(name);
   if (eg_it != mesh.element_group_end()) {
     return eg_it->second;
   } else {
     return &mesh.createElementGroup(name, _all_dimensions);
   }
 }
 
 NodeGroup * node_group_create(Mesh & mesh, const ID & name) {
   Mesh::node_group_iterator ng_it = mesh.node_group_find(name);
   if (ng_it != mesh.node_group_end()) {
     return ng_it->second;
   } else {
     return &mesh.createNodeGroup(name, mesh.getSpatialDimension());
   }
 }
 
 void add_node_to_group(NodeGroup * node_grp, UInt node,
 		       const std::map<UInt, UInt> & nodes_mapping) {
   std::map<UInt, UInt>::const_iterator nit = nodes_mapping.find(node);
 
   AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
 		      "There is an unknown node in the in the NSET "
 		      << node_grp->getName() << ".");
   
   node_grp->add(nit->second, false);
 }
 
 void optimize_group(NodeGroup * grp) { grp->optimize(); }
 void optimize_element_group(ElementGroup * grp) { grp->optimize(); }
 
 /* -------------------------------------------------------------------------- */
 template <class Iterator> struct AbaqusSkipper : qi::grammar<Iterator> {
   AbaqusSkipper() : AbaqusSkipper::base_type(skip, "abaqus_skipper") {
     /* clang-format off */
     skip
       =   (ascii::space - spirit::eol)
       |   "**" >> *(qi::char_ - spirit::eol) >> spirit::eol
       ;
     /* clang-format on */
   }
   qi::rule<Iterator> skip;
 };
 
 /* -------------------------------------------------------------------------- */
 template <class Iterator, typename Skipper = AbaqusSkipper<Iterator> >
 struct AbaqusMeshGrammar : qi::grammar<Iterator, void(), Skipper> {
 public:
   AbaqusMeshGrammar(Mesh & mesh)
       : AbaqusMeshGrammar::base_type(start, "abaqus_mesh_reader"), mesh(mesh) {
 
     /* clang-format off */
     start
       =  *(
              (qi::char_('*')
                 >  (   (qi::no_case[ qi::lit("node output")    ] > any_section)
                    |   (qi::no_case[ qi::lit("element output") ] > any_section)
                    |   (qi::no_case[ qi::lit("node")           ] > nodes)
                    |   (qi::no_case[ qi::lit("element")        ] > elements)
                    |   (qi::no_case[ qi::lit("heading")        ] > header)
                    |   (qi::no_case[ qi::lit("elset")          ] > elements_set)
                    |   (qi::no_case[ qi::lit("nset")           ] > nodes_set)
                    |   (qi::no_case[ qi::lit("material")       ] > material)
                    |   (keyword > any_section)
                    )
              )
           |  spirit::eol
           )
       ;
 
     header
       =   spirit::eol
       >   *any_line
       ;
 
     nodes
       =   *(qi::char_(',') >> option)
            >> spirit::eol
            >> *( (qi::int_
                   > node_position) [ phx::bind(&node_read,
 						 phx::ref(mesh),
 						 lbs::_1,
 						 lbs::_2,
 						 phx::ref(abaqus_nodes_to_akantu)) ]
                   >> spirit::eol
                )
       ;
 
     elements
       =   (
              (  qi::char_(',') >> qi::no_case[qi::lit("type")] >> '='
                 >> abaqus_element_type  [ lbs::_a = lbs::_1 ]
              )
           ^  *(qi::char_(',') >> option)
           )
           >> spirit::eol
           >> *(  (qi::int_
                   > connectivity) [ phx::bind(&element_read,
 						phx::ref(mesh),
 						lbs::_a,
 						lbs::_1,
 						lbs::_2,
 						phx::cref(abaqus_nodes_to_akantu),
 						phx::ref(abaqus_elements_to_akantu)) ]
                  >> spirit::eol
                )
       ;
 
     elements_set
       =   (
              (
                 (  qi::char_(',') >> qi::no_case[ qi::lit("elset") ] >> '='
                    >> value [ lbs::_a = phx::bind<ElementGroup *>(&element_group_create,
 								    phx::ref(mesh),
 								    lbs::_1) ]
                 )
              ^  *(qi::char_(',') >> option)
              )
              >> spirit::eol
              >> qi::skip
                   (qi::char_(',') | qi::space)
 	     [ +(qi::int_ [ phx::bind(&add_element_to_group,
 					lbs::_a,
 					lbs::_1,
 					phx::cref(abaqus_elements_to_akantu)
 					)
                                ]
                      )
                  ]
 	   ) [ phx::bind(&optimize_element_group, lbs::_a) ]
       ;
 
     nodes_set
       =   (
              (
                 (  qi::char_(',')
                    >> qi::no_case[ qi::lit("nset") ] >> '='
                    >> value [ lbs::_a = phx::bind<NodeGroup *>(&node_group_create, phx::ref(mesh), lbs::_1) ]
                 )
              ^  *(qi::char_(',') >> option)
              )
              >> spirit::eol
              >> qi::skip
                  (qi::char_(',') | qi::space)
 	         [ +(qi::int_ [ phx::bind(&add_node_to_group,
 					    lbs::_a,
 					    lbs::_1,
 					    phx::cref(abaqus_nodes_to_akantu)
 					   )
                               ]
                     )
                  ]
            ) [ phx::bind(&optimize_group, lbs::_a) ]
       ;
 
     material
       =   (
              (  qi::char_(',') >> qi::no_case[ qi::lit("name") ] >> '='
                 >> value  [ phx::push_back(phx::ref(material_names), lbs::_1) ]
              )
           ^  *(qi::char_(',') >> option)
           ) >> spirit::eol;
       ;
 
     node_position
       =   +(qi::char_(',') > real [ phx::push_back(lbs::_val, lbs::_1) ])
       ;
 
     connectivity
       = +(qi::char_(',') > qi::int_ [ phx::push_back(lbs::_val, lbs::_1) ])
       ;
 
 
     any_section
       =   *(qi::char_(',') >> option) > spirit::eol
       >   *any_line
       ;
 
     any_line
       =   *(qi::char_ - spirit::eol - qi::char_('*')) >> spirit::eol
       ;
 
     keyword
       =   qi::lexeme[ +(qi::char_ - (qi::char_('*') | spirit::eol)) ]
       ;
 
     option
       = key > -( '=' >> value );
 
     key
       =   qi::char_("a-zA-Z_") >> *(qi::char_("a-zA-Z_0-9") | qi::char_('-'))
       ;
 
     value
       =   key.alias()
       ;
 
     BOOST_SPIRIT_DEBUG_NODE(start);
 
     abaqus_element_type.add
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
       ("BE21"  , _bernoulli_beam_2)
       ("BE31"  , _bernoulli_beam_3)
 #endif
       ("T3D2"  , _segment_2) // Gmsh generates this elements
       ("T3D3"  , _segment_3) // Gmsh generates this elements
       ("CPE3"  , _triangle_3)
       ("CPS3"  , _triangle_3)
       ("DC2D3" , _triangle_3)
       ("CPE6"  , _triangle_6)
       ("CPS6"  , _triangle_6)
       ("DC2D6" , _triangle_6)
       ("CPE4"  , _quadrangle_4)
       ("CPS4"  , _quadrangle_4)
       ("DC2D4" , _quadrangle_4)
       ("CPE8"  , _quadrangle_8)
       ("CPS8"  , _quadrangle_8)
       ("DC2D8" , _quadrangle_8)
       ("C3D4"  , _tetrahedron_4)
       ("DC3D4" , _tetrahedron_4)
       ("C3D8"  , _hexahedron_8)
       ("C3D8R" , _hexahedron_8)
       ("DC3D8" , _hexahedron_8)
       ("C3D10" , _tetrahedron_10)
       ("DC3D10", _tetrahedron_10);
 
 #if !defined(AKANTU_NDEBUG) && defined(AKANTU_CORE_CXX_11)
     qi::on_error<qi::fail>(start, error_handler(lbs::_4, lbs::_3, lbs::_2));
 #endif
     
     start              .name("abaqus-start-rule");
     connectivity       .name("abaqus-connectivity");
     node_position      .name("abaqus-nodes-position");
     nodes              .name("abaqus-nodes");
     any_section        .name("abaqus-any_section");
     header             .name("abaqus-header");
     material           .name("abaqus-material");
     elements           .name("abaqus-elements");
     elements_set       .name("abaqus-elements-set");
     nodes_set          .name("abaqus-nodes-set");
     key                .name("abaqus-key");
     value              .name("abaqus-value");
     option             .name("abaqus-option");
     keyword            .name("abaqus-keyword");
     any_line           .name("abaqus-any-line");
     abaqus_element_type.name("abaqus-element-type");
 
     /* clang-format on */
   }
 
 public:
   AKANTU_GET_MACRO(MaterialNames, material_names,
                    const std::vector<std::string> &);
 
   /* ------------------------------------------------------------------------ */
   /* Rules                                                                    */
   /* ------------------------------------------------------------------------ */
 private:
   qi::rule<Iterator, void(), Skipper> start;
   qi::rule<Iterator, std::vector<int>(), Skipper> connectivity;
   qi::rule<Iterator, std::vector<Real>(), Skipper> node_position;
   qi::rule<Iterator, void(), Skipper> nodes, any_section, header, material;
   qi::rule<Iterator, void(), qi::locals<ElementType>, Skipper> elements;
   qi::rule<Iterator, void(), qi::locals<ElementGroup *>, Skipper> elements_set;
   qi::rule<Iterator, void(), qi::locals<NodeGroup *>, Skipper> nodes_set;
 
   qi::rule<Iterator, std::string(), Skipper> key, value, option, keyword,
       any_line;
 
   qi::real_parser<Real, qi::real_policies<Real> > real;
 
   qi::symbols<char, ElementType> abaqus_element_type;
 
   /* ------------------------------------------------------------------------ */
   /* Mambers                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   /// reference to the mesh to read
   Mesh & mesh;
 
   /// correspondance between the numbering of nodes in the abaqus file and in
   /// the akantu mesh
   std::map<UInt, UInt> abaqus_nodes_to_akantu;
 
   /// correspondance between the element number in the abaqus file and the
   /// Element in the akantu mesh
   std::map<UInt, Element> abaqus_elements_to_akantu;
 
   /// list of the material names
   std::vector<std::string> material_names;
 };
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 void MeshIOAbaqus::read(const std::string & filename, Mesh & mesh) {
   namespace spirit = boost::spirit;
   namespace qi = boost::spirit::qi;
   namespace lbs = boost::spirit::qi::labels;
   namespace ascii = boost::spirit::ascii;
   namespace phx = boost::phoenix;
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   if (!infile.good()) {
     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
   }
 
   std::string storage;             // We will read the contents here.
   infile.unsetf(std::ios::skipws); // No white space skipping!
   std::copy(std::istream_iterator<char>(infile), std::istream_iterator<char>(),
             std::back_inserter(storage));
 
   typedef std::string::const_iterator iterator_t;
   typedef AbaqusSkipper<iterator_t> skipper;
   typedef AbaqusMeshGrammar<iterator_t, skipper> grammar;
 
   grammar g(mesh);
   skipper ws;
 
   iterator_t iter = storage.begin();
   iterator_t end = storage.end();
 
   qi::phrase_parse(iter, end, g, ws);
 
   MeshAccessor mesh_accessor(mesh);
 
   for (auto & mat_name : g.getMaterialNames()) {
     auto eg_it = mesh.element_group_find(mat_name);
     auto & eg = *eg_it->second;
     if (eg_it != mesh.element_group_end()) {
       for (auto & type : eg.elementTypes()) {
         Array<std::string> & abaqus_material =
             mesh_accessor.getData<std::string>("abaqus_material", type);
 
         for (auto elem : eg.getElements(type)) {
           abaqus_material(elem) = mat_name;
         }
       }
     }
   }
 
-  mesh_accessor.setNbGlobalNodes(mesh.getNodes().getSize());
+  mesh_accessor.setNbGlobalNodes(mesh.getNodes().size());
   MeshUtils::fillElementToSubElementsData(mesh);
 }
 
 } // akantu
diff --git a/src/io/mesh_io/mesh_io_diana.cc b/src/io/mesh_io/mesh_io_diana.cc
index b75e511fd..bd32eed14 100644
--- a/src/io/mesh_io/mesh_io_diana.cc
+++ b/src/io/mesh_io/mesh_io_diana.cc
@@ -1,604 +1,604 @@
 /**
  * @file   mesh_io_diana.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Alodie Schneuwly <alodie.schneuwly@epfl.ch>
  *
  * @date creation: Sat Mar 26 2011
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  handles diana meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "mesh_io_diana.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <string.h>
 /* -------------------------------------------------------------------------- */
 #include <stdio.h>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /*   Methods Implentations                                                    */
 /* -------------------------------------------------------------------------- */
 
 MeshIODiana::MeshIODiana() {
   canReadSurface = true;
   canReadExtendedData = true;
   _diana_to_akantu_element_types["T9TM"] = _triangle_3;
   _diana_to_akantu_element_types["CT6CM"] = _triangle_6;
   _diana_to_akantu_element_types["Q12TM"] = _quadrangle_4;
   _diana_to_akantu_element_types["CQ8CM"] = _quadrangle_8;
   _diana_to_akantu_element_types["TP18L"] = _pentahedron_6;
   _diana_to_akantu_element_types["CTP45"] = _pentahedron_15;
   _diana_to_akantu_element_types["TE12L"] = _tetrahedron_4;
   _diana_to_akantu_element_types["HX24L"] = _hexahedron_8;
   _diana_to_akantu_element_types["CHX60"] = _hexahedron_20;
   _diana_to_akantu_mat_prop["YOUNG"] = "E";
   _diana_to_akantu_mat_prop["DENSIT"] = "rho";
   _diana_to_akantu_mat_prop["POISON"] = "nu";
 
   std::map<std::string, ElementType>::iterator it;
   for (it = _diana_to_akantu_element_types.begin();
        it != _diana_to_akantu_element_types.end(); ++it) {
     UInt nb_nodes = Mesh::getNbNodesPerElement(it->second);
 
     UInt * tmp = new UInt[nb_nodes];
     for (UInt i = 0; i < nb_nodes; ++i) {
       tmp[i] = i;
     }
 
     switch (it->second) {
     case _tetrahedron_10:
       tmp[8] = 9;
       tmp[9] = 8;
       break;
     case _pentahedron_15:
       tmp[0] = 2;
       tmp[1] = 8;
       tmp[2] = 0;
       tmp[3] = 6;
       tmp[4] = 1;
       tmp[5] = 7;
       tmp[6] = 11;
       tmp[7] = 9;
       tmp[8] = 10;
       tmp[9] = 5;
       tmp[10] = 14;
       tmp[11] = 3;
       tmp[12] = 12;
       tmp[13] = 4;
       tmp[14] = 13;
       break;
     case _hexahedron_20:
       tmp[0] = 5;
       tmp[1] = 16;
       tmp[2] = 4;
       tmp[3] = 19;
       tmp[4] = 7;
       tmp[5] = 18;
       tmp[6] = 6;
       tmp[7] = 17;
       tmp[8] = 13;
       tmp[9] = 12;
       tmp[10] = 15;
       tmp[11] = 14;
       tmp[12] = 1;
       tmp[13] = 8;
       tmp[14] = 0;
       tmp[15] = 11;
       tmp[16] = 3;
       tmp[17] = 10;
       tmp[18] = 2;
       tmp[19] = 9;
       break;
     default:
       // nothing to change
       break;
     }
     _read_order[it->second] = tmp;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 MeshIODiana::~MeshIODiana() {}
 
 /* -------------------------------------------------------------------------- */
 inline void my_getline(std::ifstream & infile, std::string & line) {
   std::getline(infile, line);   // read the line
   size_t pos = line.find("\r"); /// remove the extra \r if needed
   line = line.substr(0, pos);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIODiana::read(const std::string & filename, Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   std::string line;
   UInt first_node_number = std::numeric_limits<UInt>::max();
   diana_element_number_to_elements.clear();
 
   if (!infile.good()) {
     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
   }
 
   while (infile.good()) {
     my_getline(infile, line);
 
     /// read all nodes
     if (line == "'COORDINATES'") {
       line = readCoordinates(infile, mesh, first_node_number);
     }
 
     /// read all elements
     if (line == "'ELEMENTS'") {
       line = readElements(infile, mesh, first_node_number);
     }
 
     /// read the material properties and write a .dat file
     if (line == "'MATERIALS'") {
       line = readMaterial(infile, filename);
     }
 
     /// read the material properties and write a .dat file
     if (line == "'GROUPS'") {
       line = readGroups(infile, mesh, first_node_number);
     }
   }
   infile.close();
 
   mesh_accessor.setNbGlobalNodes(mesh.getNbNodes());
 
   MeshUtils::fillElementToSubElementsData(mesh);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIODiana::write(__attribute__((unused)) const std::string & filename,
                         __attribute__((unused)) const Mesh & mesh) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readCoordinates(std::ifstream & infile, Mesh & mesh,
                                          UInt & first_node_number) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
 
   Array<Real> & nodes = mesh_accessor.getNodes();
 
   std::string line;
 
   UInt index;
   Vector<Real> coord(3);
 
   do {
     my_getline(infile, line);
     if ("'ELEMENTS'" == line)
       break;
 
     std::stringstream sstr_node(line);
     sstr_node >> index >> coord(0) >> coord(1) >> coord(2);
 
     first_node_number = first_node_number < index ? first_node_number : index;
 
     nodes.push_back(coord);
   } while (true);
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt MeshIODiana::readInterval(std::stringstream & line,
                                std::set<UInt> & interval) {
   UInt first;
   line >> first;
   if (line.fail()) {
     return 0;
   }
   interval.insert(first);
 
   UInt second;
   int dash;
   dash = line.get();
   if (dash == '-') {
     line >> second;
     interval.insert(second);
     return 2;
   }
 
   if (line.fail())
     line.clear(std::ios::eofbit); // in case of get at end of the line
   else
     line.unget();
   return 1;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readGroups(std::ifstream & infile, Mesh & mesh,
                                     UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   my_getline(infile, line);
 
   bool reading_nodes_group = false;
 
   while (line != "'SUPPORTS'") {
     if (line == "NODES") {
       reading_nodes_group = true;
       my_getline(infile, line);
     }
 
     if (line == "ELEMEN") {
       reading_nodes_group = false;
       my_getline(infile, line);
     }
 
     std::stringstream * str = new std::stringstream(line);
 
     UInt id;
     std::string name;
     char c;
     *str >> id >> name >> c;
 
     Array<UInt> * list_ids = new Array<UInt>(0, 1, name);
 
     UInt s = 1;
     bool end = false;
     while (!end) {
       while (!str->eof() && s != 0) {
         std::set<UInt> interval;
         s = readInterval(*str, interval);
         std::set<UInt>::iterator it = interval.begin();
         if (s == 1)
           list_ids->push_back(*it);
         if (s == 2) {
           UInt first = *it;
           ++it;
           UInt second = *it;
           for (UInt i = first; i <= second; ++i) {
             list_ids->push_back(i);
           }
         }
       }
       if (str->fail())
         end = true;
       else {
         my_getline(infile, line);
         delete str;
         str = new std::stringstream(line);
       }
     }
 
     delete str;
 
     if (reading_nodes_group) {
       NodeGroup & ng = mesh.createNodeGroup(name);
-      for (UInt i = 0; i < list_ids->getSize(); ++i) {
+      for (UInt i = 0; i < list_ids->size(); ++i) {
         UInt node = (*list_ids)(i)-first_node_number;
         ng.add(node, false);
       }
       delete list_ids;
 
     } else {
       ElementGroup & eg = mesh.createElementGroup(name);
-      for (UInt i = 0; i < list_ids->getSize(); ++i) {
+      for (UInt i = 0; i < list_ids->size(); ++i) {
         Element & elem = diana_element_number_to_elements[(*list_ids)(i)];
         if (elem.type != _not_defined)
           eg.add(elem, false, false);
       }
 
       eg.optimize();
       delete list_ids;
     }
 
     my_getline(infile, line);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readElements(std::ifstream & infile, Mesh & mesh,
                                       UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   my_getline(infile, line);
 
   if ("CONNECTIVITY" == line) {
     line = readConnectivity(infile, mesh, first_node_number);
   }
 
   /// read the line corresponding to the materials
   if ("MATERIALS" == line) {
     line = readMaterialElement(infile, mesh);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readConnectivity(std::ifstream & infile, Mesh & mesh,
                                           UInt first_node_number) {
   AKANTU_DEBUG_IN();
 
   MeshAccessor mesh_accessor(mesh);
   Int index;
   std::string lline;
 
   std::string diana_type;
   ElementType akantu_type, akantu_type_old = _not_defined;
   Array<UInt> * connectivity = NULL;
   UInt node_per_element = 0;
   Element elem;
   UInt * read_order = NULL;
 
   while (1) {
     my_getline(infile, lline);
     //    std::cerr << lline << std::endl;
     std::stringstream sstr_elem(lline);
     if (lline == "MATERIALS")
       break;
 
     /// traiter les coordonnees
     sstr_elem >> index;
     sstr_elem >> diana_type;
 
     akantu_type = _diana_to_akantu_element_types[diana_type];
 
     if (akantu_type == _not_defined)
       continue;
 
     if (akantu_type != akantu_type_old) {
       connectivity = &(mesh_accessor.getConnectivity(akantu_type));
 
       node_per_element = connectivity->getNbComponent();
       akantu_type_old = akantu_type;
       read_order = _read_order[akantu_type];
     }
 
     Vector<UInt> local_connect(node_per_element);
 
     // used if element is written on two lines
     UInt j_last = 0;
 
     for (UInt j = 0; j < node_per_element; ++j) {
       UInt node_index;
       sstr_elem >> node_index;
 
       // check s'il y a pas plus rien après un certain point
 
       if (sstr_elem.fail()) {
         sstr_elem.clear();
         sstr_elem.ignore();
         break;
       }
 
       node_index -= first_node_number;
       local_connect(read_order[j]) = node_index;
       j_last = j;
     }
 
     // check if element is written in two lines
     if (j_last != (node_per_element - 1)) {
 
       // if this is the case, read on more line
       my_getline(infile, lline);
       std::stringstream sstr_elem(lline);
 
       for (UInt j = (j_last + 1); j < node_per_element; ++j) {
 
         UInt node_index;
         sstr_elem >> node_index;
 
         node_index -= first_node_number;
         local_connect(read_order[j]) = node_index;
       }
     }
 
     connectivity->push_back(local_connect);
 
     elem.type = akantu_type;
-    elem.element = connectivity->getSize() - 1;
+    elem.element = connectivity->size() - 1;
 
     diana_element_number_to_elements[index] = elem;
     akantu_number_to_diana_number[elem] = index;
   }
 
   AKANTU_DEBUG_OUT();
   return lline;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readMaterialElement(std::ifstream & infile,
                                              Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   std::string line;
   std::stringstream sstr_tag_name;
   sstr_tag_name << "tag_" << 0;
 
   Mesh::type_iterator it = mesh.firstType();
   Mesh::type_iterator end = mesh.lastType();
   for (; it != end; ++it) {
     UInt nb_element = mesh.getNbElement(*it);
     mesh.getDataPointer<UInt>("material", *it, _not_ghost, 1)
         .resize(nb_element);
   }
 
   my_getline(infile, line);
   while (line != "'MATERIALS'") {
     line =
         line.substr(line.find('/') + 1,
                     std::string::npos); // erase the first slash / of the line
     char tutu[250];
     strcpy(tutu, line.c_str());
 
     AKANTU_DEBUG_WARNING("reading line " << line);
     Array<UInt> temp_id(0, 2);
     UInt mat;
     while (true) {
       std::stringstream sstr_intervals_elements(line);
       Vector<UInt> id(2);
       char temp;
       while (sstr_intervals_elements.good()) {
         sstr_intervals_elements >> id(0) >> temp >> id(1); // >> "/" >> mat;
         if (!sstr_intervals_elements.fail())
           temp_id.push_back(id);
       }
       if (sstr_intervals_elements.fail()) {
         sstr_intervals_elements.clear();
         sstr_intervals_elements.ignore();
         sstr_intervals_elements >> mat;
         break;
       }
       my_getline(infile, line);
     }
 
     // loop over elements
     //    UInt * temp_id_val = temp_id.storage();
-    for (UInt i = 0; i < temp_id.getSize(); ++i)
+    for (UInt i = 0; i < temp_id.size(); ++i)
       for (UInt j = temp_id(i, 0); j <= temp_id(i, 1); ++j) {
         Element & element = diana_element_number_to_elements[j];
         if (element.type == _not_defined)
           continue;
         UInt elem = element.element;
         ElementType type = element.type;
         Array<UInt> & data =
             mesh.getDataPointer<UInt>("material", type, _not_ghost);
         data(elem) = mat;
       }
 
     my_getline(infile, line);
   }
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 std::string MeshIODiana::readMaterial(std::ifstream & infile,
                                       const std::string & filename) {
   AKANTU_DEBUG_IN();
 
   std::stringstream mat_file_name;
 
   mat_file_name << "material_" << filename;
 
   std::ofstream material_file;
   material_file.open(mat_file_name.str().c_str()); // mat_file_name.str());
 
   UInt mat_index;
   std::string line;
 
   bool first_mat = true;
   bool end = false;
 
   UInt mat_id = 0;
 
   typedef std::map<std::string, Real> MatProp;
   MatProp mat_prop;
   do {
     my_getline(infile, line);
     std::stringstream sstr_material(line);
     if (("'GROUPS'" == line) || ("'END'" == line)) {
       if (!mat_prop.empty()) {
         material_file << "material elastic [" << std::endl;
         material_file << "\tname = material" << ++mat_id << std::endl;
         for (MatProp::iterator it = mat_prop.begin(); it != mat_prop.end();
              ++it)
           material_file << "\t" << it->first << " = " << it->second
                         << std::endl;
         material_file << "]" << std::endl;
         mat_prop.clear();
       }
       end = true;
     } else {
       /// traiter les caractéristiques des matériaux
       sstr_material >> mat_index;
 
       if (!sstr_material.fail()) {
         if (!first_mat) {
           if (!mat_prop.empty()) {
             material_file << "material elastic [" << std::endl;
             material_file << "\tname = material" << ++mat_id << std::endl;
             for (MatProp::iterator it = mat_prop.begin(); it != mat_prop.end();
                  ++it)
               material_file << "\t" << it->first << " = " << it->second
                             << std::endl;
             material_file << "]" << std::endl;
             mat_prop.clear();
           }
         }
         first_mat = false;
       } else {
         sstr_material.clear();
       }
 
       std::string prop_name;
       sstr_material >> prop_name;
 
       std::map<std::string, std::string>::iterator it;
       it = _diana_to_akantu_mat_prop.find(prop_name);
 
       if (it != _diana_to_akantu_mat_prop.end()) {
         Real value;
         sstr_material >> value;
         mat_prop[it->second] = value;
       } else {
         AKANTU_DEBUG_INFO("In material reader, property " << prop_name
                                                           << "not recognized");
       }
     }
   } while (!end);
 
   AKANTU_DEBUG_OUT();
   return line;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/io/mesh_io/mesh_io_msh.cc b/src/io/mesh_io/mesh_io_msh.cc
index a2efe333e..7ae088db1 100644
--- a/src/io/mesh_io/mesh_io_msh.cc
+++ b/src/io/mesh_io/mesh_io_msh.cc
@@ -1,981 +1,981 @@
 /**
  * @file   mesh_io_msh.cc
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Read/Write for MSH files generated by gmsh
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -----------------------------------------------------------------------------
    Version (Legacy) 1.0
 
    $NOD
    number-of-nodes
    node-number x-coord y-coord z-coord
    ...
    $ENDNOD
    $ELM
    number-of-elements
    elm-number elm-type reg-phys reg-elem number-of-nodes node-number-list
    ...
    $ENDELM
    -----------------------------------------------------------------------------
    Version 2.1
 
    $MeshFormat
    version-number file-type data-size
    $EndMeshFormat
    $Nodes
    number-of-nodes
    node-number x-coord y-coord z-coord
    ...
    $EndNodes
    $Elements
    number-of-elements
    elm-number elm-type number-of-tags < tag > ... node-number-list
    ...
    $EndElements
    $PhysicalNames
    number-of-names
    physical-dimension physical-number "physical-name"
    ...
    $EndPhysicalNames
    $NodeData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    node-number value ...
    ...
    $EndNodeData
    $ElementData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    elm-number value ...
    ...
    $EndElementData
    $ElementNodeData
    number-of-string-tags
    < "string-tag" >
    ...
    number-of-real-tags
    < real-tag >
    ...
    number-of-integer-tags
    < integer-tag >
    ...
    elm-number number-of-nodes-per-element value ...
    ...
    $ElementEndNodeData
 
    -----------------------------------------------------------------------------
    elem-type
 
    1:  2-node line.
    2:  3-node triangle.
    3:  4-node quadrangle.
    4:  4-node tetrahedron.
    5:  8-node hexahedron.
    6:  6-node prism.
    7:  5-node pyramid.
    8:  3-node second order line
    9:  6-node second order triangle
    10: 9-node second order quadrangle
    11: 10-node second order tetrahedron
    12: 27-node second order hexahedron
    13: 18-node second order prism
    14: 14-node second order pyramid
    15: 1-node point.
    16: 8-node second order quadrangle
    17: 20-node second order hexahedron
    18: 15-node second order prism
    19: 13-node second order pyramid
    20: 9-node third order incomplete triangle
    21: 10-node third order triangle
    22: 12-node fourth order incomplete triangle
    23: 15-node fourth order triangle
    24: 15-node fifth order incomplete triangle
    25: 21-node fifth order complete triangle
    26: 4-node third order edge
    27: 5-node fourth order edge
    28: 6-node fifth order edge
    29: 20-node third order tetrahedron
    30: 35-node fourth order tetrahedron
    31: 56-node fifth order tetrahedron
    -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_io.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 // The boost spirit is a work on the way it does not compile so I kept the
 // current code. The current code does not handle files generated on Windows
 // <CRLF>
 
 // #include <boost/config/warning_disable.hpp>
 // #include <boost/spirit/include/qi.hpp>
 // #include <boost/spirit/include/phoenix_core.hpp>
 // #include <boost/spirit/include/phoenix_fusion.hpp>
 // #include <boost/spirit/include/phoenix_object.hpp>
 // #include <boost/spirit/include/phoenix_container.hpp>
 // #include <boost/spirit/include/phoenix_operator.hpp>
 // #include <boost/spirit/include/phoenix_bind.hpp>
 // #include <boost/spirit/include/phoenix_stl.hpp>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /*   Methods Implentations                                                    */
 /* -------------------------------------------------------------------------- */
 MeshIOMSH::MeshIOMSH() {
   canReadSurface = true;
   canReadExtendedData = true;
 
   _msh_nodes_per_elem[_msh_not_defined] = 0;
   _msh_nodes_per_elem[_msh_segment_2] = 2;
   _msh_nodes_per_elem[_msh_triangle_3] = 3;
   _msh_nodes_per_elem[_msh_quadrangle_4] = 4;
   _msh_nodes_per_elem[_msh_tetrahedron_4] = 4;
   _msh_nodes_per_elem[_msh_hexahedron_8] = 8;
   _msh_nodes_per_elem[_msh_prism_1] = 6;
   _msh_nodes_per_elem[_msh_pyramid_1] = 1;
   _msh_nodes_per_elem[_msh_segment_3] = 3;
   _msh_nodes_per_elem[_msh_triangle_6] = 6;
   _msh_nodes_per_elem[_msh_quadrangle_9] = 9;
   _msh_nodes_per_elem[_msh_tetrahedron_10] = 10;
   _msh_nodes_per_elem[_msh_hexahedron_27] = 27;
   _msh_nodes_per_elem[_msh_hexahedron_20] = 20;
   _msh_nodes_per_elem[_msh_prism_18] = 18;
   _msh_nodes_per_elem[_msh_prism_15] = 15;
   _msh_nodes_per_elem[_msh_pyramid_14] = 14;
   _msh_nodes_per_elem[_msh_point] = 1;
   _msh_nodes_per_elem[_msh_quadrangle_8] = 8;
 
   _msh_to_akantu_element_types[_msh_not_defined] = _not_defined;
   _msh_to_akantu_element_types[_msh_segment_2] = _segment_2;
   _msh_to_akantu_element_types[_msh_triangle_3] = _triangle_3;
   _msh_to_akantu_element_types[_msh_quadrangle_4] = _quadrangle_4;
   _msh_to_akantu_element_types[_msh_tetrahedron_4] = _tetrahedron_4;
   _msh_to_akantu_element_types[_msh_hexahedron_8] = _hexahedron_8;
   _msh_to_akantu_element_types[_msh_prism_1] = _pentahedron_6;
   _msh_to_akantu_element_types[_msh_pyramid_1] = _not_defined;
   _msh_to_akantu_element_types[_msh_segment_3] = _segment_3;
   _msh_to_akantu_element_types[_msh_triangle_6] = _triangle_6;
   _msh_to_akantu_element_types[_msh_quadrangle_9] = _not_defined;
   _msh_to_akantu_element_types[_msh_tetrahedron_10] = _tetrahedron_10;
   _msh_to_akantu_element_types[_msh_hexahedron_27] = _not_defined;
   _msh_to_akantu_element_types[_msh_hexahedron_20] = _hexahedron_20;
   _msh_to_akantu_element_types[_msh_prism_18] = _not_defined;
   _msh_to_akantu_element_types[_msh_prism_15] = _pentahedron_15;
   _msh_to_akantu_element_types[_msh_pyramid_14] = _not_defined;
   _msh_to_akantu_element_types[_msh_point] = _point_1;
   _msh_to_akantu_element_types[_msh_quadrangle_8] = _quadrangle_8;
 
   _akantu_to_msh_element_types[_not_defined] = _msh_not_defined;
   _akantu_to_msh_element_types[_segment_2] = _msh_segment_2;
   _akantu_to_msh_element_types[_segment_3] = _msh_segment_3;
   _akantu_to_msh_element_types[_triangle_3] = _msh_triangle_3;
   _akantu_to_msh_element_types[_triangle_6] = _msh_triangle_6;
   _akantu_to_msh_element_types[_tetrahedron_4] = _msh_tetrahedron_4;
   _akantu_to_msh_element_types[_tetrahedron_10] = _msh_tetrahedron_10;
   _akantu_to_msh_element_types[_quadrangle_4] = _msh_quadrangle_4;
   _akantu_to_msh_element_types[_quadrangle_8] = _msh_quadrangle_8;
   _akantu_to_msh_element_types[_hexahedron_8] = _msh_hexahedron_8;
   _akantu_to_msh_element_types[_hexahedron_20] = _msh_hexahedron_20;
   _akantu_to_msh_element_types[_pentahedron_6] = _msh_prism_1;
   _akantu_to_msh_element_types[_pentahedron_15] = _msh_prism_15;
   _akantu_to_msh_element_types[_point_1] = _msh_point;
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
   _akantu_to_msh_element_types[_bernoulli_beam_2] = _msh_segment_2;
   _akantu_to_msh_element_types[_bernoulli_beam_3] = _msh_segment_2;
   _akantu_to_msh_element_types[_kirchhoff_shell] = _msh_triangle_3;
 #endif
 
   std::map<ElementType, MSHElementType>::iterator it;
   for (it = _akantu_to_msh_element_types.begin();
        it != _akantu_to_msh_element_types.end(); ++it) {
     UInt nb_nodes = _msh_nodes_per_elem[it->second];
 
     std::vector<UInt> tmp(nb_nodes);
     for (UInt i = 0; i < nb_nodes; ++i) {
       tmp[i] = i;
     }
 
     switch (it->first) {
     case _tetrahedron_10:
       tmp[8] = 9;
       tmp[9] = 8;
       break;
     case _pentahedron_6:
       tmp[0] = 2;
       tmp[1] = 0;
       tmp[2] = 1;
       tmp[3] = 5;
       tmp[4] = 3;
       tmp[5] = 4;
       break;
     case _pentahedron_15:
       tmp[0] = 2;
       tmp[1] = 0;
       tmp[2] = 1;
       tmp[3] = 5;
       tmp[4] = 3;
       tmp[5] = 4;
       tmp[6] = 8;
       tmp[8] = 11;
       tmp[9] = 6;
       tmp[10] = 9;
       tmp[11] = 10;
       tmp[12] = 14;
       tmp[14] = 12;
       break;
     case _hexahedron_20:
       tmp[9] = 11;
       tmp[10] = 12;
       tmp[11] = 9;
       tmp[12] = 13;
       tmp[13] = 10;
       tmp[17] = 19;
       tmp[18] = 17;
       tmp[19] = 18;
       break;
     default:
       // nothing to change
       break;
     }
     _read_order[it->first] = tmp;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 MeshIOMSH::~MeshIOMSH() {}
 
 /* -------------------------------------------------------------------------- */
 /* Spirit stuff                                                               */
 /* -------------------------------------------------------------------------- */
 // namespace _parser {
 //   namespace spirit  = ::boost::spirit;
 //   namespace qi      = ::boost::spirit::qi;
 //   namespace ascii   = ::boost::spirit::ascii;
 //   namespace lbs     = ::boost::spirit::qi::labels;
 //   namespace phx     = ::boost::phoenix;
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   /* Lazy functors */
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct _Element {
 //     int index;
 //     std::vector<int> tags;
 //     std::vector<int> connectivity;
 //     ElementType type;
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_get_nb_nodes_ {
 //     template <class elem_type> struct result { typedef int type; };
 //     template <class elem_type> bool operator()(elem_type et) {
 //       return MeshIOMSH::_msh_nodes_per_elem[et];
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_element_ {
 //     template <class id_t, class tags_t, class elem_type, class conn_t>
 //     struct result {
 //       typedef _Element type;
 //     };
 //     template <class id_t, class tags_t, class elem_type, class conn_t>
 //     _Element operator()(id_t id, const elem_type & et, const tags_t & t,
 //                        const conn_t & c) {
 //       _Element tmp_el;
 //       tmp_el.index = id;
 //       tmp_el.tags = t;
 //       tmp_el.connectivity = c;
 //       tmp_el.type = et;
 //       return tmp_el;
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_check_value_ {
 //     template <class T> struct result { typedef void type; };
 //     template <class T> void operator()(T v1, T v2) {
 //       if (v1 != v2) {
 //         AKANTU_EXCEPTION("The msh parser expected a "
 //                          << v2 << " in the header bug got a " << v1);
 //       }
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_node_read_ {
 //     template <class Mesh, class ID, class V, class size, class Map>
 //     struct result {
 //       typedef bool type;
 //     };
 //     template <class Mesh, class ID, class V, class size, class Map>
 //     bool operator()(Mesh & mesh, const ID & id, const V & pos, size max,
 //                     Map & nodes_mapping) const {
 //       Vector<Real> tmp_pos(mesh.getSpatialDimension());
 //       UInt i = 0;
 //       for (typename V::const_iterator it = pos.begin();
 //            it != pos.end() || i < mesh.getSpatialDimension(); ++it)
 //         tmp_pos[i++] = *it;
 
 //       nodes_mapping[id] = mesh.getNbNodes();
 //       mesh.getNodes().push_back(tmp_pos);
 //       return (mesh.getNbNodes() < UInt(max));
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   struct lazy_element_read_ {
 //     template <class Mesh, class EL, class size, class NodeMap, class ElemMap>
 //     struct result {
 //       typedef bool type;
 //     };
 
 //     template <class Mesh, class EL, class size, class NodeMap, class ElemMap>
 //     bool operator()(Mesh & mesh, const EL & element, size max,
 //                     const NodeMap & nodes_mapping,
 //                     ElemMap & elements_mapping) const {
 //       Vector<UInt> tmp_conn(Mesh::getNbNodesPerElement(element.type));
 
 //       AKANTU_DEBUG_ASSERT(element.connectivity.size() == tmp_conn.size(),
 //                           "The element "
 //                               << element.index
 //                               << "in the MSH file has too many nodes.");
 
 //       mesh.addConnectivityType(element.type);
 //       Array<UInt> & connectivity = mesh.getConnectivity(element.type);
 
 //       UInt i = 0;
 //       for (std::vector<int>::const_iterator it =
 //       element.connectivity.begin();
 //            it != element.connectivity.end(); ++it) {
 //         typename NodeMap::const_iterator nit = nodes_mapping.find(*it);
 //         AKANTU_DEBUG_ASSERT(nit != nodes_mapping.end(),
 //                             "There is an unknown node in the connectivity.");
 //         tmp_conn[i++] = nit->second;
 //       }
 
-//       ::akantu::Element el(element.type, connectivity.getSize());
+//       ::akantu::Element el(element.type, connectivity.size());
 //       elements_mapping[element.index] = el;
 
 //       connectivity.push_back(tmp_conn);
 
 //       for (UInt i = 0; i < element.tags.size(); ++i) {
 //         std::stringstream tag_sstr;
 //         tag_sstr << "tag_" << i;
 //         Array<UInt> * data =
 //             mesh.template getDataPointer<UInt>(tag_sstr.str(), element.type,
 //             _not_ghost);
 //         data->push_back(element.tags[i]);
 //       }
 
 //       return (mesh.getNbElement() < UInt(max));
 //     }
 //   };
 
 //   /* ------------------------------------------------------------------------
 //   */
 //   template <class Iterator, typename Skipper = ascii::space_type>
 //   struct MshMeshGrammar : qi::grammar<Iterator, void(), Skipper> {
 //   public:
 //     MshMeshGrammar(Mesh & mesh)
 //         : MshMeshGrammar::base_type(start, "msh_mesh_reader"), mesh(mesh) {
 //       phx::function<lazy_element_> lazy_element;
 //       phx::function<lazy_get_nb_nodes_> lazy_get_nb_nodes;
 //       phx::function<lazy_check_value_> lazy_check_value;
 //       phx::function<lazy_node_read_> lazy_node_read;
 //       phx::function<lazy_element_read_> lazy_element_read;
 
 // clang-format off
 
 //       start
 //         =  *( known_section | unknown_section
 //             )
 //        ;
 
 //       known_section
 //         =  qi::char_("$")
 //            >> sections            [ lbs::_a = lbs::_1 ]
 //            >> qi::lazy(*lbs::_a)
 //            >> qi::lit("$End")
 //           //>> qi::lit(phx::ref(lbs::_a))
 //         ;
 
 //       unknown_section
 //         =  qi::char_("$")
 //            >> qi::char_("")     [ lbs::_a = lbs::_1 ]
 //            >> ignore_section
 //            >> qi::lit("$End")
 //            >> qi::lit(phx::val(lbs::_a))
 //         ;
 
 //       mesh_format // version followed by 0 or 1 for ascii or binary
 //         =  version >> (
 //                         ( qi::char_("0")
 //                           >> qi::int_       [ lazy_check_value(lbs::_1, 8) ]
 //                         )
 //                         | ( qi::char_("1")
 //                             >> qi::int_     [ lazy_check_value(lbs::_1, 8) ]
 //                             >> qi::dword    [ lazy_check_value(lbs::_1, 1) ]
 //                           )
 //                         )
 //         ;
 
 //       nodes
 //         =  nodes_
 //         ;
 
 //       nodes_
 //         =  qi::int_                      [ lbs::_a = lbs::_1 ]
 //            > *(
 //                 ( qi::int_ >> position ) [ lazy_node_read(phx::ref(mesh),
 //                                                           lbs::_1,
 //                                                           phx::cref(lbs::_2),
 //                                                           lbs::_a,
 //                                                           phx::ref(this->msh_nodes_to_akantu)) ]
 //               )
 //         ;
 
 //       element
 //         =  elements_
 //         ;
 
 //       elements_
 //         =  qi::int_                                 [ lbs::_a = lbs::_1 ]
 //            > qi::repeat(phx::ref(lbs::_a))[ element [ lazy_element_read(phx::ref(mesh),
 //                                                                         lbs::_1,
 //                                                                         phx::cref(lbs::_a),
 //                                                                         phx::cref(this->msh_nodes_to_akantu),
 //                                                                         phx::ref(this->msh_elemt_to_akantu)) ]]
 //         ;
 
 //       ignore_section
 //         =  *(qi::char_ - qi::char_('$'))
 //         ;
 
 //       interpolation_scheme = ignore_section;
 //       element_data         = ignore_section;
 //       node_data            = ignore_section;
 
 //       version
 //         =  qi::int_                         [ phx::push_back(lbs::_val, lbs::_1) ]
 //            >> *( qi::char_(".") >> qi::int_ [ phx::push_back(lbs::_val, lbs::_1) ] )
 //         ;
 
 //       position
 //         =  real   [ phx::push_back(lbs::_val, lbs::_1) ]
 //            > real [ phx::push_back(lbs::_val, lbs::_1) ]
 //            > real [ phx::push_back(lbs::_val, lbs::_1) ]
 //         ;
 
 //       tags
 //         =  qi::int_      [ lbs::_a = lbs::_1 ]
 //           > qi::repeat(phx::val(lbs::_a))[ qi::int_ [ phx::push_back(lbs::_val,
 //                                                                      lbs::_1) ] ]
 //         ;
 
 //       element
 //         =  ( qi::int_                [ lbs::_a = lbs::_1 ]
 //              > msh_element_type      [ lbs::_b = lazy_get_nb_nodes(lbs::_1) ]
 //              > tags                  [ lbs::_c = lbs::_1 ]
 //              > connectivity(lbs::_a) [ lbs::_d = lbs::_1 ]
 //            )                         [ lbs::_val = lazy_element(lbs::_a,
 //                                                                 phx::cref(lbs::_b),
 //                                                                 phx::cref(lbs::_c),
 //                                                                 phx::cref(lbs::_d)) ]
 //         ;
 //       connectivity
 //         =  qi::repeat(lbs::_r1)[ qi::int_ [ phx::push_back(lbs::_val,
 //                                                            lbs::_1) ] ]
 //         ;
 
 //       sections.add
 //           ("MeshFormat", &mesh_format)
 //           ("Nodes", &nodes)
 //           ("Elements", &elements)
 //           ("PhysicalNames", &physical_names)
 //           ("InterpolationScheme", &interpolation_scheme)
 //           ("ElementData", &element_data)
 //           ("NodeData", &node_data);
 
 //       msh_element_type.add
 //           ("0" , _not_defined   )
 //           ("1" , _segment_2     )
 //           ("2" , _triangle_3    )
 //           ("3" , _quadrangle_4  )
 //           ("4" , _tetrahedron_4 )
 //           ("5" , _hexahedron_8  )
 //           ("6" , _pentahedron_6 )
 //           ("7" , _not_defined   )
 //           ("8" , _segment_3     )
 //           ("9" , _triangle_6    )
 //           ("10", _not_defined   )
 //           ("11", _tetrahedron_10)
 //           ("12", _not_defined   )
 //           ("13", _not_defined   )
 //           ("14", _hexahedron_20 )
 //           ("15", _pentahedron_15)
 //           ("16", _not_defined   )
 //           ("17", _point_1       )
 //           ("18", _quadrangle_8  );
 
 //       mesh_format         .name("MeshFormat"         );
 //       nodes               .name("Nodes"              );
 //       elements            .name("Elements"           );
 //       physical_names      .name("PhysicalNames"      );
 //       interpolation_scheme.name("InterpolationScheme");
 //       element_data        .name("ElementData"        );
 //       node_data           .name("NodeData"           );
 
 // clang-format on
 //     }
 
 //     /* ----------------------------------------------------------------------
 //     */
 //     /* Rules */
 //     /* ----------------------------------------------------------------------
 //     */
 //   private:
 //     qi::symbols<char, ElementType> msh_element_type;
 //     qi::symbols<char, qi::rule<Iterator, void(), Skipper> *> sections;
 //     qi::rule<Iterator, void(), Skipper> start;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<std::string> >
 //     unknown_section;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<qi::rule<Iterator,
 //     Skipper> *> > known_section;
 //     qi::rule<Iterator, void(), Skipper> mesh_format, nodes, elements,
 //     physical_names, ignore_section,
 //         interpolation_scheme, element_data, node_data, any_line;
 //     qi::rule<Iterator, void(), Skipper, qi::locals<int> > nodes_;
 //     qi::rule<Iterator, void(), Skipper, qi::locals< int, int, vector<int>,
 //     vector<int> > > elements_;
 
 //     qi::rule<Iterator, std::vector<int>(), Skipper> version;
 //     qi::rule<Iterator, _Element(), Skipper, qi::locals<ElementType> >
 //     element;
 //     qi::rule<Iterator, std::vector<int>(), Skipper, qi::locals<int> > tags;
 //     qi::rule<Iterator, std::vector<int>(int), Skipper> connectivity;
 //     qi::rule<Iterator, std::vector<Real>(), Skipper> position;
 
 //     qi::real_parser<Real, qi::real_policies<Real> > real;
 
 //     /* ----------------------------------------------------------------------
 //     */
 //     /* Members */
 //     /* ----------------------------------------------------------------------
 //     */
 //   private:
 //     /// reference to the mesh to read
 //     Mesh & mesh;
 
 //     /// correspondance between the numbering of nodes in the abaqus file and
 //     in
 //     /// the akantu mesh
 //     std::map<UInt, UInt> msh_nodes_to_akantu;
 
 //     /// correspondance between the element number in the abaqus file and the
 //     /// Element in the akantu mesh
 //     std::map<UInt, Element> msh_elemt_to_akantu;
 //   };
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void MeshIOAbaqus::read(const std::string& filename, Mesh& mesh) {
 //   namespace qi      = boost::spirit::qi;
 //   namespace ascii   = boost::spirit::ascii;
 
 //   std::ifstream infile;
 //   infile.open(filename.c_str());
 
 //   if(!infile.good()) {
 //     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
 //   }
 
 //   std::string storage; // We will read the contents here.
 //   infile.unsetf(std::ios::skipws); // No white space skipping!
 //   std::copy(std::istream_iterator<char>(infile),
 //             std::istream_iterator<char>(),
 //             std::back_inserter(storage));
 
 //   typedef std::string::const_iterator iterator_t;
 //   typedef ascii::space_type skipper;
 //   typedef _parser::MshMeshGrammar<iterator_t, skipper> grammar;
 
 //   grammar g(mesh);
 //   skipper ws;
 
 //   iterator_t iter = storage.begin();
 //   iterator_t end  = storage.end();
 
 //   qi::phrase_parse(iter, end, g, ws);
 
-//   this->setNbGlobalNodes(mesh, mesh.getNodes().getSize());
+//   this->setNbGlobalNodes(mesh, mesh.getNodes().size());
 //   MeshUtils::fillElementToSubElementsData(mesh);
 // }
 
 static void my_getline(std::ifstream & infile, std::string & str) {
   std::string tmp_str;
   std::getline(infile, tmp_str);
   str = trim(tmp_str);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIOMSH::read(const std::string & filename, Mesh & mesh) {
 
   MeshAccessor mesh_accessor(mesh);
 
   std::ifstream infile;
   infile.open(filename.c_str());
 
   std::string line;
   UInt first_node_number = std::numeric_limits<UInt>::max(),
        last_node_number = 0, file_format = 1, current_line = 0;
   bool has_physical_names = false;
 
   if (!infile.good()) {
     AKANTU_DEBUG_ERROR("Cannot open file " << filename);
   }
 
   while (infile.good()) {
     my_getline(infile, line);
     current_line++;
 
     /// read the header
     if (line == "$MeshFormat") {
       my_getline(infile, line); /// the format line
       std::stringstream sstr(line);
       std::string version;
       sstr >> version;
       Int format;
       sstr >> format;
       if (format != 0)
         AKANTU_DEBUG_ERROR("This reader can only read ASCII files.");
       my_getline(infile, line); /// the end of block line
       current_line += 2;
       file_format = 2;
     }
 
     /// read the physical names
     if (line == "$PhysicalNames") {
       has_physical_names = true;
       my_getline(infile, line); /// the format line
       std::stringstream sstr(line);
 
       UInt num_of_phys_names;
       sstr >> num_of_phys_names;
 
       for (UInt k(0); k < num_of_phys_names; k++) {
         my_getline(infile, line);
         std::stringstream sstr_phys_name(line);
         UInt phys_name_id;
         UInt phys_dim;
 
         sstr_phys_name >> phys_dim >> phys_name_id;
 
         std::size_t b = line.find("\"");
         std::size_t e = line.rfind("\"");
         std::string phys_name = line.substr(b + 1, e - b - 1);
 
         phys_name_map[phys_name_id] = phys_name;
       }
     }
 
     /// read all nodes
     if (line == "$Nodes" || line == "$NOD") {
       UInt nb_nodes;
 
       my_getline(infile, line);
       std::stringstream sstr(line);
       sstr >> nb_nodes;
       current_line++;
 
       Array<Real> & nodes = mesh_accessor.getNodes();
       nodes.resize(nb_nodes);
       mesh_accessor.setNbGlobalNodes(nb_nodes);
 
       UInt index;
       Real coord[3];
       UInt spatial_dimension = nodes.getNbComponent();
       /// for each node, read the coordinates
       for (UInt i = 0; i < nb_nodes; ++i) {
         UInt offset = i * spatial_dimension;
 
         my_getline(infile, line);
         std::stringstream sstr_node(line);
         sstr_node >> index >> coord[0] >> coord[1] >> coord[2];
         current_line++;
 
         first_node_number = std::min(first_node_number, index);
         last_node_number = std::max(last_node_number, index);
 
         /// read the coordinates
         for (UInt j = 0; j < spatial_dimension; ++j)
           nodes.storage()[offset + j] = coord[j];
       }
       my_getline(infile, line); /// the end of block line
     }
 
     /// read all elements
     if (line == "$Elements" || line == "$ELM") {
       UInt nb_elements;
 
       std::vector<UInt> read_order;
 
       my_getline(infile, line);
       std::stringstream sstr(line);
       sstr >> nb_elements;
       current_line++;
 
       Int index;
       UInt msh_type;
       ElementType akantu_type, akantu_type_old = _not_defined;
       Array<UInt> * connectivity = NULL;
       UInt node_per_element = 0;
 
       for (UInt i = 0; i < nb_elements; ++i) {
         my_getline(infile, line);
         std::stringstream sstr_elem(line);
         current_line++;
 
         sstr_elem >> index;
         sstr_elem >> msh_type;
 
         /// get the connectivity vector depending on the element type
         akantu_type = this->_msh_to_akantu_element_types[(MSHElementType)msh_type];
 
         if (akantu_type == _not_defined) {
           AKANTU_DEBUG_WARNING("Unsuported element kind "
                                << msh_type << " at line " << current_line);
           continue;
         }
 
         if (akantu_type != akantu_type_old) {
           connectivity = &mesh_accessor.getConnectivity(akantu_type);
           //          connectivity->resize(0);
 
           node_per_element = connectivity->getNbComponent();
           akantu_type_old = akantu_type;
           read_order = this->_read_order[akantu_type];
         }
 
         /// read tags informations
         if (file_format == 2) {
           UInt nb_tags;
           sstr_elem >> nb_tags;
           for (UInt j = 0; j < nb_tags; ++j) {
             Int tag;
             sstr_elem >> tag;
             std::stringstream sstr_tag_name;
             sstr_tag_name << "tag_" << j;
             Array<UInt> & data = mesh.getDataPointer<UInt>(
                 sstr_tag_name.str(), akantu_type, _not_ghost);
             data.push_back(tag);
           }
         } else if (file_format == 1) {
           Int tag;
           sstr_elem >> tag; // reg-phys
           std::string tag_name = "tag_0";
           Array<UInt> * data =
               &mesh.getDataPointer<UInt>(tag_name, akantu_type, _not_ghost);
           data->push_back(tag);
 
           sstr_elem >> tag; // reg-elem
           tag_name = "tag_1";
           data = &mesh.getDataPointer<UInt>(tag_name, akantu_type, _not_ghost);
           data->push_back(tag);
 
           sstr_elem >> tag; // number-of-nodes
         }
 
         Vector<UInt> local_connect(node_per_element);
         for (UInt j = 0; j < node_per_element; ++j) {
           UInt node_index;
           sstr_elem >> node_index;
 
           AKANTU_DEBUG_ASSERT(node_index <= last_node_number,
                               "Node number not in range : line "
                               << current_line);
 
           node_index -= first_node_number;
           local_connect(read_order[j]) = node_index;
         }
         connectivity->push_back(local_connect);
       }
       my_getline(infile, line); /// the end of block line
     }
 
     if ((line[0] == '$') && (line.find("End") == std::string::npos)) {
       AKANTU_DEBUG_WARNING("Unsuported block_kind " << line << " at line "
                                                     << current_line);
     }
   }
 
   //mesh.updateTypesOffsets(_not_ghost);
 
   infile.close();
 
   this->constructPhysicalNames("tag_0", mesh);
 
   if (has_physical_names)
     mesh.createGroupsFromMeshData<std::string>("physical_names");
 
   MeshUtils::fillElementToSubElementsData(mesh);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshIOMSH::write(const std::string & filename, const Mesh & mesh) {
   std::ofstream outfile;
   const Array<Real> & nodes = mesh.getNodes();
 
   outfile.open(filename.c_str());
 
   outfile << "$MeshFormat" << std::endl;
   outfile << "2.1 0 8" << std::endl;
   outfile << "$EndMeshFormat" << std::endl;
 
   outfile << std::setprecision(std::numeric_limits<Real>::digits10);
   outfile << "$Nodes" << std::endl;
 
-  outfile << nodes.getSize() << std::endl;
+  outfile << nodes.size() << std::endl;
 
   outfile << std::uppercase;
-  for (UInt i = 0; i < nodes.getSize(); ++i) {
+  for (UInt i = 0; i < nodes.size(); ++i) {
     Int offset = i * nodes.getNbComponent();
     outfile << i + 1;
     for (UInt j = 0; j < nodes.getNbComponent(); ++j) {
       outfile << " " << nodes.storage()[offset + j];
     }
 
     for (UInt p = nodes.getNbComponent(); p < 3; ++p)
       outfile << " " << 0.;
     outfile << std::endl;
     ;
   }
   outfile << std::nouppercase;
   outfile << "$EndNodes" << std::endl;
   ;
 
   outfile << "$Elements" << std::endl;
   ;
 
   Mesh::type_iterator it =
       mesh.firstType(_all_dimensions, _not_ghost, _ek_not_defined);
   Mesh::type_iterator end =
       mesh.lastType(_all_dimensions, _not_ghost, _ek_not_defined);
 
   Int nb_elements = 0;
   for (; it != end; ++it) {
     const Array<UInt> & connectivity = mesh.getConnectivity(*it, _not_ghost);
-    nb_elements += connectivity.getSize();
+    nb_elements += connectivity.size();
   }
   outfile << nb_elements << std::endl;
 
   UInt element_idx = 1;
   for (it = mesh.firstType(_all_dimensions, _not_ghost, _ek_not_defined);
        it != end; ++it) {
     ElementType type = *it;
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     UInt * tag[2] = {NULL, NULL};
     try {
       const Array<UInt> & data_tag_0 =
           mesh.getData<UInt>("tag_0", type, _not_ghost);
       tag[0] = data_tag_0.storage();
     } catch (...) {
       tag[0] = NULL;
     }
 
     try {
       const Array<UInt> & data_tag_1 =
           mesh.getData<UInt>("tag_1", type, _not_ghost);
       tag[1] = data_tag_1.storage();
     } catch (...) {
       tag[1] = NULL;
     }
 
-    for (UInt i = 0; i < connectivity.getSize(); ++i) {
+    for (UInt i = 0; i < connectivity.size(); ++i) {
       UInt offset = i * connectivity.getNbComponent();
       outfile << element_idx << " " << _akantu_to_msh_element_types[type]
               << " 2";
 
       /// \todo write the real data in the file
       for (UInt t = 0; t < 2; ++t)
         if (tag[t])
           outfile << " " << tag[t][i];
         else
           outfile << " 0";
 
       for (UInt j = 0; j < connectivity.getNbComponent(); ++j) {
         outfile << " " << connectivity.storage()[offset + j] + 1;
       }
       outfile << std::endl;
       element_idx++;
     }
   }
 
   outfile << "$EndElements" << std::endl;
   ;
 
   outfile.close();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/mesh/element_group.cc b/src/mesh/element_group.cc
index 591a66141..13a34de66 100644
--- a/src/mesh/element_group.cc
+++ b/src/mesh/element_group.cc
@@ -1,201 +1,201 @@
 /**
  * @file   element_group.cc
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Tue Aug 18 2015
  *
  * @brief  Stores information relevent to the notion of domain boundary and surfaces.
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <sstream>
 #include <algorithm>
 #include <iterator>
 #include "mesh.hh"
 #include "group_manager.hh"
 #include "group_manager_inline_impl.cc"
 #include "dumpable.hh"
 #include "dumpable_inline_impl.hh"
 #include "aka_csr.hh"
 #include "mesh_utils.hh"
 
 #include "element_group.hh"
 #if defined(AKANTU_USE_IOHELPER)
 #  include "dumper_paraview.hh"
 #endif
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 ElementGroup::ElementGroup(const std::string & group_name,
                            const Mesh & mesh,
                            NodeGroup & node_group,
                            UInt dimension,
                            const std::string & id,
                            const MemoryID & mem_id) :
   Memory(id, mem_id),
   mesh(mesh),
   name(group_name),
   elements("elements", id, mem_id),
   node_group(node_group),
   dimension(dimension) {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_USE_IOHELPER)
   this->registerDumper<DumperParaview>("paraview_"  + group_name, group_name, true);
   this->addDumpFilteredMesh(mesh, elements, node_group.getNodes(), dimension);
 #endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::empty() {
   elements.free();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::append(const ElementGroup & other_group) {
   AKANTU_DEBUG_IN();
 
   node_group.append(other_group.node_group);
 
   /// loop on all element types in all dimensions
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
 
     type_iterator it = other_group.firstType(_all_dimensions,
                                              ghost_type,
                                              _ek_not_defined);
     type_iterator last = other_group.lastType(_all_dimensions,
                                               ghost_type,
                                               _ek_not_defined);
 
     for (; it != last; ++it) {
       ElementType type = *it;
       const Array<UInt> & other_elem_list = other_group.elements(type, ghost_type);
-      UInt nb_other_elem = other_elem_list.getSize();
+      UInt nb_other_elem = other_elem_list.size();
 
       Array<UInt> * elem_list;
       UInt nb_elem = 0;
 
       /// create current type if doesn't exists, otherwise get information
       if (elements.exists(type, ghost_type)) {
         elem_list = &elements(type, ghost_type);
-        nb_elem = elem_list->getSize();
+        nb_elem = elem_list->size();
       }
       else {
         elem_list = &(elements.alloc(0, 1, type, ghost_type));
       }
 
       /// append new elements to current list
       elem_list->resize(nb_elem + nb_other_elem);
       std::copy(other_elem_list.begin(),
                 other_elem_list.end(),
                 elem_list->begin() + nb_elem);
 
       /// remove duplicates
       std::sort(elem_list->begin(), elem_list->end());
       Array<UInt>::iterator<> end = std::unique(elem_list->begin(), elem_list->end());
       elem_list->resize(end - elem_list->begin());
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::printself(std::ostream & stream, int indent) const {
   std::string space;
   for(Int i = 0; i < indent; i++, space += AKANTU_INDENT);
 
   stream << space << "ElementGroup [" << std::endl;
   stream << space << " + name: "      << name << std::endl;
   stream << space << " + dimension: " << dimension << std::endl;
   elements.printself(stream, indent + 1);
   node_group.printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::optimize() {
   // increasing the locality of data when iterating on the element of a group
   for (ghost_type_t::iterator gt = ghost_type_t::begin();  gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     ElementList::type_iterator it = elements.firstType(_all_dimensions, ghost_type);
     ElementList::type_iterator last = elements.lastType(_all_dimensions, ghost_type);
     for (; it != last; ++it) {
       Array<UInt> & els = elements(*it, ghost_type);
       std::sort(els.begin(), els.end());
 
       Array<UInt>::iterator<> end = std::unique(els.begin(), els.end());
       els.resize(end - els.begin());
     }
   }
 
   node_group.optimize();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::fillFromNodeGroup() {
   CSR<Element> node_to_elem;
   MeshUtils::buildNode2Elements(this->mesh, node_to_elem, this->dimension);
 
   std::set<Element> seen;
 
   Array<UInt>::const_iterator<> itn  = this->node_group.begin();
   Array<UInt>::const_iterator<> endn = this->node_group.end();
   for (;itn != endn; ++itn) {
     CSR<Element>::iterator ite = node_to_elem.begin(*itn);
     CSR<Element>::iterator ende = node_to_elem.end(*itn);
     for (;ite != ende; ++ite) {
       const Element & elem = *ite;
       if(this->dimension != _all_dimensions && this->dimension != Mesh::getSpatialDimension(elem.type)) continue;
       if(seen.find(elem) != seen.end()) continue;
 
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(elem.type);
       Array<UInt>::const_iterator< Vector<UInt> > conn_it =
         this->mesh.getConnectivity(elem.type, elem.ghost_type).begin(nb_nodes_per_element);
       const Vector<UInt> & conn = conn_it[elem.element];
 
       UInt count = 0;
       for (UInt n = 0; n < conn.size(); ++n) {
-        count += (this->node_group.getNodes().find(conn(n)) != -1 ? 1 : 0);
+        count += (this->node_group.getNodes().find(conn(n)) != UInt(-1) ? 1 : 0);
       }
 
       if(count == nb_nodes_per_element) this->add(elem);
 
       seen.insert(elem);
     }
   }
 
   this->optimize();
 }
 
 /* -------------------------------------------------------------------------- */
 
 
 } // akantu
diff --git a/src/mesh/element_group_inline_impl.cc b/src/mesh/element_group_inline_impl.cc
index ebd1bd249..bd084f56c 100644
--- a/src/mesh/element_group_inline_impl.cc
+++ b/src/mesh/element_group_inline_impl.cc
@@ -1,146 +1,146 @@
 /**
  * @file   element_group_inline_impl.cc
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Tue Aug 18 2015
  *
  * @brief Stores information relevent to the notion of domain boundary and
  * surfaces.
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "mesh.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_GROUP_INLINE_IMPL_CC__
 #define __AKANTU_ELEMENT_GROUP_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline void ElementGroup::add(const Element & el, bool add_nodes,
                               bool check_for_duplicate) {
   this->add(el.type, el.element, el.ghost_type, add_nodes, check_for_duplicate);
 }
 
 /* -------------------------------------------------------------------------- */
 
 inline void ElementGroup::add(const ElementType & type, UInt element,
                               const GhostType & ghost_type, bool add_nodes,
                               bool check_for_duplicate) {
 
   addElement(type, element, ghost_type);
 
   if (add_nodes) {
     Array<UInt>::const_vector_iterator it =
         mesh.getConnectivity(type, ghost_type)
             .begin(mesh.getNbNodesPerElement(type)) +
         element;
     const Vector<UInt> & conn = *it;
     for (UInt i = 0; i < conn.size(); ++i)
       addNode(conn[i], check_for_duplicate);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void ElementGroup::addNode(UInt node_id, bool check_for_duplicate) {
   node_group.add(node_id, check_for_duplicate);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void ElementGroup::removeNode(UInt node_id) {
   node_group.remove(node_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void ElementGroup::addElement(const ElementType & elem_type,
                                      UInt elem_id,
                                      const GhostType & ghost_type) {
   if (!(elements.exists(elem_type, ghost_type))) {
     elements.alloc(0, 1, elem_type, ghost_type);
   }
 
   elements(elem_type, ghost_type).push_back(elem_id);
   this->dimension = UInt(
       std::max(Int(this->dimension), Int(mesh.getSpatialDimension(elem_type))));
 }
 
 /* -------------------------------------------------------------------------- */
-inline UInt ElementGroup::getNbNodes() const { return node_group.getSize(); }
+inline UInt ElementGroup::getNbNodes() const { return node_group.size(); }
 
 /* -------------------------------------------------------------------------- */
 inline ElementGroup::type_iterator
 ElementGroup::firstType(UInt dim, const GhostType & ghost_type,
                         const ElementKind & kind) const {
   return elements.firstType(dim, ghost_type, kind);
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementGroup::type_iterator
 ElementGroup::lastType(UInt dim, const GhostType & ghost_type,
                        const ElementKind & kind) const {
   return elements.lastType(dim, ghost_type, kind);
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementGroup::const_element_iterator
 ElementGroup::begin(const ElementType & type,
                     const GhostType & ghost_type) const {
   if (elements.exists(type, ghost_type)) {
     return elements(type, ghost_type).begin();
   } else {
     return empty_elements.begin();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementGroup::const_element_iterator
 ElementGroup::end(const ElementType & type,
                   const GhostType & ghost_type) const {
   if (elements.exists(type, ghost_type)) {
     return elements(type, ghost_type).end();
   } else {
     return empty_elements.end();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<UInt> &
 ElementGroup::getElements(const ElementType & type,
                           const GhostType & ghost_type) const {
   if (elements.exists(type, ghost_type)) {
     return elements(type, ghost_type);
   } else {
     return empty_elements;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_GROUP_INLINE_IMPL_CC__ */
diff --git a/src/mesh/element_type_map_filter.hh b/src/mesh/element_type_map_filter.hh
index 99b94ae06..4ec7b72b2 100644
--- a/src/mesh/element_type_map_filter.hh
+++ b/src/mesh/element_type_map_filter.hh
@@ -1,335 +1,335 @@
 /**
  * @file   element_type_map_filter.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Fri Dec 18 2015
  *
  * @brief  Filtered version based on a an akantu::ElementGroup of a
  * akantu::ElementTypeMap
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_BY_ELEMENT_TYPE_FILTER_HH__
 #define __AKANTU_BY_ELEMENT_TYPE_FILTER_HH__
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* ArrayFilter                                                                */
 /* -------------------------------------------------------------------------- */
 
 template <typename T> class ArrayFilter {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   /// standard iterator
   template <typename R = T> class iterator {
     inline bool operator!=(__attribute__((unused)) iterator<R> & other) { throw; };
     inline bool operator==(__attribute__((unused)) iterator<R> & other) { throw; };
 
     inline iterator<R> & operator++() { throw; };
     inline T operator*() {
       throw;
       return T();
     };
   };
 
   /// const iterator
   template <template <class S> class original_iterator, typename Shape,
             typename filter_iterator>
   class const_iterator {
 
   public:
     UInt getCurrentIndex() {
       return (*this->filter_it * this->nb_item_per_elem +
               this->sub_element_counter);
     }
 
     inline const_iterator(){};
     inline const_iterator(const original_iterator<Shape> & origin_it,
                           const filter_iterator & filter_it,
                           UInt nb_item_per_elem)
         : origin_it(origin_it), filter_it(filter_it),
           nb_item_per_elem(nb_item_per_elem), sub_element_counter(0){};
 
     inline bool operator!=(const_iterator & other) const {
       return !((*this) == other);
     }
     inline bool operator==(const_iterator & other) const {
       return (this->origin_it == other.origin_it &&
               this->filter_it == other.filter_it &&
               this->sub_element_counter == other.sub_element_counter);
     }
 
     inline bool operator!=(const const_iterator & other) const {
       return !((*this) == other);
     }
     inline bool operator==(const const_iterator & other) const {
       return (this->origin_it == other.origin_it &&
               this->filter_it == other.filter_it &&
               this->sub_element_counter == other.sub_element_counter);
     }
 
     inline const_iterator & operator++() {
 
       ++sub_element_counter;
       if (sub_element_counter == nb_item_per_elem) {
         sub_element_counter = 0;
         ++filter_it;
       }
       return *this;
     };
 
     inline Shape operator*() {
       return origin_it[nb_item_per_elem * (*filter_it) + sub_element_counter];
     };
 
   private:
     original_iterator<Shape> origin_it;
     filter_iterator filter_it;
 
     /// the number of item per element
     UInt nb_item_per_elem;
     /// counter for every sub element group
     UInt sub_element_counter;
   };
 
   typedef iterator<Vector<T> > vector_iterator;
 
   typedef Array<T> array_type;
 
   typedef const_iterator<array_type::template const_iterator, Vector<T>,
                          Array<UInt>::const_iterator<UInt> >
       const_vector_iterator;
 
   typedef typename array_type::value_type value_type;
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   ArrayFilter(const Array<T> & array, const Array<UInt> & filter,
               UInt nb_item_per_elem)
       : array(array), filter(filter), nb_item_per_elem(nb_item_per_elem){};
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
   const_vector_iterator begin_reinterpret(UInt n, UInt new_size) const {
     AKANTU_DEBUG_ASSERT(
-        n * new_size == this->getNbComponent() * this->getSize(),
+        n * new_size == this->getNbComponent() * this->size(),
         "The new values for size ("
             << new_size << ") and nb_component (" << n
             << ") are not compatible with the one of this array("
-            << this->getSize() << "," << this->getNbComponent() << ")");
+            << this->size() << "," << this->getNbComponent() << ")");
     UInt new_full_array_size =
-        this->array.getSize() * array.getNbComponent() / n;
+        this->array.size() * array.getNbComponent() / n;
     UInt new_nb_item_per_elem = this->nb_item_per_elem;
     if (new_size != 0 && n != 0)
       new_nb_item_per_elem = this->array.getNbComponent() *
-                             this->filter.getSize() * this->nb_item_per_elem /
+                             this->filter.size() * this->nb_item_per_elem /
                              (n * new_size);
 
     return const_vector_iterator(
         this->array.begin_reinterpret(n, new_full_array_size),
         this->filter.begin(), new_nb_item_per_elem);
   };
 
   const_vector_iterator end_reinterpret(UInt n, UInt new_size) const {
     AKANTU_DEBUG_ASSERT(
-        n * new_size == this->getNbComponent() * this->getSize(),
+        n * new_size == this->getNbComponent() * this->size(),
         "The new values for size ("
             << new_size << ") and nb_component (" << n
             << ") are not compatible with the one of this array("
-            << this->getSize() << "," << this->getNbComponent() << ")");
+            << this->size() << "," << this->getNbComponent() << ")");
     UInt new_full_array_size =
-        this->array.getSize() * this->array.getNbComponent() / n;
+        this->array.size() * this->array.getNbComponent() / n;
     UInt new_nb_item_per_elem = this->nb_item_per_elem;
     if (new_size != 0 && n != 0)
       new_nb_item_per_elem = this->array.getNbComponent() *
-                             this->filter.getSize() * this->nb_item_per_elem /
+                             this->filter.size() * this->nb_item_per_elem /
                              (n * new_size);
 
     return const_vector_iterator(
         this->array.begin_reinterpret(n, new_full_array_size),
         this->filter.end(), new_nb_item_per_elem);
   };
 
   vector_iterator begin_reinterpret(UInt, UInt) { throw; };
 
   vector_iterator end_reinterpret(UInt, UInt) { throw; };
 
   /// return the size of the filtered array which is the filter size
-  UInt getSize() const {
-    return this->filter.getSize() * this->nb_item_per_elem;
+  UInt size() const {
+    return this->filter.size() * this->nb_item_per_elem;
   };
   /// the number of components of the filtered array
   UInt getNbComponent() const { return this->array.getNbComponent(); };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 private:
   /// reference to array of data
   const Array<T> & array;
   /// reference to the filter used to select elements
   const Array<UInt> & filter;
   /// the number of item per element
   UInt nb_item_per_elem;
 };
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMapFilter */
 /* -------------------------------------------------------------------------- */
 
 template <class T, typename SupportType = ElementType>
 class ElementTypeMapArrayFilter {
 
   /* ------------------------------------------------------------------------ */
   /* Typedefs                                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   typedef T type;
   typedef ArrayFilter<T> array_type;
   typedef typename array_type::value_type value_type;
 
   typedef typename ElementTypeMapArray<UInt, SupportType>::type_iterator
       type_iterator;
 
   // class type_iterator{
 
   // public:
 
   //    typedef typename ElementTypeMapArray<T,SupportType>::type_iterator
   //    type_it;
 
   //  public:
   //   type_iterator(){};
   //   //    type_iterator(const type_iterator & it){original_it =
   //   it.original_it;};
   //   type_iterator(const type_it & it){original_it = it;};
 
   //   inline ElementType & operator*(){throw;};
   //   inline ElementType & operator*() const{throw;};
   //   inline type_iterator & operator++(){throw;return *this;};
   //   type_iterator operator++(int){throw; return *this;};
   //   inline bool operator==(const type_iterator & other) const{throw;return
   //   false;};
   //   inline bool operator!=(const type_iterator & other) const{throw;return
   //   false;};
   //   //    type_iterator & operator=(const type_iterator & other){throw;return
   //   *this;};
 
   //   type_it original_it;
 
   // };
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
 public:
   ElementTypeMapArrayFilter(
       const ElementTypeMapArray<T, SupportType> & array,
       const ElementTypeMapArray<UInt, SupportType> & filter,
       const ElementTypeMap<UInt, SupportType> & nb_data_per_elem)
       : array(array), filter(filter), nb_data_per_elem(nb_data_per_elem) {}
 
   ElementTypeMapArrayFilter(
       const ElementTypeMapArray<T, SupportType> & array,
       const ElementTypeMapArray<UInt, SupportType> & filter)
       : array(array), filter(filter) {}
 
   ~ElementTypeMapArrayFilter() {}
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 
   inline const ArrayFilter<T>
   operator()(const SupportType & type,
              const GhostType & ghost_type = _not_ghost) const {
     if (filter.exists(type, ghost_type)) {
       if (nb_data_per_elem.exists(type, ghost_type))
         return ArrayFilter<T>(array(type, ghost_type), filter(type, ghost_type),
                               nb_data_per_elem(type, ghost_type) /
                                   array(type, ghost_type).getNbComponent());
       else
         return ArrayFilter<T>(array(type, ghost_type), filter(type, ghost_type),
                               1);
     } else {
       return ArrayFilter<T>(empty_array, empty_filter, 1);
     }
   };
 
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  GhostType ghost_type = _not_ghost,
                                  ElementKind kind = _ek_not_defined) const {
     return filter.firstType(dim, ghost_type, kind);
   };
 
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 GhostType ghost_type = _not_ghost,
                                 ElementKind kind = _ek_not_defined) const {
     return filter.lastType(dim, ghost_type, kind);
   };
 
   ElementTypeMap<UInt>
   getNbComponents(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                   ElementKind kind = _ek_not_defined) const {
     return this->array.getNbComponents(dim, ghost_type, kind);
   };
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 
   std::string getID() {
     return std::string("filtered:" + this->array().getID());
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 
 protected:
   const ElementTypeMapArray<T, SupportType> & array;
   const ElementTypeMapArray<UInt, SupportType> & filter;
   ElementTypeMap<UInt> nb_data_per_elem;
 
   /// Empty array to be able to return consistent filtered arrays
   Array<T> empty_array;
   Array<UInt> empty_filter;
 };
 
 } // akantu
 
 #endif /* __AKANTU_BY_ELEMENT_TYPE_FILTER_HH__ */
diff --git a/src/mesh/element_type_map_tmpl.hh b/src/mesh/element_type_map_tmpl.hh
index 91735c2a0..5643d21d6 100644
--- a/src/mesh/element_type_map_tmpl.hh
+++ b/src/mesh/element_type_map_tmpl.hh
@@ -1,621 +1,621 @@
 /**
  * @file   element_type_map_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 31 2011
  * @date last modification: Fri Oct 02 2015
  *
  * @brief  implementation of template functions of the ElementTypeMap and
  * ElementTypeMapArray classes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_type_map.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_type_conversion.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_TYPE_MAP_TMPL_HH__
 #define __AKANTU_ELEMENT_TYPE_MAP_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMap                                                             */
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline std::string
 ElementTypeMap<Stored, SupportType>::printType(const SupportType & type,
                                                const GhostType & ghost_type) {
   std::stringstream sstr;
   sstr << "(" << ghost_type << ":" << type << ")";
   return sstr.str();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline bool ElementTypeMap<Stored, SupportType>::exists(
     const SupportType & type, const GhostType & ghost_type) const {
   return this->getData(ghost_type).find(type) !=
          this->getData(ghost_type).end();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline const Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) const {
   typename DataMap::const_iterator it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMap::printType(type, ghost_type)
                             << " in this ElementTypeMap<"
                             << debug::demangle(typeid(Stored).name())
                             << "> class");
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) {
   return this->getData(ghost_type)[type];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const Stored & insert, const SupportType & type,
            const GhostType & ghost_type) {
   typename DataMap::iterator it = this->getData(ghost_type).find(type);
 
   if (it != this->getData(ghost_type).end()) {
     AKANTU_SILENT_EXCEPTION("Element of type "
                             << ElementTypeMap::printType(type, ghost_type)
                             << " already in this ElementTypeMap<"
                             << debug::demangle(typeid(Stored).name())
                             << "> class");
   } else {
     DataMap & data = this->getData(ghost_type);
     const std::pair<typename DataMap::iterator, bool> & res =
         data.insert(std::pair<ElementType, Stored>(type, insert));
     it = res.first;
   }
 
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::DataMap &
 ElementTypeMap<Stored, SupportType>::getData(GhostType ghost_type) {
   if (ghost_type == _not_ghost)
     return data;
   else
     return ghost_data;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline const typename ElementTypeMap<Stored, SupportType>::DataMap &
 ElementTypeMap<Stored, SupportType>::getData(GhostType ghost_type) const {
   if (ghost_type == _not_ghost)
     return data;
   else
     return ghost_data;
 }
 
 /* -------------------------------------------------------------------------- */
 /// Works only if stored is a pointer to a class with a printself method
 template <class Stored, typename SupportType>
 void ElementTypeMap<Stored, SupportType>::printself(std::ostream & stream,
                                                     int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "ElementTypeMap<" << debug::demangle(typeid(Stored).name())
          << "> [" << std::endl;
   for (auto gt : ghost_types) {
     const DataMap & data = getData(gt);
     for (auto & pair : data) {
       stream << space << space << ElementTypeMap::printType(pair.first, gt)
              << std::endl;
     }
   }
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::ElementTypeMap() {
   AKANTU_DEBUG_IN();
 
   // std::stringstream sstr;
   // if(parent_id != "") sstr << parent_id << ":";
   // sstr << id;
 
   // this->id = sstr.str();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::~ElementTypeMap() {}
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMapArray                                                        */
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline Array<T> & ElementTypeMapArray<T, SupportType>::alloc(
     UInt size, UInt nb_component, const SupportType & type,
     const GhostType & ghost_type, const T & default_value) {
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
 
   Array<T> * tmp;
 
   typename ElementTypeMapArray<T, SupportType>::DataMap::iterator it =
       this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end()) {
     std::stringstream sstr;
     sstr << this->id << ":" << type << ghost_id;
     tmp = &(Memory::alloc<T>(sstr.str(), size, nb_component, default_value));
     std::stringstream sstrg;
     sstrg << ghost_type;
     // tmp->setTag(sstrg.str());
     this->getData(ghost_type)[type] = tmp;
   } else {
     AKANTU_DEBUG_INFO(
         "The vector "
         << this->id << this->printType(type, ghost_type)
         << " already exists, it is resized instead of allocated.");
     tmp = it->second;
     it->second->resize(size);
   }
 
   return *tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void
 ElementTypeMapArray<T, SupportType>::alloc(UInt size, UInt nb_component,
                                            const SupportType & type,
                                            const T & default_value) {
   this->alloc(size, nb_component, type, _not_ghost, default_value);
   this->alloc(size, nb_component, type, _ghost, default_value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::free() {
   AKANTU_DEBUG_IN();
 
   for (auto gt : ghost_types) {
     DataMap & data = this->getData(gt);
     for (auto & pair : data) {
       dealloc(pair.second->getID());
     }
     data.clear();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::clear() {
   for (auto gt : ghost_types) {
     DataMap & data = this->getData(gt);
     for (auto & vect : data) {
       vect.second->clear();
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline const Array<T> & ElementTypeMapArray<T, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) const {
   typename ElementTypeMapArray<T, SupportType>::DataMap::const_iterator it =
       this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMapArray::printType(type, ghost_type)
                             << " in this const ElementTypeMapArray<"
                             << debug::demangle(typeid(T).name()) << "> class(\""
                             << this->id << "\")");
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline Array<T> & ElementTypeMapArray<T, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) {
   typename ElementTypeMapArray<T, SupportType>::DataMap::iterator it =
       this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMapArray::printType(type, ghost_type)
                             << " in this ElementTypeMapArray<"
                             << debug::demangle(typeid(T).name())
                             << "> class (\"" << this->id << "\")");
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void
 ElementTypeMapArray<T, SupportType>::setArray(const SupportType & type,
                                               const GhostType & ghost_type,
                                               const Array<T> & vect) {
   typename ElementTypeMapArray<T, SupportType>::DataMap::iterator it =
       this->getData(ghost_type).find(type);
 
   if (AKANTU_DEBUG_TEST(dblWarning) && it != this->getData(ghost_type).end() &&
       it->second != &vect) {
     AKANTU_DEBUG_WARNING(
         "The Array "
         << this->printType(type, ghost_type)
         << " is already registred, this call can lead to a memory leak.");
   }
 
   this->getData(ghost_type)[type] = &(const_cast<Array<T> &>(vect));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::onElementsRemoved(
     const ElementTypeMapArray<UInt> & new_numbering) {
   for (auto gt : ghost_types) {
     for (auto & type :
          new_numbering.elementTypes(_all_dimensions, gt, _ek_not_defined)) {
       SupportType support_type = convertType<ElementType, SupportType>(type);
       if (this->exists(support_type, gt)) {
         const auto & renumbering = new_numbering(type, gt);
-        if (renumbering.getSize() == 0)
+        if (renumbering.size() == 0)
           continue;
 
         auto & vect = this->operator()(support_type, gt);
         auto nb_component = vect.getNbComponent();
-        Array<T> tmp(renumbering.getSize(), nb_component);
+        Array<T> tmp(renumbering.size(), nb_component);
         UInt new_size = 0;
 
-        for (UInt i = 0; i < vect.getSize(); ++i) {
+        for (UInt i = 0; i < vect.size(); ++i) {
           UInt new_i = renumbering(i);
           if (new_i != UInt(-1)) {
             memcpy(tmp.storage() + new_i * nb_component,
                    vect.storage() + i * nb_component, nb_component * sizeof(T));
             ++new_size;
           }
         }
         tmp.resize(new_size);
         vect.copy(tmp);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 void ElementTypeMapArray<T, SupportType>::printself(std::ostream & stream,
                                                     int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "ElementTypeMapArray<" << debug::demangle(typeid(T).name())
          << "> [" << std::endl;
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
     GhostType gt = (GhostType)g;
 
     const DataMap & data = this->getData(gt);
     typename DataMap::const_iterator it;
     for (it = data.begin(); it != data.end(); ++it) {
       stream << space << space << ElementTypeMapArray::printType(it->first, gt)
              << " [" << std::endl;
       it->second->printself(stream, indent + 3);
       stream << space << space << " ]" << std::endl;
     }
   }
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /* SupportType Iterator                                                       */
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::type_iterator::type_iterator(
     DataMapIterator & list_begin, DataMapIterator & list_end, UInt dim,
     ElementKind ek)
     : list_begin(list_begin), list_end(list_end), dim(dim), kind(ek) {}
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::type_iterator::type_iterator(
     const type_iterator & it)
     : list_begin(it.list_begin), list_end(it.list_end), dim(it.dim),
       kind(it.kind) {}
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 typename ElementTypeMap<Stored, SupportType>::type_iterator &
 ElementTypeMap<Stored, SupportType>::type_iterator::
 operator=(const type_iterator & it) {
   if (this != &it) {
     list_begin = it.list_begin;
     list_end = it.list_end;
     dim = it.dim;
     kind = it.kind;
   }
   return *this;
 }
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator::reference
     ElementTypeMap<Stored, SupportType>::type_iterator::operator*() {
   return list_begin->first;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator::reference
     ElementTypeMap<Stored, SupportType>::type_iterator::operator*() const {
   return list_begin->first;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator &
     ElementTypeMap<Stored, SupportType>::type_iterator::operator++() {
   ++list_begin;
   while ((list_begin != list_end) &&
          (((dim != _all_dimensions) &&
            (dim != Mesh::getSpatialDimension(list_begin->first))) ||
           ((kind != _ek_not_defined) &&
            (kind != Mesh::getKind(list_begin->first)))))
     ++list_begin;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 typename ElementTypeMap<Stored, SupportType>::type_iterator
     ElementTypeMap<Stored, SupportType>::type_iterator::operator++(int) {
   type_iterator tmp(*this);
   operator++();
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline bool ElementTypeMap<Stored, SupportType>::type_iterator::
 operator==(const type_iterator & other) const {
   return this->list_begin == other.list_begin;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline bool ElementTypeMap<Stored, SupportType>::type_iterator::
 operator!=(const type_iterator & other) const {
   return this->list_begin != other.list_begin;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 typename ElementTypeMap<Stored, SupportType>::ElementTypesIteratorHelper
 ElementTypeMap<Stored, SupportType>::elementTypes(UInt dim,
                                                   GhostType ghost_type,
                                                   ElementKind kind) const {
   return ElementTypesIteratorHelper(*this, dim, ghost_type, kind);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator
 ElementTypeMap<Stored, SupportType>::firstType(UInt dim, GhostType ghost_type,
                                                ElementKind kind) const {
   typename DataMap::const_iterator b, e;
   b = getData(ghost_type).begin();
   e = getData(ghost_type).end();
 
   // loop until the first valid type
   while ((b != e) &&
          (((dim != _all_dimensions) &&
            (dim != Mesh::getSpatialDimension(b->first))) ||
           ((kind != _ek_not_defined) && (kind != Mesh::getKind(b->first)))))
     ++b;
 
   return typename ElementTypeMap<Stored, SupportType>::type_iterator(b, e, dim,
                                                                      kind);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator
 ElementTypeMap<Stored, SupportType>::lastType(UInt dim, GhostType ghost_type,
                                               ElementKind kind) const {
   typename DataMap::const_iterator e;
   e = getData(ghost_type).end();
   return typename ElementTypeMap<Stored, SupportType>::type_iterator(e, e, dim,
                                                                      kind);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 template <class Stored, typename SupportType>
 inline std::ostream &
 operator<<(std::ostream & stream,
            const ElementTypeMap<Stored, SupportType> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 class ElementTypeMapArrayInializer {
 public:
   ElementTypeMapArrayInializer(UInt spatial_dimension = _all_dimensions,
                                UInt nb_component = 1,
                                const GhostType & ghost_type = _not_ghost,
                                const ElementKind & element_kind = _ek_regular)
       : spatial_dimension(spatial_dimension), nb_component(nb_component),
         ghost_type(ghost_type), element_kind(element_kind) {}
 
   const GhostType & ghostType() const { return ghost_type; }
 
 protected:
   UInt spatial_dimension;
   UInt nb_component;
   GhostType ghost_type;
   ElementKind element_kind;
 };
 
 /* -------------------------------------------------------------------------- */
 class MeshElementTypeMapArrayInializer : public ElementTypeMapArrayInializer {
 public:
   MeshElementTypeMapArrayInializer(
       const Mesh & mesh, UInt nb_component = 1,
       UInt spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_regular,
       bool with_nb_element = false, bool with_nb_nodes_per_element = false)
       : ElementTypeMapArrayInializer(spatial_dimension, nb_component,
                                      ghost_type, element_kind),
         mesh(mesh), with_nb_element(with_nb_element),
         with_nb_nodes_per_element(with_nb_nodes_per_element) {}
 
   decltype(auto) elementTypes() const {
     return mesh.elementTypes(this->spatial_dimension, this->ghost_type,
                              this->element_kind);
   }
 
   virtual UInt size(const ElementType & type) const {
     if (with_nb_element)
       return mesh.getNbElement(type, this->ghost_type);
 
     return 0;
   }
 
   UInt nbComponent(const ElementType & type) const {
     if (with_nb_nodes_per_element)
       return (this->nb_component * mesh.getNbNodesPerElement(type));
 
     return this->nb_component;
   }
 
 protected:
   const Mesh & mesh;
   bool with_nb_element;
   bool with_nb_nodes_per_element;
 };
 
 /* -------------------------------------------------------------------------- */
 class FEEngineElementTypeMapArrayInializer
     : public MeshElementTypeMapArrayInializer {
 public:
   FEEngineElementTypeMapArrayInializer(
       const FEEngine & fe_engine, UInt nb_component = 1,
       UInt spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_regular);
 
   UInt size(const ElementType & type) const override;
 
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<Real, ElementType>::ElementTypesIteratorHelper;
 
   ElementTypesIteratorHelper elementTypes() const;
 
 protected:
   const FEEngine & fe_engine;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 template <class Func>
 void ElementTypeMapArray<T, SupportType>::initialize(const Func & f,
                                                      const T & default_value) {
   for (auto & type : f.elementTypes()) {
     if (not this->exists(type, f.ghostType()))
       this->alloc(f.size(type), f.nbComponent(type), type, f.ghostType(),
                   default_value);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 template <typename... pack>
 void ElementTypeMapArray<T, SupportType>::initialize(const Mesh & mesh,
                                                      pack &&... _pack) {
   GhostType requested_ghost_type = OPTIONAL_NAMED_ARG(ghost_type, _casper);
   bool all_ghost_types = requested_ghost_type == _casper;
 
   for (auto ghost_type : ghost_types) {
     if ((not(ghost_type == requested_ghost_type)) and (not all_ghost_types))
       continue;
 
     this->initialize(
         MeshElementTypeMapArrayInializer(
             mesh, OPTIONAL_NAMED_ARG(nb_component, 1),
             OPTIONAL_NAMED_ARG(spatial_dimension, mesh.getSpatialDimension()),
             ghost_type, OPTIONAL_NAMED_ARG(element_kind, _ek_regular),
             OPTIONAL_NAMED_ARG(with_nb_element, false),
             OPTIONAL_NAMED_ARG(with_nb_nodes_per_element, false)),
         OPTIONAL_NAMED_ARG(default_value, T()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 template <typename... pack>
 void ElementTypeMapArray<T, SupportType>::initialize(const FEEngine & fe_engine,
                                                      pack &&... _pack) {
   bool all_ghost_types = OPTIONAL_NAMED_ARG(all_ghost_types, true);
   GhostType requested_ghost_type = OPTIONAL_NAMED_ARG(ghost_type, _not_ghost);
 
   for (auto ghost_type : ghost_types) {
     if ((not(ghost_type == requested_ghost_type)) and (not all_ghost_types))
       continue;
 
     this->initialize(FEEngineElementTypeMapArrayInializer(
                          fe_engine, OPTIONAL_NAMED_ARG(nb_component, 1),
                          OPTIONAL_NAMED_ARG(spatial_dimension, UInt(-2)),
                          ghost_type,
                          OPTIONAL_NAMED_ARG(element_kind, _ek_regular)),
                      OPTIONAL_NAMED_ARG(default_value, T()));
   }
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_TYPE_MAP_TMPL_HH__ */
diff --git a/src/mesh/group_manager.cc b/src/mesh/group_manager.cc
index f9517336a..b0164f0a8 100644
--- a/src/mesh/group_manager.cc
+++ b/src/mesh/group_manager.cc
@@ -1,1041 +1,1041 @@
 /**
  * @file   group_manager.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@gmail.com>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Mon Aug 17 2015
  *
  * @brief  Stores information about ElementGroup and NodeGroup
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "group_manager.hh"
 #include "aka_csr.hh"
 #include "data_accessor.hh"
 #include "element_group.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iterator>
 #include <list>
 #include <numeric>
 #include <queue>
 #include <sstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 GroupManager::GroupManager(const Mesh & mesh, const ID & id,
                            const MemoryID & mem_id)
     : id(id), memory_id(mem_id), mesh(mesh) {
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 GroupManager::~GroupManager() {
   auto eit = element_groups.begin();
   auto eend = element_groups.end();
   for (; eit != eend; ++eit)
     delete (eit->second);
 
   auto nit = node_groups.begin();
   auto nend = node_groups.end();
   for (; nit != nend; ++nit)
     delete (nit->second);
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup & GroupManager::createNodeGroup(const std::string & group_name,
                                           bool replace_group) {
   AKANTU_DEBUG_IN();
 
   auto it = node_groups.find(group_name);
 
   if (it != node_groups.end()) {
     if (replace_group) {
       it->second->empty();
       AKANTU_DEBUG_OUT();
       return *(it->second);
     } else
       AKANTU_EXCEPTION(
           "Trying to create a node group that already exists:" << group_name);
   }
 
   std::stringstream sstr;
   sstr << this->id << ":" << group_name << "_node_group";
 
   NodeGroup * node_group =
       new NodeGroup(group_name, mesh, sstr.str(), memory_id);
 
   node_groups[group_name] = node_group;
 
   AKANTU_DEBUG_OUT();
 
   return *node_group;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 NodeGroup &
 GroupManager::createFilteredNodeGroup(const std::string & group_name,
                                       const NodeGroup & source_node_group,
                                       T & filter) {
   AKANTU_DEBUG_IN();
 
   NodeGroup & node_group = this->createNodeGroup(group_name);
   node_group.append(source_node_group);
   if (T::type == FilterFunctor::_node_filter_functor) {
     node_group.applyNodeFilter(filter);
   } else {
     AKANTU_DEBUG_ERROR("ElementFilter cannot be applied to NodeGroup yet."
                        << " Needs to be implemented.");
   }
 
   AKANTU_DEBUG_OUT();
   return node_group;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyNodeGroup(const std::string & group_name) {
   AKANTU_DEBUG_IN();
 
   NodeGroups::iterator nit = node_groups.find(group_name);
   NodeGroups::iterator nend = node_groups.end();
   if (nit != nend) {
     delete (nit->second);
     node_groups.erase(nit);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::createElementGroup(const std::string & group_name,
                                                 UInt dimension,
                                                 bool replace_group) {
   AKANTU_DEBUG_IN();
 
   NodeGroup & new_node_group =
       createNodeGroup(group_name + "_nodes", replace_group);
 
   auto it = element_groups.find(group_name);
 
   if (it != element_groups.end()) {
     if (replace_group) {
       it->second->empty();
       AKANTU_DEBUG_OUT();
       return *(it->second);
     } else
       AKANTU_EXCEPTION("Trying to create a element group that already exists:"
                        << group_name);
   }
 
   std::stringstream sstr;
   sstr << this->id << ":" << group_name << "_element_group";
 
   ElementGroup * element_group = new ElementGroup(
       group_name, mesh, new_node_group, dimension, sstr.str(), memory_id);
 
   std::stringstream sstr_nodes;
   sstr_nodes << group_name << "_nodes";
 
   node_groups[sstr_nodes.str()] = &new_node_group;
   element_groups[group_name] = element_group;
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyElementGroup(const std::string & group_name,
                                        bool destroy_node_group) {
   AKANTU_DEBUG_IN();
 
   auto eit = element_groups.find(group_name);
   auto eend = element_groups.end();
   if (eit != eend) {
     if (destroy_node_group)
       destroyNodeGroup(eit->second->getNodeGroup().getName());
     delete (eit->second);
     element_groups.erase(eit);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::destroyAllElementGroups(bool destroy_node_groups) {
   AKANTU_DEBUG_IN();
 
   auto eit = element_groups.begin();
   auto eend = element_groups.end();
   for (; eit != eend; ++eit) {
     if (destroy_node_groups)
       destroyNodeGroup(eit->second->getNodeGroup().getName());
     delete (eit->second);
   }
   element_groups.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::createElementGroup(const std::string & group_name,
                                                 UInt dimension,
                                                 NodeGroup & node_group) {
   AKANTU_DEBUG_IN();
 
   if (element_groups.find(group_name) != element_groups.end())
     AKANTU_EXCEPTION(
         "Trying to create a element group that already exists:" << group_name);
 
   ElementGroup * element_group =
       new ElementGroup(group_name, mesh, node_group, dimension,
                        id + ":" + group_name + "_element_group", memory_id);
 
   element_groups[group_name] = element_group;
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ElementGroup & GroupManager::createFilteredElementGroup(
     const std::string & group_name, UInt dimension,
     const NodeGroup & node_group, T & filter) {
   AKANTU_DEBUG_IN();
 
   ElementGroup * element_group = NULL;
 
   if (T::type == FilterFunctor::_node_filter_functor) {
     NodeGroup & filtered_node_group = this->createFilteredNodeGroup(
         group_name + "_nodes", node_group, filter);
     element_group =
         &(this->createElementGroup(group_name, dimension, filtered_node_group));
   } else if (T::type == FilterFunctor::_element_filter_functor) {
     AKANTU_DEBUG_ERROR(
         "Cannot handle an ElementFilter yet. Needs to be implemented.");
   }
 
   AKANTU_DEBUG_OUT();
 
   return *element_group;
 }
 
 /* -------------------------------------------------------------------------- */
 class ClusterSynchronizer : public DataAccessor<Element> {
   using DistantIDs = std::set<std::pair<UInt, UInt>>;
 
 public:
   ClusterSynchronizer(GroupManager & group_manager, UInt element_dimension,
                       std::string cluster_name_prefix,
                       ElementTypeMapArray<UInt> & element_to_fragment,
                       const ElementSynchronizer & element_synchronizer,
                       UInt nb_cluster)
       : group_manager(group_manager), element_dimension(element_dimension),
         cluster_name_prefix(cluster_name_prefix),
         element_to_fragment(element_to_fragment),
         element_synchronizer(element_synchronizer), nb_cluster(nb_cluster) {}
 
   UInt synchronize() {
     StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
     UInt rank = comm.whoAmI();
     UInt nb_proc = comm.getNbProc();
 
     /// find starting index to renumber local clusters
     Array<UInt> nb_cluster_per_proc(nb_proc);
     nb_cluster_per_proc(rank) = nb_cluster;
     comm.allGather(nb_cluster_per_proc);
 
     starting_index = std::accumulate(nb_cluster_per_proc.begin(),
                                      nb_cluster_per_proc.begin() + rank, 0);
 
     UInt global_nb_fragment =
         std::accumulate(nb_cluster_per_proc.begin() + rank,
                         nb_cluster_per_proc.end(), starting_index);
 
     /// create the local to distant cluster pairs with neighbors
     element_synchronizer.synchronizeOnce(*this, _gst_gm_clusters);
 
     /// count total number of pairs
     Array<int> nb_pairs(nb_proc); // This is potentially a bug for more than
     // 2**31 pairs, but due to a all gatherv after
     // it must be int to match MPI interfaces
     nb_pairs(rank) = distant_ids.size();
     comm.allGather(nb_pairs);
 
     UInt total_nb_pairs = std::accumulate(nb_pairs.begin(), nb_pairs.end(), 0);
 
     /// generate pairs global array
     UInt local_pair_index =
         std::accumulate(nb_pairs.storage(), nb_pairs.storage() + rank, 0);
 
     Array<UInt> total_pairs(total_nb_pairs, 2);
 
     for (auto & ids : distant_ids) {
       total_pairs(local_pair_index, 0) = ids.first;
       total_pairs(local_pair_index, 1) = ids.second;
       ++local_pair_index;
     }
 
     /// communicate pairs to all processors
     nb_pairs *= 2;
     comm.allGatherV(total_pairs, nb_pairs);
 
     /// renumber clusters
 
     /// generate fragment list
     std::vector<std::set<UInt>> global_clusters;
     UInt total_nb_cluster = 0;
 
     Array<bool> is_fragment_in_cluster(global_nb_fragment, 1, false);
     std::queue<UInt> fragment_check_list;
 
-    while (total_pairs.getSize() != 0) {
+    while (total_pairs.size() != 0) {
       /// create a new cluster
       ++total_nb_cluster;
       global_clusters.resize(total_nb_cluster);
       std::set<UInt> & current_cluster = global_clusters[total_nb_cluster - 1];
 
       UInt first_fragment = total_pairs(0, 0);
       UInt second_fragment = total_pairs(0, 1);
       total_pairs.erase(0);
 
       fragment_check_list.push(first_fragment);
       fragment_check_list.push(second_fragment);
 
       while (!fragment_check_list.empty()) {
         UInt current_fragment = fragment_check_list.front();
 
         UInt * total_pairs_end =
-            total_pairs.storage() + total_pairs.getSize() * 2;
+            total_pairs.storage() + total_pairs.size() * 2;
 
         UInt * fragment_found =
             std::find(total_pairs.storage(), total_pairs_end, current_fragment);
 
         if (fragment_found != total_pairs_end) {
           UInt position = fragment_found - total_pairs.storage();
           UInt pair = position / 2;
           UInt other_index = (position + 1) % 2;
           fragment_check_list.push(total_pairs(pair, other_index));
           total_pairs.erase(pair);
         } else {
           fragment_check_list.pop();
           current_cluster.insert(current_fragment);
           is_fragment_in_cluster(current_fragment) = true;
         }
       }
     }
 
     /// add to FragmentToCluster all local fragments
     for (UInt c = 0; c < global_nb_fragment; ++c) {
       if (!is_fragment_in_cluster(c)) {
         ++total_nb_cluster;
         global_clusters.resize(total_nb_cluster);
         std::set<UInt> & current_cluster =
             global_clusters[total_nb_cluster - 1];
 
         current_cluster.insert(c);
       }
     }
 
     /// reorganize element groups to match global clusters
     for (UInt c = 0; c < global_clusters.size(); ++c) {
 
       /// create new element group corresponding to current cluster
       std::stringstream sstr;
       sstr << cluster_name_prefix << "_" << c;
       ElementGroup & cluster =
           group_manager.createElementGroup(sstr.str(), element_dimension, true);
 
       std::set<UInt>::iterator it = global_clusters[c].begin();
       std::set<UInt>::iterator end = global_clusters[c].end();
 
       /// append to current element group all fragments that belong to
       /// the same cluster if they exist
       for (; it != end; ++it) {
         Int local_index = *it - starting_index;
 
         if (local_index < 0 || local_index >= Int(nb_cluster))
           continue;
 
         std::stringstream tmp_sstr;
         tmp_sstr << "tmp_" << cluster_name_prefix << "_" << local_index;
         auto eg_it = group_manager.element_group_find(tmp_sstr.str());
 
         AKANTU_DEBUG_ASSERT(eg_it != group_manager.element_group_end(),
                             "Temporary fragment \"" << tmp_sstr.str()
                                                     << "\" not found");
 
         cluster.append(*(eg_it->second));
         group_manager.destroyElementGroup(tmp_sstr.str(), true);
       }
     }
 
     return total_nb_cluster;
   }
 
 private:
   /// functions for parallel communications
   inline UInt getNbData(const Array<Element> & elements,
                         const SynchronizationTag & tag) const {
     if (tag == _gst_gm_clusters)
-      return elements.getSize() * sizeof(UInt);
+      return elements.size() * sizeof(UInt);
 
     return 0;
   }
 
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const {
     if (tag != _gst_gm_clusters)
       return;
 
     Array<Element>::const_iterator<> el_it = elements.begin();
     Array<Element>::const_iterator<> el_end = elements.end();
 
     for (; el_it != el_end; ++el_it) {
 
       const Element & el = *el_it;
 
       /// for each element pack its global cluster index
       buffer << element_to_fragment(el.type, el.ghost_type)(el.element) +
                     starting_index;
     }
   }
 
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag) {
     if (tag != _gst_gm_clusters)
       return;
 
     Array<Element>::const_iterator<> el_it = elements.begin();
     Array<Element>::const_iterator<> el_end = elements.end();
 
     for (; el_it != el_end; ++el_it) {
       UInt distant_cluster;
 
       buffer >> distant_cluster;
 
       const Element & el = *el_it;
       UInt local_cluster =
           element_to_fragment(el.type, el.ghost_type)(el.element) +
           starting_index;
 
       distant_ids.insert(std::make_pair(local_cluster, distant_cluster));
     }
   }
 
 private:
   GroupManager & group_manager;
   UInt element_dimension;
   std::string cluster_name_prefix;
   ElementTypeMapArray<UInt> & element_to_fragment;
   const ElementSynchronizer & element_synchronizer;
 
   UInt nb_cluster;
   DistantIDs distant_ids;
 
   UInt starting_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /// \todo this function doesn't work in 1D
 UInt GroupManager::createBoundaryGroupFromGeometry() {
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   return createClusters(spatial_dimension - 1, "boundary");
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::createClusters(
     UInt element_dimension, Mesh & mesh_facets, std::string cluster_name_prefix,
     const GroupManager::ClusteringFilter & filter) {
   return createClusters(element_dimension, cluster_name_prefix, filter, mesh_facets);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::createClusters(
     UInt element_dimension, std::string cluster_name_prefix,
     const GroupManager::ClusteringFilter & filter) {
   std::unique_ptr<Mesh> mesh_facets;
   if (!mesh_facets && element_dimension > 0) {
     MeshAccessor mesh_accessor(const_cast<Mesh &>(mesh));
     mesh_facets = std::make_unique<Mesh>(mesh.getSpatialDimension(),
                                          mesh_accessor.getNodesSharedPtr(),
                                          "mesh_facets_for_clusters");
 
     mesh_facets->defineMeshParent(mesh);
 
     MeshUtils::buildAllFacets(mesh, *mesh_facets, element_dimension,
                               element_dimension - 1);
   }
 
   return createClusters(element_dimension, cluster_name_prefix, filter, *mesh_facets);
 }
 
 /* -------------------------------------------------------------------------- */
 //// \todo if needed element list construction can be optimized by
 //// templating the filter class
 UInt GroupManager::createClusters(UInt element_dimension,
                                   std::string cluster_name_prefix,
                                   const GroupManager::ClusteringFilter & filter,
                                   Mesh & mesh_facets) {
   AKANTU_DEBUG_IN();
 
   UInt nb_proc = StaticCommunicator::getStaticCommunicator().getNbProc();
   std::string tmp_cluster_name_prefix = cluster_name_prefix;
 
   ElementTypeMapArray<UInt> * element_to_fragment = nullptr;
 
   if (nb_proc > 1 && mesh.isDistributed()) {
     element_to_fragment =
         new ElementTypeMapArray<UInt>("element_to_fragment", id, memory_id);
 
     element_to_fragment->initialize(
         mesh, _nb_component = 1, _spatial_dimension = element_dimension,
         _element_kind = _ek_not_defined, _with_nb_element = true);
     // mesh.initElementTypeMapArray(*element_to_fragment, 1, element_dimension,
     //                              false, _ek_not_defined, true);
     tmp_cluster_name_prefix = "tmp_" + tmp_cluster_name_prefix;
   }
 
   ElementTypeMapArray<bool> seen_elements("seen_elements", id, memory_id);
   seen_elements.initialize(mesh, _spatial_dimension = element_dimension,
                            _element_kind = _ek_not_defined,
                            _with_nb_element = true);
   // mesh.initElementTypeMapArray(seen_elements, 1, element_dimension, false,
   //                              _ek_not_defined, true);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
     Element el;
     el.ghost_type = ghost_type;
 
     Mesh::type_iterator type_it =
         mesh.firstType(element_dimension, ghost_type, _ek_not_defined);
     Mesh::type_iterator type_end =
         mesh.lastType(element_dimension, ghost_type, _ek_not_defined);
 
     for (; type_it != type_end; ++type_it) {
       el.type = *type_it;
       el.kind = Mesh::getKind(*type_it);
       UInt nb_element = mesh.getNbElement(*type_it, ghost_type);
       Array<bool> & seen_elements_array = seen_elements(el.type, ghost_type);
 
       for (UInt e = 0; e < nb_element; ++e) {
         el.element = e;
         if (!filter(el))
           seen_elements_array(e) = true;
       }
     }
   }
 
   Array<bool> checked_node(mesh.getNbNodes(), 1, false);
 
   UInt nb_cluster = 0;
 
   /// keep looping until all elements are seen
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
     Element uns_el;
     uns_el.ghost_type = ghost_type;
 
     Mesh::type_iterator type_it =
         mesh.firstType(element_dimension, ghost_type, _ek_not_defined);
     Mesh::type_iterator type_end =
         mesh.lastType(element_dimension, ghost_type, _ek_not_defined);
 
     for (; type_it != type_end; ++type_it) {
       uns_el.type = *type_it;
       Array<bool> & seen_elements_vec =
           seen_elements(uns_el.type, uns_el.ghost_type);
 
-      for (UInt e = 0; e < seen_elements_vec.getSize(); ++e) {
+      for (UInt e = 0; e < seen_elements_vec.size(); ++e) {
         // skip elements that have been already seen
         if (seen_elements_vec(e) == true)
           continue;
 
         // set current element
         uns_el.element = e;
         seen_elements_vec(e) = true;
 
         /// create a new cluster
         std::stringstream sstr;
         sstr << tmp_cluster_name_prefix << "_" << nb_cluster;
         ElementGroup & cluster =
             createElementGroup(sstr.str(), element_dimension, true);
         ++nb_cluster;
 
         // point element are cluster by themself
         if (element_dimension == 0) {
           cluster.add(uns_el);
 
           UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(uns_el.type);
           Vector<UInt> connect =
               mesh.getConnectivity(uns_el.type, uns_el.ghost_type)
                   .begin(nb_nodes_per_element)[uns_el.element];
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             /// add element's nodes to the cluster
             UInt node = connect[n];
             if (!checked_node(node)) {
               cluster.addNode(node);
               checked_node(node) = true;
             }
           }
 
           continue;
         }
 
         std::queue<Element> element_to_add;
         element_to_add.push(uns_el);
 
         /// keep looping until current cluster is complete (no more
         /// connected elements)
         while (!element_to_add.empty()) {
 
           /// take first element and erase it in the queue
           Element el = element_to_add.front();
           element_to_add.pop();
 
           /// if parallel, store cluster index per element
           if (nb_proc > 1 && mesh.isDistributed())
             (*element_to_fragment)(el.type, el.ghost_type)(el.element) =
                 nb_cluster - 1;
 
           /// add current element to the cluster
           cluster.add(el);
 
           const Array<Element> & element_to_facet =
               mesh_facets.getSubelementToElement(el.type, el.ghost_type);
 
           UInt nb_facet_per_element = element_to_facet.getNbComponent();
 
           for (UInt f = 0; f < nb_facet_per_element; ++f) {
             const Element & facet = element_to_facet(el.element, f);
 
             if (facet == ElementNull)
               continue;
 
             const std::vector<Element> & connected_elements =
                 mesh_facets.getElementToSubelement(
                     facet.type, facet.ghost_type)(facet.element);
 
             for (UInt elem = 0; elem < connected_elements.size(); ++elem) {
               const Element & check_el = connected_elements[elem];
 
               // check if this element has to be skipped
               if (check_el == ElementNull || check_el == el)
                 continue;
 
               Array<bool> & seen_elements_vec_current =
                   seen_elements(check_el.type, check_el.ghost_type);
 
               if (seen_elements_vec_current(check_el.element) == false) {
                 seen_elements_vec_current(check_el.element) = true;
                 element_to_add.push(check_el);
               }
             }
           }
 
           UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(el.type);
           Vector<UInt> connect = mesh.getConnectivity(el.type, el.ghost_type)
                                      .begin(nb_nodes_per_element)[el.element];
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             /// add element's nodes to the cluster
             UInt node = connect[n];
             if (!checked_node(node)) {
               cluster.addNode(node, false);
               checked_node(node) = true;
             }
           }
         }
       }
     }
   }
 
   if (nb_proc > 1 && mesh.isDistributed()) {
     ClusterSynchronizer cluster_synchronizer(
         *this, element_dimension, cluster_name_prefix, *element_to_fragment,
         this->mesh.getElementSynchronizer(), nb_cluster);
     nb_cluster = cluster_synchronizer.synchronize();
     delete element_to_fragment;
   }
 
   if (mesh.isDistributed())
     this->synchronizeGroupNames();
 
   AKANTU_DEBUG_OUT();
   return nb_cluster;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void GroupManager::createGroupsFromMeshData(const std::string & dataset_name) {
   std::set<std::string> group_names;
   const ElementTypeMapArray<T> & datas = mesh.getData<T>(dataset_name);
   typedef typename ElementTypeMapArray<T>::type_iterator type_iterator;
 
   std::map<std::string, UInt> group_dim;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     type_iterator type_it = datas.firstType(_all_dimensions, *gt);
     type_iterator type_end = datas.lastType(_all_dimensions, *gt);
     for (; type_it != type_end; ++type_it) {
       const Array<T> & dataset = datas(*type_it, *gt);
       UInt nb_element = mesh.getNbElement(*type_it, *gt);
-      AKANTU_DEBUG_ASSERT(dataset.getSize() == nb_element,
+      AKANTU_DEBUG_ASSERT(dataset.size() == nb_element,
                           "Not the same number of elements ("
                               << *type_it << ":" << *gt
                               << ") in the map from MeshData ("
-                              << dataset.getSize() << ") " << dataset_name
+                              << dataset.size() << ") " << dataset_name
                               << " and in the mesh (" << nb_element << ")!");
       for (UInt e(0); e < nb_element; ++e) {
         std::stringstream sstr;
         sstr << dataset(e);
         std::string gname = sstr.str();
         group_names.insert(gname);
 
         std::map<std::string, UInt>::iterator it = group_dim.find(gname);
         if (it == group_dim.end()) {
           group_dim[gname] = mesh.getSpatialDimension(*type_it);
         } else {
           it->second = std::max(it->second, mesh.getSpatialDimension(*type_it));
         }
       }
     }
   }
 
   std::set<std::string>::iterator git = group_names.begin();
   std::set<std::string>::iterator gend = group_names.end();
   for (; git != gend; ++git)
     createElementGroup(*git, group_dim[*git]);
 
   if (mesh.isDistributed())
     this->synchronizeGroupNames();
 
   Element el;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     el.ghost_type = *gt;
 
     type_iterator type_it = datas.firstType(_all_dimensions, *gt);
     type_iterator type_end = datas.lastType(_all_dimensions, *gt);
     for (; type_it != type_end; ++type_it) {
       el.type = *type_it;
 
       const Array<T> & dataset = datas(*type_it, *gt);
       UInt nb_element = mesh.getNbElement(*type_it, *gt);
-      AKANTU_DEBUG_ASSERT(dataset.getSize() == nb_element,
+      AKANTU_DEBUG_ASSERT(dataset.size() == nb_element,
                           "Not the same number of elements in the map from "
                           "MeshData and in the mesh!");
 
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(el.type);
 
       Array<UInt>::const_iterator<Vector<UInt>> cit =
           mesh.getConnectivity(*type_it, *gt).begin(nb_nodes_per_element);
 
       for (UInt e(0); e < nb_element; ++e, ++cit) {
         el.element = e;
         std::stringstream sstr;
         sstr << dataset(e);
         ElementGroup & group = getElementGroup(sstr.str());
         group.add(el, false, false);
 
         const Vector<UInt> & connect = *cit;
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           UInt node = connect[n];
           group.addNode(node, false);
         }
       }
     }
   }
 
   git = group_names.begin();
   for (; git != gend; ++git) {
     getElementGroup(*git).optimize();
   }
 }
 
 template void GroupManager::createGroupsFromMeshData<std::string>(
     const std::string & dataset_name);
 template void
 GroupManager::createGroupsFromMeshData<UInt>(const std::string & dataset_name);
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::createElementGroupFromNodeGroup(
     const std::string & name, const std::string & node_group_name,
     UInt dimension) {
   NodeGroup & node_group = getNodeGroup(node_group_name);
   ElementGroup & group = createElementGroup(name, dimension, node_group);
 
   group.fillFromNodeGroup();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "GroupManager [" << std::endl;
 
   std::set<std::string> node_group_seen;
   for (const_element_group_iterator it(element_group_begin());
        it != element_group_end(); ++it) {
     it->second->printself(stream, indent + 1);
     node_group_seen.insert(it->second->getNodeGroup().getName());
   }
 
   for (const_node_group_iterator it(node_group_begin()); it != node_group_end();
        ++it) {
     if (node_group_seen.find(it->second->getName()) == node_group_seen.end())
       it->second->printself(stream, indent + 1);
   }
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 UInt GroupManager::getNbElementGroups(UInt dimension) const {
   if (dimension == _all_dimensions)
     return element_groups.size();
 
   ElementGroups::const_iterator it = element_groups.begin();
   ElementGroups::const_iterator end = element_groups.end();
   UInt count = 0;
   for (; it != end; ++it)
     count += (it->second->getDimension() == dimension);
   return count;
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::checkAndAddGroups(CommunicationBuffer & buffer) {
   AKANTU_DEBUG_IN();
 
   UInt nb_node_group;
   buffer >> nb_node_group;
   AKANTU_DEBUG_INFO("Received " << nb_node_group << " node group names");
 
   for (UInt ng = 0; ng < nb_node_group; ++ng) {
     std::string node_group_name;
     buffer >> node_group_name;
 
     if (node_groups.find(node_group_name) == node_groups.end()) {
       this->createNodeGroup(node_group_name);
     }
 
     AKANTU_DEBUG_INFO("Received node goup name: " << node_group_name);
   }
 
   UInt nb_element_group;
   buffer >> nb_element_group;
   AKANTU_DEBUG_INFO("Received " << nb_element_group << " element group names");
   for (UInt eg = 0; eg < nb_element_group; ++eg) {
     std::string element_group_name;
     buffer >> element_group_name;
     std::string node_group_name;
     buffer >> node_group_name;
     UInt dim;
     buffer >> dim;
 
     AKANTU_DEBUG_INFO("Received element group name: "
                       << element_group_name << " corresponding to a "
                       << Int(dim) << "D group with node group "
                       << node_group_name);
 
     NodeGroup & node_group = *node_groups[node_group_name];
 
     if (element_groups.find(element_group_name) == element_groups.end()) {
       this->createElementGroup(element_group_name, dim, node_group);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::fillBufferWithGroupNames(
     DynamicCommunicationBuffer & comm_buffer) const {
   AKANTU_DEBUG_IN();
 
   // packing node group names;
   UInt nb_groups = this->node_groups.size();
   comm_buffer << nb_groups;
   AKANTU_DEBUG_INFO("Sending " << nb_groups << " node group names");
 
   NodeGroups::const_iterator nnames_it = node_groups.begin();
   NodeGroups::const_iterator nnames_end = node_groups.end();
   for (; nnames_it != nnames_end; ++nnames_it) {
     std::string node_group_name = nnames_it->first;
     comm_buffer << node_group_name;
     AKANTU_DEBUG_INFO("Sending node goupe name: " << node_group_name);
   }
 
   // packing element group names with there associated node group name
   nb_groups = this->element_groups.size();
   comm_buffer << nb_groups;
   AKANTU_DEBUG_INFO("Sending " << nb_groups << " element group names");
   ElementGroups::const_iterator gnames_it = this->element_groups.begin();
   ElementGroups::const_iterator gnames_end = this->element_groups.end();
   for (; gnames_it != gnames_end; ++gnames_it) {
     ElementGroup & element_group = *(gnames_it->second);
     std::string element_group_name = gnames_it->first;
     std::string node_group_name = element_group.getNodeGroup().getName();
     UInt dim = element_group.getDimension();
 
     comm_buffer << element_group_name;
     comm_buffer << node_group_name;
     comm_buffer << dim;
 
     AKANTU_DEBUG_INFO("Sending element group name: "
                       << element_group_name << " corresponding to a "
                       << Int(dim) << "D group with the node group "
                       << node_group_name);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GroupManager::synchronizeGroupNames() {
   AKANTU_DEBUG_IN();
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int nb_proc = comm.getNbProc();
   Int my_rank = comm.whoAmI();
 
   if (nb_proc == 1)
     return;
 
   if (my_rank == 0) {
     for (Int p = 1; p < nb_proc; ++p) {
       CommunicationStatus status;
       comm.probe<char>(p, p, status);
-      AKANTU_DEBUG_INFO("Got " << printMemorySize<char>(status.getSize())
+      AKANTU_DEBUG_INFO("Got " << printMemorySize<char>(status.size())
                                << " from proc " << p);
 
-      CommunicationBuffer recv_buffer(status.getSize());
+      CommunicationBuffer recv_buffer(status.size());
       comm.receive(recv_buffer, p, p);
 
       this->checkAndAddGroups(recv_buffer);
     }
 
     DynamicCommunicationBuffer comm_buffer;
     this->fillBufferWithGroupNames(comm_buffer);
 
-    UInt buffer_size = comm_buffer.getSize();
+    UInt buffer_size = comm_buffer.size();
 
     comm.broadcast(buffer_size, 0);
 
     AKANTU_DEBUG_INFO("Initiating broadcast with "
-                      << printMemorySize<char>(comm_buffer.getSize()));
+                      << printMemorySize<char>(comm_buffer.size()));
     comm.broadcast(comm_buffer, 0);
 
   } else {
     DynamicCommunicationBuffer comm_buffer;
     this->fillBufferWithGroupNames(comm_buffer);
 
-    AKANTU_DEBUG_INFO("Sending " << printMemorySize<char>(comm_buffer.getSize())
+    AKANTU_DEBUG_INFO("Sending " << printMemorySize<char>(comm_buffer.size())
                                  << " to proc " << 0);
     comm.send(comm_buffer, 0, my_rank);
 
     UInt buffer_size = 0;
     comm.broadcast(buffer_size, 0);
 
     AKANTU_DEBUG_INFO("Receiving broadcast with "
-                      << printMemorySize<char>(comm_buffer.getSize()));
+                      << printMemorySize<char>(comm_buffer.size()));
     CommunicationBuffer recv_buffer(buffer_size);
     comm.broadcast(recv_buffer, 0);
 
     this->checkAndAddGroups(recv_buffer);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 const ElementGroup &
 GroupManager::getElementGroup(const std::string & name) const {
   const_element_group_iterator it = element_group_find(name);
   if (it == element_group_end()) {
     AKANTU_EXCEPTION("There are no element groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup & GroupManager::getElementGroup(const std::string & name) {
   element_group_iterator it = element_group_find(name);
   if (it == element_group_end()) {
     AKANTU_EXCEPTION("There are no element groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 const NodeGroup & GroupManager::getNodeGroup(const std::string & name) const {
   const_node_group_iterator it = node_group_find(name);
   if (it == node_group_end()) {
     AKANTU_EXCEPTION("There are no node groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup & GroupManager::getNodeGroup(const std::string & name) {
   node_group_iterator it = node_group_find(name);
   if (it == node_group_end()) {
     AKANTU_EXCEPTION("There are no node groups named "
                      << name << " associated to the group manager: " << id);
   }
 
   return *(it->second);
 }
 
 } // namespace akantu
diff --git a/src/mesh/mesh.cc b/src/mesh/mesh.cc
index f76ecd7fc..2f6c5d2fc 100644
--- a/src/mesh/mesh.cc
+++ b/src/mesh/mesh.cc
@@ -1,442 +1,445 @@
 /**
  * @file   mesh.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  class handling meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <sstream>
 
 #include "aka_config.hh"
 
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 #include "group_manager_inline_impl.cc"
 #include "mesh.hh"
 #include "mesh_io.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_synchronizer.hh"
 #include "mesh_utils_distribution.hh"
 #include "node_synchronizer.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_field.hh"
 #include "dumper_internal_material_field.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 const Element ElementNull(_not_defined, 0);
 
 /* -------------------------------------------------------------------------- */
 void Element::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
   stream << space << "Element [" << type << ", " << element << ", "
          << ghost_type << "]";
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id,
            StaticCommunicator & communicator)
     : Memory(id, memory_id),
       GroupManager(*this, id + ":group_manager", memory_id),
       nodes_type(0, 1, id + ":nodes_type"),
       connectivities("connectivities", id, memory_id),
       normals("normals", id, memory_id), spatial_dimension(spatial_dimension),
       lower_bounds(spatial_dimension, 0.), upper_bounds(spatial_dimension, 0.),
       size(spatial_dimension, 0.), local_lower_bounds(spatial_dimension, 0.),
       local_upper_bounds(spatial_dimension, 0.),
       mesh_data("mesh_data", id, memory_id), communicator(&communicator) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, StaticCommunicator & communicator,
            const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, id, memory_id, communicator) {
   AKANTU_DEBUG_IN();
 
   this->nodes =
       std::make_shared<Array<Real>>(0, spatial_dimension, id + ":coordinates");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, StaticCommunicator::getStaticCommunicator(), id,
            memory_id) {}
 
 // /* --------------------------------------------------------------------------
 // */ Mesh::Mesh(UInt spatial_dimension, const ID & nodes_id, const ID & id,
 //            const MemoryID & memory_id)
 //     : Mesh(spatial_dimension, id, memory_id,
 //            StaticCommunicator::getStaticCommunicator()) {
 //   this->nodes = &(this->getArray<Real>(nodes_id));
-//   this->nb_global_nodes = this->nodes->getSize();
+//   this->nb_global_nodes = this->nodes->size();
 //   this->computeBoundingBox();
 // }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, std::shared_ptr<Array<Real>> nodes,
            const ID & id, const MemoryID & memory_id)
     : Mesh(spatial_dimension, id, memory_id,
            StaticCommunicator::getStaticCommunicator()) {
   this->nodes = nodes;
 
-  this->nb_global_nodes = this->nodes->getSize();
+  this->nb_global_nodes = this->nodes->size();
 
-  this->nodes_to_elements.resize(nodes->getSize());
+  this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh & Mesh::initMeshFacets(const ID & id) {
   AKANTU_DEBUG_IN();
 
   if (!mesh_facets) {
     mesh_facets = std::make_unique<Mesh>(spatial_dimension, this->nodes,
                                          getID() + ":" + id, getMemoryID());
 
     mesh_facets->mesh_parent = this;
     mesh_facets->is_mesh_facets = true;
   }
 
   AKANTU_DEBUG_OUT();
   return *mesh_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::defineMeshParent(const Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   this->mesh_parent = &mesh;
   this->is_mesh_facets = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::~Mesh() = default;
 
 /* -------------------------------------------------------------------------- */
 void Mesh::read(const std::string & filename, const MeshIOType & mesh_io_type) {
   MeshIO mesh_io;
   mesh_io.read(filename, *this, mesh_io_type);
 
   type_iterator it =
       this->firstType(spatial_dimension, _not_ghost, _ek_not_defined);
   type_iterator last =
       this->lastType(spatial_dimension, _not_ghost, _ek_not_defined);
   if (it == last)
     AKANTU_EXCEPTION(
         "The mesh contained in the file "
         << filename << " does not seem to be of the good dimension."
         << " No element of dimension " << spatial_dimension << " where read.");
 
+  this->nb_global_nodes = this->nodes->size();
+
   this->computeBoundingBox();
 
-  this->nodes_to_elements.resize(nodes->getSize());
+  this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::write(const std::string & filename,
                  const MeshIOType & mesh_io_type) {
   MeshIO mesh_io;
   mesh_io.write(filename, *this, mesh_io_type);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "Mesh [" << std::endl;
   stream << space << " + id                : " << getID() << std::endl;
   stream << space << " + spatial dimension : " << this->spatial_dimension
          << std::endl;
   stream << space << " + nodes [" << std::endl;
   nodes->printself(stream, indent + 2);
   stream << space << " + connectivities [" << std::endl;
   connectivities.printself(stream, indent + 2);
   stream << space << " ]" << std::endl;
 
   GroupManager::printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::computeBoundingBox() {
   AKANTU_DEBUG_IN();
   for (UInt k = 0; k < spatial_dimension; ++k) {
     local_lower_bounds(k) = std::numeric_limits<double>::max();
     local_upper_bounds(k) = -std::numeric_limits<double>::max();
   }
 
-  for (UInt i = 0; i < nodes->getSize(); ++i) {
+  for (UInt i = 0; i < nodes->size(); ++i) {
     //    if(!isPureGhostNode(i))
     for (UInt k = 0; k < spatial_dimension; ++k) {
       local_lower_bounds(k) = std::min(local_lower_bounds[k], (*nodes)(i, k));
       local_upper_bounds(k) = std::max(local_upper_bounds[k], (*nodes)(i, k));
     }
   }
 
   if (this->is_distributed) {
     StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
 
     Matrix<Real> reduce_bounds(spatial_dimension, 2);
     for (UInt k = 0; k < spatial_dimension; ++k) {
       reduce_bounds(k, 0) = local_lower_bounds(k);
       reduce_bounds(k, 1) = -local_upper_bounds(k);
     }
 
     comm.allReduce(reduce_bounds, _so_min);
 
     for (UInt k = 0; k < spatial_dimension; ++k) {
       lower_bounds(k) = reduce_bounds(k, 0);
       upper_bounds(k) = -reduce_bounds(k, 1);
     }
   } else {
     this->lower_bounds = this->local_lower_bounds;
     this->upper_bounds = this->local_upper_bounds;
   }
 
   size = upper_bounds - lower_bounds;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::initNormals() {
   normals.initialize(*this, _nb_component = spatial_dimension,
                      _spatial_dimension = spatial_dimension,
                      _element_kind = _ek_not_defined);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getGlobalConnectivity(
     ElementTypeMapArray<UInt> & global_connectivity, UInt dimension,
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   for (auto type : elementTypes(dimension, ghost_type)) {
     auto & local_conn = connectivities(type, ghost_type);
     auto & g_connectivity = global_connectivity(type, ghost_type);
 
-    UInt nb_nodes = local_conn.getSize() * local_conn.getNbComponent();
+    UInt nb_nodes = local_conn.size() * local_conn.getNbComponent();
 
     if (!nodes_global_ids && is_mesh_facets) {
       std::transform(
           local_conn.begin_reinterpret(nb_nodes),
           local_conn.end_reinterpret(nb_nodes),
           g_connectivity.begin_reinterpret(nb_nodes),
           [& node_ids = *mesh_parent->nodes_global_ids](UInt l)->UInt {
             return node_ids(l);
           });
     } else {
       std::transform(local_conn.begin_reinterpret(nb_nodes),
                      local_conn.end_reinterpret(nb_nodes),
                      g_connectivity.begin_reinterpret(nb_nodes),
                      [& node_ids = *nodes_global_ids](UInt l)->UInt {
                        return node_ids(l);
                      });
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Mesh::getGroupDumper(const std::string & dumper_name,
                                       const std::string & group_name) {
   if (group_name == "all")
     return this->getDumper(dumper_name);
   else
     return element_groups[group_name]->getDumper(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ElementTypeMap<UInt> Mesh::getNbDataPerElem(ElementTypeMapArray<T> & arrays,
                                             const ElementKind & element_kind) {
   ElementTypeMap<UInt> nb_data_per_elem;
 
   for (auto type : elementTypes(spatial_dimension, _not_ghost, element_kind)) {
     UInt nb_elements = this->getNbElement(type);
     auto & array = arrays(type);
 
-    nb_data_per_elem(type) = array.getNbComponent() * array.getSize();
+    nb_data_per_elem(type) = array.getNbComponent() * array.size();
     nb_data_per_elem(type) /= nb_elements;
   }
 
   return nb_data_per_elem;
 }
 
 /* -------------------------------------------------------------------------- */
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<Real> & array,
                        const ElementKind & element_kind);
 
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<UInt> & array,
                        const ElementKind & element_kind);
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 template <typename T>
 dumper::Field *
 Mesh::createFieldFromAttachedData(const std::string & field_id,
                                   const std::string & group_name,
                                   const ElementKind & element_kind) {
 
   dumper::Field * field = nullptr;
   ElementTypeMapArray<T> * internal = nullptr;
   try {
     internal = &(this->getData<T>(field_id));
   } catch (...) {
     return nullptr;
   }
 
   ElementTypeMap<UInt> nb_data_per_elem =
       this->getNbDataPerElem(*internal, element_kind);
 
   field = this->createElementalField<T, dumper::InternalMaterialField>(
       *internal, group_name, this->spatial_dimension, element_kind,
       nb_data_per_elem);
 
   return field;
 }
 
 template dumper::Field *
 Mesh::createFieldFromAttachedData<Real>(const std::string & field_id,
                                         const std::string & group_name,
                                         const ElementKind & element_kind);
 
 template dumper::Field *
 Mesh::createFieldFromAttachedData<UInt>(const std::string & field_id,
                                         const std::string & group_name,
                                         const ElementKind & element_kind);
 #endif
 
 /* -------------------------------------------------------------------------- */
 void Mesh::distribute() {
   this->distribute(StaticCommunicator::getStaticCommunicator());
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::distribute(StaticCommunicator & communicator) {
   AKANTU_DEBUG_ASSERT(is_distributed == false,
                       "This mesh is already distribute");
   this->communicator = &communicator;
 
   this->element_synchronizer = std::make_unique<ElementSynchronizer>(
       *this, this->getID() + ":element_synchronizer", this->getMemoryID(),
       true);
 
   this->node_synchronizer = std::make_unique<NodeSynchronizer>(
       *this, this->getID() + ":node_synchronizer", this->getMemoryID(), true);
 
   Int psize = this->communicator->getNbProc();
 #ifdef AKANTU_USE_SCOTCH
   Int prank = this->communicator->whoAmI();
   if (prank == 0) {
     MeshPartitionScotch partition(*this, spatial_dimension);
     partition.partitionate(psize);
 
     MeshUtilsDistribution::distributeMeshCentralized(*this, 0, partition);
   } else {
     MeshUtilsDistribution::distributeMeshCentralized(*this, 0);
   }
 #else
   if (!(psize == 1)) {
     AKANTU_DEBUG_ERROR("Cannot distribute a mesh without a partitioning tool");
   }
 #endif
 
   this->is_distributed = true;
+
   this->element_synchronizer->buildPrankToElement();
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getAssociatedElements(const Array<UInt> & node_list,
                                  Array<Element> & elements) {
   for (const auto & node : node_list)
     for (const auto & element : *nodes_to_elements[node])
       elements.push_back(element);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::fillNodesToElements() {
   Element e;
 
-  UInt nb_nodes = nodes->getSize();
+  UInt nb_nodes = nodes->size();
   for (UInt n = 0; n < nb_nodes; ++n) {
     this->nodes_to_elements[n]->clear();
   }
 
   for (auto ghost_type : ghost_types) {
     e.ghost_type = ghost_type;
     for (const auto & type :
          elementTypes(spatial_dimension, ghost_type, _ek_not_defined)) {
       e.type = type;
       e.kind = getKind(type);
 
       UInt nb_element = this->getNbElement(type, ghost_type);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           connectivities(type, ghost_type)
               .begin(Mesh::getNbNodesPerElement(type));
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it) {
         e.element = el;
         const Vector<UInt> & conn = *conn_it;
         for (UInt n = 0; n < conn.size(); ++n)
           nodes_to_elements[conn(n)]->insert(e);
       }
     }
   }
 }
 
 } // namespace akantu
diff --git a/src/mesh/mesh.hh b/src/mesh/mesh.hh
index 312202a7b..c23eb8552 100644
--- a/src/mesh/mesh.hh
+++ b/src/mesh/mesh.hh
@@ -1,595 +1,595 @@
 /**
  * @file   mesh.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  the class representing the meshes
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_MESH_HH__
 #define __AKANTU_MESH_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_event_handler_manager.hh"
 #include "aka_memory.hh"
 #include "dumpable.hh"
 #include "element.hh"
 #include "element_class.hh"
 #include "element_type_map.hh"
 #include "group_manager.hh"
 #include "mesh_data.hh"
 #include "mesh_events.hh"
 /* -------------------------------------------------------------------------- */
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class StaticCommunicator;
 class ElementSynchronizer;
 class NodeSynchronizer;
 } // namespace akantu
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Mesh                                                                       */
 /* -------------------------------------------------------------------------- */
 
 /**
  * @class  Mesh this  contain the  coordinates of  the nodes  in  the Mesh.nodes
  * Array,  and the  connectivity. The  connectivity  are stored  in by  element
  * types.
  *
  * In order to loop on all element you have to loop on all types like this :
  * @code{.cpp}
  Mesh::type_iterator it = mesh.firstType(dim, ghost_type);
  Mesh::type_iterator end = mesh.lastType(dim, ghost_type);
  for(; it != end; ++it) {
    UInt nb_element  = mesh.getNbElement(*it);
    const Array<UInt> & conn = mesh.getConnectivity(*it);
    for(UInt e = 0; e < nb_element; ++e) {
      ...
    }
  }
  @endcode
 */
 class Mesh : protected Memory,
              public EventHandlerManager<MeshEventHandler>,
              public GroupManager,
              public Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 private:
   /// default constructor used for chaining, the last parameter is just to
   /// differentiate constructors
   Mesh(UInt spatial_dimension, const ID & id, const MemoryID & memory_id,
        StaticCommunicator & 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, StaticCommunicator & communicator,
        const ID & id = "mesh", const MemoryID & memory_id = 0);
 
   /// constructor that use an existing nodes coordinates array, by knowing its
   /// ID
   // Mesh(UInt spatial_dimension, const ID & nodes_id, const ID & id,
   //      const MemoryID & memory_id = 0);
 
   /**
    * constructor that use an existing nodes coordinates
    * array, by getting the vector of coordinates
    */
   Mesh(UInt spatial_dimension, std::shared_ptr<Array<Real>> nodes, const ID & id = "mesh",
        const MemoryID & memory_id = 0);
 
   virtual ~Mesh();
 
   /// @typedef ConnectivityTypeList list of the types present in a Mesh
   typedef std::set<ElementType> ConnectivityTypeList;
 
   /// read the mesh from a file
   void read(const std::string & filename,
             const MeshIOType & mesh_io_type = _miot_auto);
   /// write the mesh to a file
   void write(const std::string & filename,
              const MeshIOType & mesh_io_type = _miot_auto);
 
 private:
   /// initialize the connectivity to NULL and other stuff
   void init();
 
   /// function that computes the bounding box (fills xmin, xmax)
   void computeBoundingBox();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// patitionate the mesh among the processors involved in their computation
   virtual void distribute(StaticCommunicator & communicator);
   virtual void distribute();
 
   /// function to print the containt of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /// extract coordinates of nodes from an element
   template <typename T>
   inline void extractNodalValuesFromElement(const Array<T> & nodal_values,
                                             T * elemental_values,
                                             UInt * connectivity, UInt n_nodes,
                                             UInt nb_degree_of_freedom) const;
 
   // /// extract coordinates of nodes from a reversed element
   // inline void extractNodalCoordinatesFromPBCElement(Real * local_coords,
   //                                                   UInt * connectivity,
   //                                                   UInt n_nodes);
 
   /// convert a element to a linearized element
   inline UInt elementToLinearized(const Element & elem) const;
 
   /// convert a linearized element to an element
   inline Element linearizedToElement(UInt linearized_element) const;
 
   /// update the types offsets array for the conversions
   //inline void updateTypesOffsets(const GhostType & ghost_type);
 
   /// add a Array of connectivity for the type <type>.
   inline void addConnectivityType(const ElementType & type,
                                   const GhostType & ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   template <class Event> inline void sendEvent(Event & event) {
-    //    if(event.getList().getSize() != 0)
+    //    if(event.getList().size() != 0)
     EventHandlerManager<MeshEventHandler>::sendEvent<Event>(event);
   }
 
   /* ------------------------------------------------------------------------ */
   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,
                              UInt dimension, GhostType ghost_type);
 
 public:
   void getAssociatedElements(const Array<UInt> & node_list,
                              Array<Element> & elements);
 
 private:
   /// fills the nodes_to_elements structure
   void fillNodesToElements();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the id of the mesh
   AKANTU_GET_MACRO(ID, Memory::id, const ID &);
 
   /// get the id of the mesh
   AKANTU_GET_MACRO(MemoryID, Memory::memory_id, const MemoryID &);
 
   /// get the spatial dimension of the mesh = number of component of the
   /// coordinates
   AKANTU_GET_MACRO(SpatialDimension, spatial_dimension, UInt);
 
   /// get the nodes Array aka coordinates
   AKANTU_GET_MACRO(Nodes, *nodes, const Array<Real> &);
   AKANTU_GET_MACRO_NOT_CONST(Nodes, *nodes, Array<Real> &);
 
   /// get the normals for the elements
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Normals, normals, Real);
 
   /// get the number of nodes
-  AKANTU_GET_MACRO(NbNodes, nodes->getSize(), UInt);
+  AKANTU_GET_MACRO(NbNodes, nodes->size(), UInt);
 
   /// get the Array of global ids of the nodes (only used in parallel)
   AKANTU_GET_MACRO(GlobalNodesIds, *nodes_global_ids, const Array<UInt> &);
   AKANTU_GET_MACRO_NOT_CONST(GlobalNodesIds, *nodes_global_ids, Array<UInt> &);
 
   /// get the global id of a node
   inline UInt getNodeGlobalId(UInt local_id) const;
 
   /// get the global id of a node
   inline UInt getNodeLocalId(UInt global_id) const;
 
   /// get the global number of nodes
   inline UInt getNbGlobalNodes() const;
 
   /// get the nodes type Array
   AKANTU_GET_MACRO(NodesType, nodes_type, const Array<NodeType> &);
 
 protected:
   AKANTU_GET_MACRO_NOT_CONST(NodesType, nodes_type, Array<NodeType> &);
 
 public:
   inline NodeType getNodeType(UInt local_id) const;
 
   /// say if a node is a pure ghost node
   inline bool isPureGhostNode(UInt n) const;
 
   /// say if a node is pur local or master node
   inline bool isLocalOrMasterNode(UInt n) const;
 
   inline bool isLocalNode(UInt n) const;
   inline bool isMasterNode(UInt n) const;
   inline bool isSlaveNode(UInt n) const;
 
   AKANTU_GET_MACRO(LowerBounds, lower_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(UpperBounds, upper_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(LocalLowerBounds, local_lower_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(LocalUpperBounds, local_upper_bounds, const Vector<Real> &);
 
   /// get the connectivity Array for a given type
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO(Connectivities, connectivities,
                    const ElementTypeMapArray<UInt> &);
 
   /// get the number of element of a type in the mesh
   inline UInt getNbElement(const ElementType & type,
                            const GhostType & ghost_type = _not_ghost) const;
 
   /// get the number of element for a given ghost_type and a given dimension
   inline UInt getNbElement(const UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & kind = _ek_not_defined) const;
 
   // /// get the connectivity list either for the elements or the ghost elements
   // inline const ConnectivityTypeList &
   // getConnectivityTypeList(const GhostType & ghost_type = _not_ghost) const;
 
   /// compute the barycenter of a given element
   inline void getBarycenter(UInt element, const ElementType & type,
                             Real * barycenter,
                             GhostType ghost_type = _not_ghost) const;
   inline void getBarycenter(const Element & element,
                             Vector<Real> & barycenter) const;
 
   /// get the element connected to a subelement
   const Array<std::vector<Element>> &
   getElementToSubelement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
   /// get the element connected to a subelement
   Array<std::vector<Element>> &
   getElementToSubelement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// get the subelement connected to an element
   const Array<Element> &
   getSubelementToElement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
   /// get the subelement connected to an element
   Array<Element> &
   getSubelementToElement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const Array<T> &
   getData(const std::string & 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 std::string & data_name,
                             const ElementType & el_type,
                             const GhostType & ghost_type = _not_ghost);
 
   /// register a new ElementalTypeMap in the MeshData
   template <typename T>
   inline ElementTypeMapArray<T> & registerData(const std::string & data_name);
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const ElementTypeMapArray<T> &
   getData(const std::string & data_name) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline ElementTypeMapArray<T> & getData(const std::string & data_name);
 
   template <typename T>
   ElementTypeMap<UInt> getNbDataPerElem(ElementTypeMapArray<T> & array,
                                         const ElementKind & element_kind);
 
   template <typename T>
   dumper::Field * createFieldFromAttachedData(const std::string & field_id,
                                               const std::string & group_name,
                                               const ElementKind & element_kind);
 
   /// templated getter returning the pointer to data in MeshData (modifiable)
   template <typename T>
   inline Array<T> &
   getDataPointer(const std::string & data_name, const ElementType & el_type,
                  const GhostType & ghost_type = _not_ghost,
                  UInt nb_component = 1, bool size_to_nb_element = true,
                  bool resize_with_parent = false);
 
   /// Facets mesh accessor
   inline const Mesh & getMeshFacets() const;
   inline Mesh & getMeshFacets();
 
   /// Parent mesh accessor
   inline const Mesh & getMeshParent() const;
 
   inline bool isMeshFacets() const { return this->is_mesh_facets; }
 
   /// defines is the mesh is distributed or not
   inline bool isDistributed() const { return this->is_distributed; }
 
 #ifndef SWIG
   /// return the dumper from a group and and a dumper name
   DumperIOHelper & getGroupDumper(const std::string & dumper_name,
                                   const std::string & group_name);
 #endif
   /* ------------------------------------------------------------------------ */
   /* Wrappers on ElementClass functions                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of nodes per element for a given element type
   static inline UInt getNbNodesPerElement(const ElementType & type);
 
   /// get the number of nodes per element for a given element type considered as
   /// a first order element
   static inline ElementType getP1ElementType(const ElementType & type);
 
   /// get the kind of the element type
   static inline ElementKind getKind(const ElementType & type);
 
   /// get spatial dimension of a type of element
   static inline UInt getSpatialDimension(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type, UInt t);
 
   /// get local connectivity of a facet for a given facet type
   static inline MatrixProxy<UInt>
   getFacetLocalConnectivity(const ElementType & type, UInt t = 0);
 
   /// get connectivity of facets for a given element
   inline Matrix<UInt> getFacetConnectivity(const Element & element,
                                            UInt t = 0) const;
 
   /// get the number of type of the surface element associated to a given
   /// element type
   static inline UInt getNbFacetTypes(const ElementType & type, UInt t = 0);
 
   /// get the type of the surface element associated to a given element
   static inline ElementType getFacetType(const ElementType & type, UInt t = 0);
 
   /// get all the type of the surface element associated to a given element
   static inline VectorProxy<ElementType>
   getAllFacetTypes(const ElementType & type);
 
   /// get the number of nodes in the given element list
   static inline UInt getNbNodesPerElementList(const Array<Element> & elements);
 
   /* ------------------------------------------------------------------------ */
   /* Element type Iterator                                                    */
   /* ------------------------------------------------------------------------ */
   using type_iterator = ElementTypeMapArray<UInt, ElementType>::type_iterator;
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<UInt, ElementType>::ElementTypesIteratorHelper;
 
   inline ElementTypesIteratorHelper
   elementTypes(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                ElementKind kind = _ek_regular) const {
     return connectivities.elementTypes(dim, ghost_type, kind);
   }
 
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  GhostType ghost_type = _not_ghost,
                                  ElementKind kind = _ek_regular) const {
     return connectivities.firstType(dim, ghost_type, kind);
   }
 
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 GhostType ghost_type = _not_ghost,
                                 ElementKind kind = _ek_regular) const {
     return connectivities.lastType(dim, ghost_type, kind);
   }
 
   AKANTU_GET_MACRO(ElementSynchronizer, *element_synchronizer,
                    const ElementSynchronizer &);
   AKANTU_GET_MACRO_NOT_CONST(ElementSynchronizer, *element_synchronizer,
                              ElementSynchronizer &);
   AKANTU_GET_MACRO(NodeSynchronizer, *node_synchronizer,
                    const NodeSynchronizer &);
   AKANTU_GET_MACRO_NOT_CONST(NodeSynchronizer, *node_synchronizer,
                              NodeSynchronizer &);
 
   // AKANTU_GET_MACRO_NOT_CONST(Communicator, *communicator, StaticCommunicator
   // &);
   AKANTU_GET_MACRO(Communicator, *communicator, const StaticCommunicator &);
   /* ------------------------------------------------------------------------ */
   /* Private methods for friends                                              */
   /* ------------------------------------------------------------------------ */
 private:
   friend class MeshAccessor;
 
   //#if defined(AKANTU_COHESIVE_ELEMENT)
   //  friend class CohesiveElementInserter;
   //#endif
 
   //#if defined(AKANTU_IGFEM)
   //  template <UInt dim> friend class MeshIgfemSphericalGrowingGel;
   //#endif
 
   AKANTU_GET_MACRO(NodesPointer, *nodes, Array<Real> &);
 
   /// get a pointer to the nodes_global_ids Array<UInt> and create it if
   /// necessary
   inline Array<UInt> & getNodesGlobalIdsPointer();
 
   /// get a pointer to the nodes_type Array<Int> and create it if necessary
   inline Array<NodeType> & getNodesTypePointer();
 
   /// get a pointer to the connectivity Array for the given type and create it
   /// if necessary
   inline Array<UInt> &
   getConnectivityPointer(const ElementType & type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// get a pointer to the element_to_subelement Array for the given type and
   /// create it if necessary
   inline Array<std::vector<Element>> &
   getElementToSubelementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   /// get a pointer to the subelement_to_element Array for the given type and
   /// create it if necessary
   inline Array<Element> &
   getSubelementToElementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   AKANTU_GET_MACRO_NOT_CONST(MeshData, mesh_data, MeshData &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// array of the nodes coordinates
   std::shared_ptr<Array<Real>> nodes;
 
   /// global node ids
   std::unique_ptr<Array<UInt>> nodes_global_ids;
 
   /// node type,  -3 pure ghost, -2  master for the  node, -1 normal node,  i in
   /// [0-N] slave node and master is proc i
   Array<NodeType> nodes_type;
 
   /// global number of nodes;
   UInt nb_global_nodes{0};
 
   /// all class of elements present in this mesh (for heterogenous meshes)
   ElementTypeMapArray<UInt> connectivities;
 
   /// map to normals for all class of elements present in this mesh
   ElementTypeMapArray<Real> normals;
 
   /// list of all existing types in the mesh
   // ConnectivityTypeList type_set;
 
   /// the spatial dimension of this mesh
   UInt spatial_dimension{0};
 
   /// types offsets
   // Array<UInt> types_offsets;
 
   // /// list of all existing types in the mesh
   // ConnectivityTypeList ghost_type_set;
   // /// ghost types offsets
   // Array<UInt> ghost_types_offsets;
 
   /// min of coordinates
   Vector<Real> lower_bounds;
   /// max of coordinates
   Vector<Real> upper_bounds;
   /// size covered by the mesh on each direction
   Vector<Real> size;
 
   /// local min of coordinates
   Vector<Real> local_lower_bounds;
   /// local max of coordinates
   Vector<Real> local_upper_bounds;
 
   /// Extra data loaded from the mesh file
   MeshData mesh_data;
 
   /// facets' mesh
   std::unique_ptr<Mesh> mesh_facets;
 
   /// parent mesh (this is set for mesh_facets meshes)
   const Mesh * mesh_parent{nullptr};
 
   /// defines if current mesh is mesh_facets or not
   bool is_mesh_facets{false};
 
   /// defines if the mesh is centralized or distributed
   bool is_distributed{false};
 
   /// Communicator on which mesh is distributed
   const StaticCommunicator * communicator;
 
   /// Element synchronizer
   std::unique_ptr<ElementSynchronizer> element_synchronizer;
 
   /// Node synchronizer
   std::unique_ptr<NodeSynchronizer> node_synchronizer;
 
   using NodesToElements = std::vector<std::unique_ptr<std::set<Element>>>;
 
   /// This info is stored to simplify the dynamic changes
   NodesToElements nodes_to_elements;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream, const Element & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /// 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 223265a07..2fc9741c9 100644
--- a/src/mesh/mesh_inline_impl.cc
+++ b/src/mesh/mesh_inline_impl.cc
@@ -1,685 +1,685 @@
 /**
  * @file   mesh_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Implementation of the inline functions of the mesh class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
+#include "aka_iterators.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "cohesive_element.hh"
 #endif
 
 #ifndef __AKANTU_MESH_INLINE_IMPL_CC__
 #define __AKANTU_MESH_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline RemovedNodesEvent::RemovedNodesEvent(const Mesh & mesh)
     : new_numbering(mesh.getNbNodes(), 1, "new_numbering") {}
 
 /* -------------------------------------------------------------------------- */
 inline RemovedElementsEvent::RemovedElementsEvent(const Mesh & mesh,
                                                   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->getSize());
+  this->nodes_to_elements.resize(nodes->size());
   for (const auto & elem : event.getList()) {
     const Array<UInt> & conn = connectivities(elem.type, elem.ghost_type);
 
     UInt nb_nodes_per_elem = this->getNbNodesPerElement(elem.type);
 
     for (UInt n = 0; n < nb_nodes_per_elem; ++n) {
       UInt node = conn(elem.element, n);
       if (not nodes_to_elements[node])
         nodes_to_elements[node] = std::make_unique<std::set<Element>>();
       nodes_to_elements[node]->insert(elem);
     }
   }
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline void Mesh::sendEvent<NewNodesEvent>(NewNodesEvent & event) {
   this->computeBoundingBox();
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 Mesh::sendEvent<RemovedElementsEvent>(RemovedElementsEvent & event) {
   this->connectivities.onElementsRemoved(event.getNewNumbering());
   this->fillNodesToElements();
   this->computeBoundingBox();
 
   EventHandlerManager<MeshEventHandler>::sendEvent(event);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Mesh::sendEvent<RemovedNodesEvent>(RemovedNodesEvent & event) {
   const auto & new_numbering = event.getNewNumbering();
   this->removeNodesFromArray(*nodes, new_numbering);
   if (nodes_global_ids)
     this->removeNodesFromArray(*nodes_global_ids, new_numbering);
-  if (nodes_type.getSize() != 0)
+  if (nodes_type.size() != 0)
     this->removeNodesFromArray(nodes_type, new_numbering);
 
-  if(not nodes_to_elements.empty()) {
-    std::vector<std::unique_ptr<std::set<Element>>> tmp(nodes_to_elements.size());
+  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.getSize(), vect.getNbComponent());
+  Array<T> tmp(vect.size(), vect.getNbComponent());
   UInt nb_component = vect.getNbComponent();
   UInt new_nb_nodes = 0;
-  for (UInt i = 0; i < new_numbering.getSize(); ++i) {
+  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 UInt Mesh::elementToLinearized(const Element & elem) const {
 //   AKANTU_DEBUG_ASSERT(elem.type < _max_element_type &&
 //                           elem.element < types_offsets.storage()[elem.type +
 //                           1],
 //                       "The element " << elem << "does not exists in the mesh
 //                       "
 //                                      << getID());
 
 //   return types_offsets.storage()[elem.type] + elem.element;
 // }
 
 // /* --------------------------------------------------------------------------
 // */ inline Element Mesh::linearizedToElement(UInt linearized_element) const {
 
 //   UInt t;
 
 //   for (t = _not_defined;
 //        t != _max_element_type && linearized_element >= types_offsets(t); ++t)
 //     ;
 
 //   AKANTU_DEBUG_ASSERT(linearized_element < types_offsets(t),
 //                       "The linearized element "
 //                           << linearized_element
 //                           << "does not exists in the mesh " << getID());
 
 //   --t;
 //   ElementType type = ElementType(t);
 //   return Element(type, linearized_element - types_offsets.storage()[t],
 //                  _not_ghost, getKind(type));
 // }
 
 // /* --------------------------------------------------------------------------
 // */ inline void Mesh::updateTypesOffsets(const GhostType & ghost_type) {
 //   Array<UInt> * types_offsets_ptr = &this->types_offsets;
 //   if (ghost_type == _ghost)
 //     types_offsets_ptr = &this->ghost_types_offsets;
 //   Array<UInt> & types_offsets = *types_offsets_ptr;
 
 //   types_offsets.clear();
 //   for (auto type : elementTypes(_all_dimensions, ghost_type,
 //   _ek_not_defined))
-//     types_offsets(type) = connectivities(type, ghost_type).getSize();
+//     types_offsets(type) = connectivities(type, ghost_type).size();
 
 //   for (UInt t = _not_defined + 1; t < _max_element_type; ++t)
 //     types_offsets(t) += types_offsets(t - 1);
 //   for (UInt t = _max_element_type; t > _not_defined; --t)
 //     types_offsets(t) = types_offsets(t - 1);
 //   types_offsets(0) = 0;
 // }
 
 // /* --------------------------------------------------------------------------
 // */ inline const Mesh::ConnectivityTypeList &
 // Mesh::getConnectivityTypeList(const GhostType & ghost_type) const {
 //   if (ghost_type == _not_ghost)
 //     return type_set;
 //   else
 //     return ghost_type_set;
 // }
 
 /* -------------------------------------------------------------------------- */
 inline Array<UInt> & Mesh::getNodesGlobalIdsPointer() {
   AKANTU_DEBUG_IN();
   if (not nodes_global_ids) {
-    auto nb_nodes = nodes->getSize();
     nodes_global_ids = std::make_unique<Array<UInt>>(
-        nb_nodes, 1, getID() + ":nodes_global_ids");
+        nodes->size(), 1, getID() + ":nodes_global_ids");
 
-    UInt i = 0;
-    for (auto & global_id : *nodes_global_ids) {
-      global_id = ++i;
+    for (auto && global_ids : counting(*nodes_global_ids)) {
+      std::get<1>(global_ids) = std::get<0>(global_ids);
     }
   }
 
   AKANTU_DEBUG_OUT();
   return *nodes_global_ids;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<NodeType> & Mesh::getNodesTypePointer() {
   AKANTU_DEBUG_IN();
-  if (nodes_type.getSize() == 0) {
-    nodes_type.resize(nodes->getSize());
+  if (nodes_type.size() == 0) {
+    nodes_type.resize(nodes->size());
     nodes_type.set(_nt_normal);
   }
 
   AKANTU_DEBUG_OUT();
   return nodes_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<UInt> &
 Mesh::getConnectivityPointer(const ElementType & type,
                              const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> * tmp;
   if (!connectivities.exists(type, ghost_type)) {
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     tmp = &(connectivities.alloc(0, nb_nodes_per_element, type, ghost_type));
 
     AKANTU_DEBUG_INFO("The connectivity vector for the type " << type
                                                               << " created");
     // if (ghost_type == _not_ghost)
     //   type_set.insert(type);
     // else
     //   ghost_type_set.insert(type);
 
     // updateTypesOffsets(ghost_type);
   } else {
     tmp = &connectivities(type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
   return *tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 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) {
   return getDataPointer<Element>("subelement_to_element", type, ghost_type,
                                  getNbFacetsPerElement(type), true,
                                  is_mesh_facets);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<std::vector<Element>> &
 Mesh::getElementToSubelement(const ElementType & type,
                              const GhostType & ghost_type) const {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<std::vector<Element>> &
 Mesh::getElementToSubelement(const ElementType & type,
                              const GhostType & ghost_type) {
   return getData<std::vector<Element>>("element_to_subelement", type,
                                        ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Array<Element> &
 Mesh::getSubelementToElement(const ElementType & type,
                              const GhostType & ghost_type) const {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Array<Element> &
 Mesh::getSubelementToElement(const ElementType & type,
                              const GhostType & ghost_type) {
   return getData<Element>("subelement_to_element", type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline Array<T> &
 Mesh::getDataPointer(const std::string & 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 const Array<T> & Mesh::getData(const std::string & 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 std::string & data_name,
                                 const ElementType & el_type,
                                 const GhostType & ghost_type) {
   return mesh_data.getElementalDataArray<T>(data_name, el_type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline const ElementTypeMapArray<T> &
 Mesh::getData(const std::string & data_name) const {
   return mesh_data.getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMapArray<T> & Mesh::getData(const std::string & data_name) {
   return mesh_data.getElementalData<T>(data_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMapArray<T> &
 Mesh::registerData(const std::string & 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.getSize();
+    return conn.size();
   } catch (...) {
     return 0;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbElement(const UInt spatial_dimension,
                                const GhostType & ghost_type,
                                const ElementKind & kind) const {
   AKANTU_DEBUG_ASSERT(spatial_dimension <= 3 || spatial_dimension == UInt(-1),
                       "spatial_dimension is " << spatial_dimension
                                               << " and is greater than 3 !");
   UInt nb_element = 0;
 
   for (auto type : elementTypes(spatial_dimension, ghost_type, kind))
     nb_element += getNbElement(type, ghost_type);
 
   return nb_element;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::getBarycenter(UInt element, const ElementType & type,
                                 Real * barycenter, GhostType ghost_type) const {
   UInt * conn_val = getConnectivity(type, ghost_type).storage();
   UInt nb_nodes_per_element = getNbNodesPerElement(type);
 
   Real * local_coord = new Real[spatial_dimension * nb_nodes_per_element];
 
   UInt offset = element * nb_nodes_per_element;
   for (UInt n = 0; n < nb_nodes_per_element; ++n) {
     memcpy(local_coord + n * spatial_dimension,
            nodes->storage() + conn_val[offset + n] * spatial_dimension,
            spatial_dimension * sizeof(Real));
   }
 
   Math::barycenter(local_coord, nb_nodes_per_element, spatial_dimension,
                    barycenter);
 
   delete[] local_coord;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::getBarycenter(const Element & element,
                                 Vector<Real> & barycenter) const {
   getBarycenter(element.element, element.type, barycenter.storage(),
                 element.ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbNodesPerElement(const ElementType & type) {
   UInt nb_nodes_per_element = 0;
 #define GET_NB_NODES_PER_ELEMENT(type)                                         \
   nb_nodes_per_element = ElementClass<type>::getNbNodesPerElement()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_NODES_PER_ELEMENT);
 #undef GET_NB_NODES_PER_ELEMENT
   return nb_nodes_per_element;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementType Mesh::getP1ElementType(const ElementType & type) {
   ElementType p1_type = _not_defined;
 #define GET_P1_TYPE(type) p1_type = ElementClass<type>::getP1ElementType()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_P1_TYPE);
 #undef GET_P1_TYPE
   return p1_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementKind Mesh::getKind(const ElementType & type) {
   ElementKind kind = _ek_not_defined;
 #define GET_KIND(type) kind = ElementClass<type>::getKind()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_KIND);
 #undef GET_KIND
   return kind;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getSpatialDimension(const ElementType & type) {
   UInt spatial_dimension = 0;
 #define GET_SPATIAL_DIMENSION(type)                                            \
   spatial_dimension = ElementClass<type>::getSpatialDimension()
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_SPATIAL_DIMENSION);
 #undef GET_SPATIAL_DIMENSION
 
   return spatial_dimension;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetTypes(const ElementType & type,
                                   __attribute__((unused)) UInt t) {
   UInt nb = 0;
 #define GET_NB_FACET_TYPE(type) nb = ElementClass<type>::getNbFacetTypes()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET_TYPE);
 #undef GET_NB_FACET_TYPE
   return nb;
 }
 
 /* -------------------------------------------------------------------------- */
 inline ElementType Mesh::getFacetType(const ElementType & type, UInt t) {
   ElementType surface_type = _not_defined;
 #define GET_FACET_TYPE(type) surface_type = ElementClass<type>::getFacetType(t)
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_FACET_TYPE);
 #undef GET_FACET_TYPE
 
   return surface_type;
 }
 
 /* -------------------------------------------------------------------------- */
 inline VectorProxy<ElementType>
 Mesh::getAllFacetTypes(const ElementType & type) {
 #define GET_FACET_TYPE(type)                                                   \
   UInt nb = ElementClass<type>::getNbFacetTypes();                             \
   ElementType * elt_ptr =                                                      \
       const_cast<ElementType *>(ElementClass<type>::getFacetTypeInternal());   \
   return VectorProxy<ElementType>(elt_ptr, nb);
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_FACET_TYPE);
 #undef GET_FACET_TYPE
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetsPerElement(const ElementType & type) {
   AKANTU_DEBUG_IN();
 
   UInt n_facet = 0;
 #define GET_NB_FACET(type) n_facet = ElementClass<type>::getNbFacetsPerElement()
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET);
 #undef GET_NB_FACET
 
   AKANTU_DEBUG_OUT();
   return n_facet;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbFacetsPerElement(const ElementType & type, UInt t) {
   AKANTU_DEBUG_IN();
 
   UInt n_facet = 0;
 #define GET_NB_FACET(type)                                                     \
   n_facet = ElementClass<type>::getNbFacetsPerElement(t)
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_NB_FACET);
 #undef GET_NB_FACET
 
   AKANTU_DEBUG_OUT();
   return n_facet;
 }
 
 /* -------------------------------------------------------------------------- */
 inline MatrixProxy<UInt>
 Mesh::getFacetLocalConnectivity(const ElementType & type, UInt t) {
   AKANTU_DEBUG_IN();
 
 #define GET_FACET_CON(type)                                                    \
   AKANTU_DEBUG_OUT();                                                          \
   return ElementClass<type>::getFacetLocalConnectivityPerElement(t)
 
   AKANTU_BOOST_ALL_ELEMENT_SWITCH(GET_FACET_CON);
 #undef GET_FACET_CON
 
   AKANTU_DEBUG_OUT();
   return MatrixProxy<UInt>(
       nullptr, 0, 0); // This avoid a compilation warning but will certainly
   // also cause a segfault if reached
 }
 
 /* -------------------------------------------------------------------------- */
 inline Matrix<UInt> Mesh::getFacetConnectivity(const Element & element,
                                                UInt t) const {
   AKANTU_DEBUG_IN();
 
   Matrix<UInt> local_facets(getFacetLocalConnectivity(element.type, t), false);
   Matrix<UInt> facets(local_facets.rows(), local_facets.cols());
 
   const Array<UInt> & conn = connectivities(element.type, element.ghost_type);
 
   for (UInt f = 0; f < facets.rows(); ++f) {
     for (UInt n = 0; n < facets.cols(); ++n) {
       facets(f, n) = conn(element.element, local_facets(f, n));
     }
   }
 
   AKANTU_DEBUG_OUT();
   return facets;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Mesh::extractNodalValuesFromElement(
     const Array<T> & nodal_values, T * local_coord, UInt * connectivity,
     UInt n_nodes, UInt nb_degree_of_freedom) const {
   for (UInt n = 0; n < n_nodes; ++n) {
     memcpy(local_coord + n * nb_degree_of_freedom,
            nodal_values.storage() + connectivity[n] * nb_degree_of_freedom,
            nb_degree_of_freedom * sizeof(T));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Mesh::addConnectivityType(const ElementType & type,
                                       const GhostType & ghost_type) {
   getConnectivityPointer(type, ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isPureGhostNode(UInt n) const {
-  return nodes_type.getSize() ? (nodes_type(n) == _nt_pure_gost) : false;
+  return nodes_type.size() ? (nodes_type(n) == _nt_pure_gost) : false;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isLocalOrMasterNode(UInt n) const {
-  return nodes_type.getSize()
+  return nodes_type.size()
              ? (nodes_type(n) == _nt_master) || (nodes_type(n) == _nt_normal)
              : true;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isLocalNode(UInt n) const {
-  return nodes_type.getSize() ? nodes_type(n) == _nt_normal : true;
+  return nodes_type.size() ? nodes_type(n) == _nt_normal : true;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isMasterNode(UInt n) const {
-  return nodes_type.getSize() ? nodes_type(n) == _nt_master : false;
+  return nodes_type.size() ? nodes_type(n) == _nt_master : false;
 }
 
 /* -------------------------------------------------------------------------- */
 inline bool Mesh::isSlaveNode(UInt n) const {
-  return nodes_type.getSize() ? nodes_type(n) >= 0 : false;
+  return nodes_type.size() ? nodes_type(n) >= 0 : false;
 }
 
 /* -------------------------------------------------------------------------- */
 inline NodeType Mesh::getNodeType(UInt local_id) const {
-  return nodes_type.getSize() ? nodes_type(local_id) : _nt_normal;
+  return nodes_type.size() ? nodes_type(local_id) : _nt_normal;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNodeGlobalId(UInt local_id) const {
   return nodes_global_ids ? (*nodes_global_ids)(local_id) : local_id;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNodeLocalId(UInt global_id) const {
   AKANTU_DEBUG_ASSERT(nodes_global_ids != NULL, "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->getSize();
+  return nodes_global_ids ? nb_global_nodes : nodes->size();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Mesh::getNbNodesPerElementList(const Array<Element> & elements) {
   UInt nb_nodes_per_element = 0;
   UInt nb_nodes = 0;
   ElementType current_element_type = _not_defined;
 
   Array<Element>::const_iterator<Element> el_it = elements.begin();
   Array<Element>::const_iterator<Element> el_end = elements.end();
 
   for (; el_it != el_end; ++el_it) {
     const Element & el = *el_it;
 
     if (el.type != current_element_type) {
       current_element_type = el.type;
       nb_nodes_per_element = Mesh::getNbNodesPerElement(current_element_type);
     }
 
     nb_nodes += nb_nodes_per_element;
   }
 
   return nb_nodes;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Mesh & Mesh::getMeshFacets() {
   if (!this->mesh_facets)
     AKANTU_EXCEPTION(
         "No facet mesh is defined yet! check the buildFacets functions");
 
   return *this->mesh_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Mesh & Mesh::getMeshFacets() const {
   if (!this->mesh_facets)
     AKANTU_EXCEPTION(
         "No facet mesh is defined yet! check the buildFacets functions");
 
   return *this->mesh_facets;
 }
 /* -------------------------------------------------------------------------- */
 inline const Mesh & Mesh::getMeshParent() const {
   if (!this->mesh_parent)
     AKANTU_EXCEPTION(
         "No parent mesh is defined! This is only valid in a mesh_facets");
 
   return *this->mesh_parent;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
 
 #endif /* __AKANTU_MESH_INLINE_IMPL_CC__ */
diff --git a/src/mesh/node_group.cc b/src/mesh/node_group.cc
index df513dd9e..839472e41 100644
--- a/src/mesh/node_group.cc
+++ b/src/mesh/node_group.cc
@@ -1,111 +1,111 @@
 /**
  * @file   node_group.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Implementation of the node group
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "node_group.hh"
 #include "dumpable.hh"
 #include "dumpable_inline_impl.hh"
 #include "mesh.hh"
 
 #if defined(AKANTU_USE_IOHELPER)
 #  include "dumper_paraview.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NodeGroup::NodeGroup(const std::string & name,
 		     const Mesh & mesh,
 		     const std::string & id,
                      const MemoryID & memory_id) :
   Memory(id, memory_id),
   name(name),
   node_group(alloc<UInt>(std::string(this->id + ":nodes"), 0, 1))//,
   // mesh(mesh)
 {
 
 #if defined(AKANTU_USE_IOHELPER)
   this->registerDumper<DumperParaview>("paraview_"  + name, name, true);
   this->getDumper().registerField("positions",new dumper::NodalField<Real,true>(
                                                                     mesh.getNodes(),
                                                                     0,
                                                                     0,
                                                                     &this->getNodes()));
 #endif
 
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup::~NodeGroup() {}
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::empty() {
   node_group.resize(0);
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::optimize() {
   std::sort(node_group.begin(), node_group.end());
   Array<UInt>::iterator<> end = std::unique(node_group.begin(), node_group.end());
   node_group.resize(end - node_group.begin());
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::append(const NodeGroup & other_group) {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = node_group.getSize();
+  UInt nb_nodes = node_group.size();
 
   /// append new nodes to current list
-  node_group.resize(nb_nodes + other_group.node_group.getSize());
+  node_group.resize(nb_nodes + other_group.node_group.size());
   std::copy(other_group.node_group.begin(),
 	    other_group.node_group.end(),
 	    node_group.begin() + nb_nodes);
 
   optimize();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::printself(std::ostream & stream, int indent) const {
   std::string space;
   for(Int i = 0; i < indent; i++, space += AKANTU_INDENT);
 
   stream << space << "NodeGroup [" << std::endl;
   stream << space << " + name: " << name << std::endl;
   node_group.printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 
 } // akantu
diff --git a/src/mesh/node_group.hh b/src/mesh/node_group.hh
index 40af0023e..1003698b6 100644
--- a/src/mesh/node_group.hh
+++ b/src/mesh/node_group.hh
@@ -1,141 +1,141 @@
 /**
  * @file   node_group.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Node group definition
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_array.hh"
 #include "aka_memory.hh"
 #include "mesh_filter.hh"
 #include "dumpable.hh"
 /* -------------------------------------------------------------------------- */
 
 
 
 #ifndef __AKANTU_NODE_GROUP_HH__
 #define __AKANTU_NODE_GROUP_HH__
 
 namespace akantu {
 
 class NodeGroup : public Memory, public Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   NodeGroup(const std::string & name,
 	    const Mesh & mesh,
             const std::string & id = "node_group",
             const MemoryID & memory_id = 0);
   virtual ~NodeGroup();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   typedef Array<UInt>::const_iterator<UInt> const_node_iterator;
 
   /// empty the node group
   void empty();
 
   /// iterator to the beginning of the node group
   inline const_node_iterator begin() const;
   /// iterator to the end of the node group
   inline const_node_iterator end() const;
 
   /// add a node and give the local position through an iterator
   inline const_node_iterator add(UInt node, bool check_for_duplicate = true);
 
   /// remove a node
   inline void remove(UInt node);
 
   inline decltype(auto) find(UInt node) const {
     return node_group.find(node);
   }
   
   /// remove duplicated nodes
   void optimize();
 
   /// append a group to current one
   void append(const NodeGroup & other_group);
 
   /// apply a filter on current node group
   template <typename T>
   void applyNodeFilter(T & filter);
 
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   AKANTU_GET_MACRO_NOT_CONST(Nodes, node_group, Array<UInt> &);
   AKANTU_GET_MACRO(Nodes, node_group, const Array<UInt> &);
   AKANTU_GET_MACRO(Name, name, const std::string &);
 
   /// give the number of nodes in the current group
-  inline UInt getSize() const;
+  inline UInt size() const;
 
   UInt * storage(){return node_group.storage();};
   
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// name of the group
   std::string name;
 
   /// list of nodes in the group
   Array<UInt> & node_group;
 
   /// reference to the mesh in question
   //const Mesh & mesh;
 };
 
 /// standard output stream operator
 inline std::ostream & operator <<(std::ostream & stream, const NodeGroup & _this)
 {
   _this.printself(stream);
   return stream;
 }
 
 } // akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "node_group_inline_impl.cc"
 
 
 
 #endif /* __AKANTU_NODE_GROUP_HH__ */
diff --git a/src/mesh/node_group_inline_impl.cc b/src/mesh/node_group_inline_impl.cc
index 5a4a22330..3587b776a 100644
--- a/src/mesh/node_group_inline_impl.cc
+++ b/src/mesh/node_group_inline_impl.cc
@@ -1,102 +1,102 @@
 /**
  * @file   node_group_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Node group inline function definitions
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline NodeGroup::const_node_iterator NodeGroup::begin() const {
   return node_group.begin();
 }
 
 /* -------------------------------------------------------------------------- */
 inline NodeGroup::const_node_iterator NodeGroup::end() const {
   return node_group.end();
 }
 
 /* -------------------------------------------------------------------------- */
 inline NodeGroup::const_node_iterator NodeGroup::add(UInt node, bool check_for_duplicate) {
   if(check_for_duplicate) {
     const_node_iterator it = std::find(begin(), end(), node);
     if(it == node_group.end()) {
       node_group.push_back(node);
       return (node_group.end() - 1);
     }
     return it;
   } else {
     node_group.push_back(node);
     return (node_group.end() - 1);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void NodeGroup::remove(UInt node) {
   Array<UInt>::iterator<> it = this->node_group.begin();
   Array<UInt>::iterator<> end = this->node_group.end();
   AKANTU_DEBUG_ASSERT(it != end, "The node group is empty!!");
   for (; it != node_group.end(); ++it) {
     if (*it == node) { 
       it = node_group.erase(it);
     }
   }
   AKANTU_DEBUG_ASSERT(it != end, "The node was not found!");
 }
 
 /* -------------------------------------------------------------------------- */
-inline UInt NodeGroup::getSize() const {
-  return node_group.getSize();
+inline UInt NodeGroup::size() const {
+  return node_group.size();
 }
 
 /* -------------------------------------------------------------------------- */
 struct FilterFunctor;
 
 template <typename T>
 void NodeGroup::applyNodeFilter(T & filter) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(T::type == FilterFunctor::_node_filter_functor,
 		      "NodeFilter can only apply node filter functor");
 
   Array<UInt>::iterator<> it = this->node_group.begin();
 
   for (; it != node_group.end(); ++it) {
     /// filter == true -> keep node
     if (!filter(*it)) { 
       it = node_group.erase(it);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 
 } // akantu
diff --git a/src/mesh_utils/cohesive_element_inserter.cc b/src/mesh_utils/cohesive_element_inserter.cc
index 587afc25c..af9656d93 100644
--- a/src/mesh_utils/cohesive_element_inserter.cc
+++ b/src/mesh_utils/cohesive_element_inserter.cc
@@ -1,458 +1,458 @@
 /**
  * @file   cohesive_element_inserter.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Dec 04 2013
  * @date last modification: Sun Oct 04 2015
  *
  * @brief  Cohesive element inserter functions
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "cohesive_element_inserter.hh"
 #include "element_group.hh"
 #include <algorithm>
 #include <limits>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 CohesiveElementInserter::CohesiveElementInserter(Mesh & mesh, bool is_extrinsic,
                                                  const ID & id)
     : id(id), mesh(mesh), mesh_facets(mesh.initMeshFacets()),
       insertion_facets("insertion_facets", id),
       insertion_limits(mesh.getSpatialDimension(), 2),
       check_facets("check_facets", id) {
 
   MeshUtils::buildAllFacets(mesh, mesh_facets, 0);
   init(is_extrinsic);
 }
 
 /* -------------------------------------------------------------------------- */
 CohesiveElementInserter::~CohesiveElementInserter() {
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   delete global_ids_updater;
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void CohesiveElementInserter::init(bool is_extrinsic) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   MeshUtils::resetFacetToDouble(mesh_facets);
 
   /// initialize facet insertion array
   insertion_facets.initialize(mesh_facets,
                               _spatial_dimension = (spatial_dimension - 1),
                               _with_nb_element = true);
   // mesh_facets.initElementTypeMapArray(
   //     insertion_facets, 1, spatial_dimension - 1, false, _ek_regular, true);
 
   /// init insertion limits
   for (UInt dim = 0; dim < spatial_dimension; ++dim) {
     insertion_limits(dim, 0) = std::numeric_limits<Real>::max() * (-1.);
     insertion_limits(dim, 1) = std::numeric_limits<Real>::max();
   }
 
   if (is_extrinsic) {
     check_facets.initialize(mesh_facets,
                             _spatial_dimension = spatial_dimension - 1);
     // mesh_facets.initElementTypeMapArray(check_facets, 1, spatial_dimension -
     // 1);
     initFacetsCheck();
   }
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   facet_synchronizer = NULL;
   global_ids_updater = NULL;
 #endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void CohesiveElementInserter::initFacetsCheck() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType facet_gt = *gt;
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, facet_gt);
     Mesh::type_iterator last =
         mesh_facets.lastType(spatial_dimension - 1, facet_gt);
 
     for (; it != last; ++it) {
       ElementType facet_type = *it;
 
       Array<bool> & f_check = check_facets(facet_type, facet_gt);
 
       const Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(facet_type, facet_gt);
 
-      UInt nb_facet = element_to_facet.getSize();
+      UInt nb_facet = element_to_facet.size();
       f_check.resize(nb_facet);
 
       for (UInt f = 0; f < nb_facet; ++f) {
         if (element_to_facet(f)[1] == ElementNull ||
             (element_to_facet(f)[0].ghost_type == _ghost &&
              element_to_facet(f)[1].ghost_type == _ghost)) {
           f_check(f) = false;
         } else
           f_check(f) = true;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void CohesiveElementInserter::limitCheckFacets() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   Vector<Real> bary_facet(spatial_dimension);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, ghost_type);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, ghost_type);
     for (; it != end; ++it) {
       ElementType type = *it;
       Array<bool> & f_check = check_facets(type, ghost_type);
       UInt nb_facet = mesh_facets.getNbElement(type, ghost_type);
 
       for (UInt f = 0; f < nb_facet; ++f) {
         if (f_check(f)) {
 
           mesh_facets.getBarycenter(f, type, bary_facet.storage(), ghost_type);
 
           UInt coord_in_limit = 0;
 
           while (coord_in_limit < spatial_dimension &&
                  bary_facet(coord_in_limit) >
                      insertion_limits(coord_in_limit, 0) &&
                  bary_facet(coord_in_limit) <
                      insertion_limits(coord_in_limit, 1))
             ++coord_in_limit;
 
           if (coord_in_limit != spatial_dimension)
             f_check(f) = false;
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void CohesiveElementInserter::setLimit(SpacialDirection axis, Real first_limit,
                                        Real second_limit) {
 
   AKANTU_DEBUG_ASSERT(
       axis < mesh.getSpatialDimension(),
       "You are trying to limit insertion in a direction that doesn't exist");
 
   insertion_limits(axis, 0) = std::min(first_limit, second_limit);
   insertion_limits(axis, 1) = std::max(first_limit, second_limit);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt CohesiveElementInserter::insertIntrinsicElements() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   Vector<Real> bary_facet(spatial_dimension);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType ghost_type = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, ghost_type);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, ghost_type);
 
     for (; it != end; ++it) {
       const ElementType type_facet = *it;
       Array<bool> & f_insertion = insertion_facets(type_facet, ghost_type);
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, ghost_type);
 
       UInt nb_facet = mesh_facets.getNbElement(type_facet, ghost_type);
 
       for (UInt f = 0; f < nb_facet; ++f) {
 
         if (element_to_facet(f)[1] == ElementNull)
           continue;
 
         mesh_facets.getBarycenter(f, type_facet, bary_facet.storage(),
                                   ghost_type);
 
         UInt coord_in_limit = 0;
 
         while (coord_in_limit < spatial_dimension &&
                bary_facet(coord_in_limit) >
                    insertion_limits(coord_in_limit, 0) &&
                bary_facet(coord_in_limit) < insertion_limits(coord_in_limit, 1))
           ++coord_in_limit;
 
         if (coord_in_limit == spatial_dimension)
           f_insertion(f) = true;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 
   return insertElements();
 }
 
 /* -------------------------------------------------------------------------- */
 void CohesiveElementInserter::insertIntrinsicElements(std::string physname,
                                                       UInt material_index) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   ElementTypeMapArray<UInt> * phys_data;
   try {
     phys_data = &(mesh_facets.getData<UInt>("physical_names"));
   } catch (...) {
     phys_data = &(mesh_facets.registerData<UInt>("physical_names"));
     phys_data->initialize(mesh_facets,
                           _spatial_dimension = spatial_dimension - 1,
                           _with_nb_element = true);
     // mesh_facets.initElementTypeMapArray(*phys_data, 1, spatial_dimension - 1,
     //                                     false, _ek_regular, true);
   }
   Vector<Real> bary_facet(spatial_dimension);
   mesh_facets.createElementGroup(physname);
 
   GhostType ghost_type = _not_ghost;
 
   Mesh::type_iterator it =
       mesh_facets.firstType(spatial_dimension - 1, ghost_type);
   Mesh::type_iterator end =
       mesh_facets.lastType(spatial_dimension - 1, ghost_type);
 
   for (; it != end; ++it) {
     const ElementType type_facet = *it;
     Array<bool> & f_insertion = insertion_facets(type_facet, ghost_type);
     Array<std::vector<Element>> & element_to_facet =
         mesh_facets.getElementToSubelement(type_facet, ghost_type);
 
     UInt nb_facet = mesh_facets.getNbElement(type_facet, ghost_type);
     UInt coord_in_limit = 0;
 
     ElementGroup & group = mesh.getElementGroup(physname);
     ElementGroup & group_facet = mesh_facets.getElementGroup(physname);
 
     Vector<Real> bary_physgroup(spatial_dimension);
     Real norm_bary;
     for (ElementGroup::const_element_iterator el_it(
              group.begin(type_facet, ghost_type));
          el_it != group.end(type_facet, ghost_type); ++el_it) {
 
       UInt e = *el_it;
       mesh.getBarycenter(e, type_facet, bary_physgroup.storage(), ghost_type);
 #ifndef AKANTU_NDEBUG
       bool find_a_partner = false;
 #endif
       norm_bary = bary_physgroup.norm();
       Array<UInt> & material_id = (*phys_data)(type_facet, ghost_type);
 
       for (UInt f = 0; f < nb_facet; ++f) {
 
         if (element_to_facet(f)[1] == ElementNull)
           continue;
 
         mesh_facets.getBarycenter(f, type_facet, bary_facet.storage(),
                                   ghost_type);
 
         coord_in_limit = 0;
 
         while (coord_in_limit < spatial_dimension &&
                (std::abs(bary_facet(coord_in_limit) -
                          bary_physgroup(coord_in_limit)) /
                     norm_bary <
                 Math::getTolerance()))
           ++coord_in_limit;
 
         if (coord_in_limit == spatial_dimension) {
           f_insertion(f) = true;
 #ifndef AKANTU_NDEBUG
           find_a_partner = true;
 #endif
           group_facet.add(type_facet, f, ghost_type, false);
           material_id(f) = material_index;
           break;
         }
       }
       AKANTU_DEBUG_ASSERT(find_a_partner,
                           "The element nO "
                               << e << " of physical group " << physname
                               << " did not find its associated facet!"
                               << " Try to decrease math tolerance. "
                               << std::endl);
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt CohesiveElementInserter::insertElements(bool only_double_facets) {
 
   CohesiveNewNodesEvent node_event;
   NewElementsEvent element_event;
 
   Array<UInt> new_pairs(0, 2);
 
   UInt nb_new_elements = MeshUtils::insertCohesiveElements(
       mesh, mesh_facets, insertion_facets, new_pairs,
       element_event.getList(), only_double_facets);
 
-  UInt nb_new_nodes = new_pairs.getSize();
+  UInt nb_new_nodes = new_pairs.size();
   node_event.getList().reserve(nb_new_nodes);
   node_event.getOldNodesList().reserve(nb_new_nodes);
   for(UInt n = 0; n < nb_new_nodes; ++n) {
     node_event.getList().push_back(new_pairs(n, 1));
     node_event.getOldNodesList().push_back(new_pairs(n, 0));
   }
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
-  if (mesh.getNodesType().getSize()) {
+  if (mesh.getNodesType().size()) {
 
     /// update nodes type
     updateNodesType(mesh, node_event);
     updateNodesType(mesh_facets, node_event);
 
     /// update global ids
     nb_new_nodes = this->updateGlobalIDs(node_event);
 
     /// compute total number of new elements
     StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
     comm.allReduce(&nb_new_elements, 1, _so_sum);
   }
 #endif
 
   if (nb_new_nodes > 0)
     mesh.sendEvent(node_event);
 
   if (nb_new_elements > 0) {
     updateInsertionFacets();
     //mesh.updateTypesOffsets(_not_ghost);
     mesh.sendEvent(element_event);
     MeshUtils::resetFacetToDouble(mesh_facets);
   }
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
-  if (mesh.getNodesType().getSize()) {
+  if (mesh.getNodesType().size()) {
     /// update global ids
     this->synchronizeGlobalIDs(node_event);
   }
 #endif
 
   return nb_new_elements;
 }
 
 /* -------------------------------------------------------------------------- */
 void CohesiveElementInserter::updateInsertionFacets() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType facet_gt = *gt;
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, facet_gt);
     Mesh::type_iterator last =
         mesh_facets.lastType(spatial_dimension - 1, facet_gt);
 
     for (; it != last; ++it) {
       ElementType facet_type = *it;
 
       Array<bool> & ins_facets = insertion_facets(facet_type, facet_gt);
 
       // this is the extrinsic case
       if (check_facets.exists(facet_type, facet_gt)) {
         Array<bool> & f_check = check_facets(facet_type, facet_gt);
 
-        UInt nb_facets = f_check.getSize();
+        UInt nb_facets = f_check.size();
 
-        for (UInt f = 0; f < ins_facets.getSize(); ++f) {
+        for (UInt f = 0; f < ins_facets.size(); ++f) {
           if (ins_facets(f)) {
             ++nb_facets;
             ins_facets(f) = false;
             f_check(f) = false;
           }
         }
 
         f_check.resize(nb_facets);
       }
       // and this the intrinsic one
       else {
         ins_facets.resize(mesh_facets.getNbElement(facet_type, facet_gt));
         ins_facets.set(false);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void CohesiveElementInserter::printself(std::ostream & stream,
                                         int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "CohesiveElementInserter [" << std::endl;
 
   stream << space << " + mesh [" << std::endl;
   mesh.printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << " + mesh_facets [" << std::endl;
   mesh_facets.printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 } // namespace akantu
diff --git a/src/mesh_utils/global_ids_updater_inline_impl.cc b/src/mesh_utils/global_ids_updater_inline_impl.cc
index 4976cc9e0..77a4ffe24 100644
--- a/src/mesh_utils/global_ids_updater_inline_impl.cc
+++ b/src/mesh_utils/global_ids_updater_inline_impl.cc
@@ -1,132 +1,132 @@
 /**
  * @file   global_ids_updater_inline_impl.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Oct 02 2015
  * @date last modification: Sun Oct 04 2015
  *
  * @brief  Implementation of the inline functions of GlobalIdsUpdater
  *
  * @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 "global_ids_updater.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_GLOBAL_IDS_UPDATER_INLINE_IMPL_CC__
 #define __AKANTU_GLOBAL_IDS_UPDATER_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline UInt GlobalIdsUpdater::getNbData(const Array<Element> & elements,
                                         const SynchronizationTag & tag) const {
   UInt size = 0;
-  if (elements.getSize() == 0)
+  if (elements.size() == 0)
     return size;
 
   if (tag == _gst_giu_global_conn)
     size += Mesh::getNbNodesPerElementList(elements) * sizeof(UInt);
 
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void GlobalIdsUpdater::packData(CommunicationBuffer & buffer,
                                        const Array<Element> & elements,
                                        const SynchronizationTag & tag) const {
   if (tag == _gst_giu_global_conn)
     packUnpackGlobalConnectivity<true>(buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void GlobalIdsUpdater::unpackData(CommunicationBuffer & buffer,
                                          const Array<Element> & elements,
                                          const SynchronizationTag & tag) {
   if (tag == _gst_giu_global_conn)
     packUnpackGlobalConnectivity<false>(buffer, elements);
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool pack_mode>
 inline void GlobalIdsUpdater::packUnpackGlobalConnectivity(
     CommunicationBuffer & buffer, const Array<Element> & elements) const {
   AKANTU_DEBUG_IN();
 
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
 
   Array<UInt>::const_vector_iterator conn_begin;
   UInt nb_nodes_per_elem = 0;
   UInt index;
 
   Array<UInt> & global_nodes_ids = mesh.getGlobalNodesIds();
 
   Array<Element>::const_scalar_iterator it = elements.begin();
   Array<Element>::const_scalar_iterator end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
 
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
 
       const Array<UInt> & connectivity =
           mesh.getConnectivity(current_element_type, current_ghost_type);
       nb_nodes_per_elem = connectivity.getNbComponent();
       conn_begin = connectivity.begin(nb_nodes_per_elem);
     }
 
     /// get element connectivity
     const Vector<UInt> current_conn = conn_begin[el.element];
 
     /// loop on all connectivity nodes
     for (UInt n = 0; n < nb_nodes_per_elem; ++n) {
       UInt node = current_conn(n);
 
       if (pack_mode) {
         /// if node is local or master pack its global id, otherwise
         /// dummy data
         if (mesh.isLocalOrMasterNode(node))
           index = global_nodes_ids(node);
         else
           index = UInt(-1);
 
         buffer << index;
       } else {
         buffer >> index;
 
         /// update slave nodes' index
         if (index != UInt(-1) && mesh.isSlaveNode(node))
           global_nodes_ids(node) = index;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
 
 #endif /* __AKANTU_GLOBAL_IDS_UPDATER_INLINE_IMPL_CC__ */
diff --git a/src/mesh_utils/mesh_partition.cc b/src/mesh_utils/mesh_partition.cc
index fbb583db9..51d33e0f3 100644
--- a/src/mesh_utils/mesh_partition.cc
+++ b/src/mesh_utils/mesh_partition.cc
@@ -1,417 +1,421 @@
 /**
  * @file   mesh_partition.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Aug 17 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  implementation of common part of all partitioner
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_partition.hh"
 #include "aka_iterators.hh"
 #include "aka_types.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
+#include <algorithm>
+#include <numeric>
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MeshPartition::MeshPartition(const Mesh & mesh, UInt spatial_dimension,
                              const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), mesh(mesh), spatial_dimension(spatial_dimension),
       partitions("partition", id, memory_id),
       ghost_partitions("ghost_partition", id, memory_id),
       ghost_partitions_offset("ghost_partition_offset", id, memory_id),
-      saved_connectivity("saved_connectivity", id, memory_id) {
+      saved_connectivity("saved_connectivity", id, memory_id),
+      lin_to_element(mesh.getNbElement(spatial_dimension)){
   AKANTU_DEBUG_IN();
 
+
   Element elem;
   elem.ghost_type = _not_ghost;
 
+  lin_to_element.resize(0);
   for (auto && type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_not_defined)) {
     elem.type = type;
     for (auto && i : arange(mesh.getNbElement(elem.type))) {
       elem.element = i;
       lin_to_element.push_back(elem);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MeshPartition::~MeshPartition() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * TODO this function should most probably be rewritten in a more modern way
  * conversion in c++ of the GENDUALMETIS (mesh.c) function wrote by George in
  * Metis (University of Minnesota)
  */
 void MeshPartition::buildDualGraph(Array<Int> & dxadj, Array<Int> & dadjncy,
                                    Array<Int> & edge_loads,
                                    const EdgeLoadFunctor & edge_load_func) {
   AKANTU_DEBUG_IN();
 
   // tweak mesh;
   UInt nb_good_types = 0;
 
   std::vector<UInt> nb_nodes_per_element_p1;
   std::vector<UInt> magic_number;
   std::vector<UInt> nb_element;
-  std::vector<Array<UInt> *> conn;
+  std::vector<Array<UInt> *> connectivities;
 
   Element elem;
   elem.ghost_type = _not_ghost;
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (auto & type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_not_defined)) {
     elem.type = type;
 
     ElementType type_p1 = Mesh::getP1ElementType(type);
 
-    conn.push_back(
+    connectivities.push_back(
         &const_cast<Array<UInt> &>(mesh.getConnectivity(type, _not_ghost)));
     nb_nodes_per_element_p1.push_back(Mesh::getNbNodesPerElement(type_p1));
-    nb_element.push_back(conn.back()->getSize());
+    nb_element.push_back(connectivities.back()->size());
     magic_number.push_back(
         Mesh::getNbNodesPerElement(Mesh::getFacetType(type_p1)));
 
     ++nb_good_types;
   }
 
   CSR<Element> node_to_elem;
 
   MeshUtils::buildNode2Elements(mesh, node_to_elem);
 
-  UInt nb_total_element = 0;
-  UInt nb_total_node_element = 0;
-  for (UInt t = 0; t < nb_good_types; ++t) {
-    nb_total_element += nb_element[t];
-    nb_total_node_element += nb_element[t] * nb_nodes_per_element_p1[t];
-  }
+  UInt nb_total_element =
+      std::accumulate(nb_element.begin(), nb_element.end(), 0);
 
   dxadj.resize(nb_total_element + 1);
-
   /// initialize the dxadj array
-  for (UInt t = 0, linerized_el = 0; t < nb_good_types; ++t)
-    for (UInt el = 0; el < nb_element[t]; ++el, ++linerized_el)
-      dxadj(linerized_el) = nb_nodes_per_element_p1[t];
+  auto dxadj_it = dxadj.begin();
+  for (auto && t : arange(nb_good_types)) {
+    std::fill_n(dxadj_it, nb_element[t], nb_nodes_per_element_p1[t]);
+    dxadj_it += nb_element[t];
+  }
 
   /// convert the dxadj_val array in a csr one
   for (UInt i = 1; i < nb_total_element; ++i)
     dxadj(i) += dxadj(i - 1);
   for (UInt i = nb_total_element; i > 0; --i)
     dxadj(i) = dxadj(i - 1);
   dxadj(0) = 0;
 
   dadjncy.resize(2 * dxadj(nb_total_element));
   edge_loads.resize(2 * dxadj(nb_total_element));
 
   /// weight map to determine adjacency
   std::unordered_map<UInt, UInt> weight_map;
 
   for (UInt t = 0, linerized_el = 0; t < nb_good_types; ++t) {
-    for (UInt el = 0; el < nb_element[t]; ++el, ++linerized_el) {
+    auto conn_it = connectivities[t]->begin(connectivities[t]->getNbComponent());
+    auto conn_end = connectivities[t]->end(connectivities[t]->getNbComponent());
+    for (; conn_it != conn_end; ++conn_it, ++linerized_el) {
       /// fill the weight map
-      for (UInt n = 0; n < nb_nodes_per_element_p1[t]; ++n) {
-        UInt node = (*conn[t])(el, n);
-        CSR<Element>::iterator k;
-        for (k = node_to_elem.rbegin(node); k != node_to_elem.rend(node); --k) {
-          Element current_element = *k;
-          UInt current_el = lin_to_element.find(current_element);
+      const auto & conn = *conn_it;
+      for (UInt n : arange(nb_nodes_per_element_p1[t])) {
+        auto && node = conn(n);
+        for (auto k = node_to_elem.rbegin(node); k != node_to_elem.rend(node);
+             --k) {
+          auto && current_element = *k;
+          auto && current_el = lin_to_element.find(current_element);
 
           if (current_el <= linerized_el)
             break;
 
-          auto it_w = weight_map.find(current_el);
-
-          if (it_w == weight_map.end()) {
-            weight_map[current_el] = 1;
-          } else {
-            it_w->second++;
-          }
+          auto && weight_map_insert =
+              weight_map.insert(std::make_pair(current_el, 1));
+          if (not weight_map_insert.second)
+            (weight_map_insert.first->second)++;
         }
       }
+
       /// each element with a weight of the size of a facet are adjacent
-      for (auto it_w = weight_map.begin(); it_w != weight_map.end(); ++it_w) {
-        if (it_w->second == magic_number[t]) {
-          UInt adjacent_el = it_w->first;
+      for (auto && weight_pair : weight_map) {
+        UInt magic, adjacent_el;
+        std::tie(adjacent_el, magic) = weight_pair;
+        if (magic == magic_number[t]) {
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
           /// Patch in order to prevent neighboring cohesive elements
           /// from detecting each other
           ElementKind linearized_el_kind = lin_to_element(linerized_el).kind;
           ElementKind adjacent_el_kind = lin_to_element(adjacent_el).kind;
 
           if (linearized_el_kind == adjacent_el_kind &&
               linearized_el_kind == _ek_cohesive)
             continue;
 #endif
 
           UInt index_adj = dxadj(adjacent_el)++;
           UInt index_lin = dxadj(linerized_el)++;
 
           dadjncy(index_lin) = adjacent_el;
           dadjncy(index_adj) = linerized_el;
         }
       }
 
       weight_map.clear();
     }
   }
 
   Int k_start = 0;
   for (UInt t = 0, linerized_el = 0, j = 0; t < nb_good_types; ++t)
     for (UInt el = 0; el < nb_element[t]; ++el, ++linerized_el) {
       for (Int k = k_start; k < dxadj(linerized_el); ++k, ++j)
         dadjncy(j) = dadjncy(k);
       dxadj(linerized_el) = j;
       k_start += nb_nodes_per_element_p1[t];
     }
 
   for (UInt i = nb_total_element; i > 0; --i)
     dxadj(i) = dxadj(i - 1);
   dxadj(0) = 0;
 
   UInt adj = 0;
   for (UInt i = 0; i < nb_total_element; ++i) {
     UInt nb_adj = dxadj(i + 1) - dxadj(i);
     for (UInt j = 0; j < nb_adj; ++j, ++adj) {
       Int el_adj_id = dadjncy(dxadj(i) + j);
       Element el = lin_to_element(i);
       Element el_adj = lin_to_element(el_adj_id);
 
       Int load = edge_load_func(el, el_adj);
       edge_loads(adj) = load;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartition::fillPartitionInformation(
     const Mesh & mesh, const Int * linearized_partitions) {
   AKANTU_DEBUG_IN();
 
   CSR<Element> node_to_elem;
 
   MeshUtils::buildNode2Elements(mesh, node_to_elem);
 
   UInt linearized_el = 0;
   for (auto & type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_not_defined)) {
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     partitions.alloc(nb_element, 1, type, _not_ghost);
     auto & ghost_part_csr = ghost_partitions_csr(type, _not_ghost);
     ghost_part_csr.resizeRows(nb_element);
 
     ghost_partitions_offset.alloc(nb_element + 1, 1, type, _ghost);
     ghost_partitions.alloc(0, 1, type, _ghost);
 
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     for (UInt el = 0; el < nb_element; ++el, ++linearized_el) {
       UInt part = linearized_partitions[linearized_el];
 
       partitions(type, _not_ghost)(el) = part;
       std::list<UInt> list_adj_part;
       for (UInt n = 0; n < nb_nodes_per_element; ++n) {
         UInt node = connectivity.storage()[el * nb_nodes_per_element + n];
         CSR<Element>::iterator ne;
         for (ne = node_to_elem.begin(node); ne != node_to_elem.end(node);
              ++ne) {
           const Element & adj_element = *ne;
           UInt adj_el = lin_to_element.find(adj_element);
           UInt adj_part = linearized_partitions[adj_el];
           if (part != adj_part) {
             list_adj_part.push_back(adj_part);
           }
         }
       }
 
       list_adj_part.sort();
       list_adj_part.unique();
 
       for (auto & adj_part : list_adj_part) {
         ghost_part_csr.getRows().push_back(adj_part);
         ghost_part_csr.rowOffset(el)++;
 
         ghost_partitions(type, _ghost).push_back(adj_part);
         ghost_partitions_offset(type, _ghost)(el)++;
       }
     }
 
     ghost_part_csr.countToCSR();
 
     /// convert the ghost_partitions_offset array in an offset array
     Array<UInt> & ghost_partitions_offset_ptr =
         ghost_partitions_offset(type, _ghost);
     for (UInt i = 1; i < nb_element; ++i)
       ghost_partitions_offset_ptr(i) += ghost_partitions_offset_ptr(i - 1);
     for (UInt i = nb_element; i > 0; --i)
       ghost_partitions_offset_ptr(i) = ghost_partitions_offset_ptr(i - 1);
     ghost_partitions_offset_ptr(0) = 0;
   }
 
   // All Facets
   for (Int sp = spatial_dimension - 1; sp >= 0; --sp) {
     for (auto & type : mesh.elementTypes(sp, _not_ghost, _ek_not_defined)) {
       UInt nb_element = mesh.getNbElement(type);
 
       partitions.alloc(nb_element, 1, type, _not_ghost);
       AKANTU_DEBUG_INFO("Allocating partitions for " << type);
       auto & ghost_part_csr = ghost_partitions_csr(type, _not_ghost);
       ghost_part_csr.resizeRows(nb_element);
 
       ghost_partitions_offset.alloc(nb_element + 1, 1, type, _ghost);
       ghost_partitions.alloc(0, 1, type, _ghost);
       AKANTU_DEBUG_INFO("Allocating ghost_partitions for " << type);
       const Array<std::vector<Element>> & elem_to_subelem =
           mesh.getElementToSubelement(type, _not_ghost);
       for (UInt i(0); i < mesh.getNbElement(type, _not_ghost);
            ++i) { // Facet loop
 
         const std::vector<Element> & adjacent_elems = elem_to_subelem(i);
         if (!adjacent_elems.empty()) {
           Element min_elem;
           UInt min_part(std::numeric_limits<UInt>::max());
           std::set<UInt> adjacent_parts;
 
           for (UInt j(0); j < adjacent_elems.size(); ++j) {
             UInt adjacent_elem_id = adjacent_elems[j].element;
             UInt adjacent_elem_part =
                 partitions(adjacent_elems[j].type,
                            adjacent_elems[j].ghost_type)(adjacent_elem_id);
             if (adjacent_elem_part < min_part) {
               min_part = adjacent_elem_part;
               min_elem = adjacent_elems[j];
             }
             adjacent_parts.insert(adjacent_elem_part);
           }
           partitions(type, _not_ghost)(i) = min_part;
 
           auto git = ghost_partitions_csr(min_elem.type, _not_ghost)
                          .begin(min_elem.element);
           auto gend = ghost_partitions_csr(min_elem.type, _not_ghost)
                           .end(min_elem.element);
           for (; git != gend; ++git) {
 
             adjacent_parts.insert(min_part);
           }
           adjacent_parts.erase(min_part);
           for (auto & part : adjacent_parts) {
             ghost_part_csr.getRows().push_back(part);
             ghost_part_csr.rowOffset(i)++;
             ghost_partitions(type, _ghost).push_back(part);
           }
 
           ghost_partitions_offset(type, _ghost)(i + 1) =
               ghost_partitions_offset(type, _ghost)(i + 1) +
               adjacent_elems.size();
         } else {
           partitions(type, _not_ghost)(i) = 0;
         }
       }
       ghost_part_csr.countToCSR();
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartition::tweakConnectivity(const Array<UInt> & pairs) {
   AKANTU_DEBUG_IN();
 
-  if (pairs.getSize() == 0)
+  if (pairs.size() == 0)
     return;
 
   Mesh::type_iterator it =
       mesh.firstType(spatial_dimension, _not_ghost, _ek_not_defined);
   Mesh::type_iterator end =
       mesh.lastType(spatial_dimension, _not_ghost, _ek_not_defined);
 
   for (; it != end; ++it) {
     ElementType type = *it;
 
     Array<UInt> & conn =
         const_cast<Array<UInt> &>(mesh.getConnectivity(type, _not_ghost));
     UInt nb_nodes_per_element = conn.getNbComponent();
-    UInt nb_element = conn.getSize();
+    UInt nb_element = conn.size();
 
     Array<UInt> & saved_conn = saved_connectivity.alloc(
         nb_element, nb_nodes_per_element, type, _not_ghost);
     saved_conn.copy(conn);
 
-    for (UInt i = 0; i < pairs.getSize(); ++i) {
+    for (UInt i = 0; i < pairs.size(); ++i) {
       for (UInt el = 0; el < nb_element; ++el) {
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           if (pairs(i, 1) == conn(el, n))
             conn(el, n) = pairs(i, 0);
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartition::restoreConnectivity() {
   AKANTU_DEBUG_IN();
 
   ElementTypeMapArray<UInt>::type_iterator it = saved_connectivity.firstType(
       spatial_dimension, _not_ghost, _ek_not_defined);
   ElementTypeMapArray<UInt>::type_iterator end = saved_connectivity.lastType(
       spatial_dimension, _not_ghost, _ek_not_defined);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     Array<UInt> & conn =
         const_cast<Array<UInt> &>(mesh.getConnectivity(type, _not_ghost));
     Array<UInt> & saved_conn = saved_connectivity(type, _not_ghost);
     conn.copy(saved_conn);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/mesh_utils/mesh_partition.hh b/src/mesh_utils/mesh_partition.hh
index 0d3ad6346..6e9909bb1 100644
--- a/src/mesh_utils/mesh_partition.hh
+++ b/src/mesh_utils/mesh_partition.hh
@@ -1,152 +1,150 @@
 /**
  * @file   mesh_partition.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Sep 01 2015
  *
  * @brief  tools to partitionate a mesh
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_PARTITION_HH__
 #define __AKANTU_MESH_PARTITION_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_csr.hh"
 #include "aka_memory.hh"
 #include "mesh.hh"
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class MeshPartition : protected Memory {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   MeshPartition(const Mesh & mesh, UInt spatial_dimension,
                 const ID & id = "MeshPartitioner",
                 const MemoryID & memory_id = 0);
 
   virtual ~MeshPartition();
 
   class EdgeLoadFunctor {
   public:
-    virtual Int operator()(__attribute__((unused)) const Element & el1,
-                           __attribute__((unused))
-                           const Element & el2) const = 0;
+    virtual Int operator()(const Element & el1, const Element & el2) const
+        noexcept = 0;
   };
 
   class ConstEdgeLoadFunctor : public EdgeLoadFunctor {
   public:
-    virtual inline Int operator()(__attribute__((unused)) const Element & el1,
-                                  __attribute__((unused))
-                                  const Element & el2) const {
+    virtual inline Int operator()(const Element &, const Element &) const
+        noexcept {
       return 1;
     }
   };
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// define a partition of the mesh
   virtual void
   partitionate(UInt nb_part,
                const EdgeLoadFunctor & edge_load_func = ConstEdgeLoadFunctor(),
                const Array<UInt> & pairs = Array<UInt>()) = 0;
 
   /// reorder the nodes to reduce the filling during the factorization of a
   /// matrix that has a profil based on the connectivity of the mesh
   virtual void reorder() = 0;
 
   /// fill the partitions array with a given linearized partition information
   void fillPartitionInformation(const Mesh & mesh,
                                 const Int * linearized_partitions);
 
 protected:
   /// build the dual graph of the mesh, for all element of spatial_dimension
   void buildDualGraph(Array<Int> & dxadj, Array<Int> & dadjncy,
                       Array<Int> & edge_loads,
                       const EdgeLoadFunctor & edge_load_func);
 
   /// tweak the mesh to handle the PBC pairs
   void tweakConnectivity(const Array<UInt> & pairs);
   /// restore the mesh that has been tweaked
   void restoreConnectivity();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(Partitions, partitions, const ElementTypeMapArray<UInt> &);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Partition, partitions, UInt);
 
   AKANTU_GET_MACRO(GhostPartitionCSR, ghost_partitions_csr,
                    const ElementTypeMap<CSR<UInt>> &);
 
   AKANTU_GET_MACRO(NbPartition, nb_partitions, UInt);
   AKANTU_SET_MACRO(NbPartition, nb_partitions, UInt);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// id
   std::string id;
 
   /// the mesh to partition
   const Mesh & mesh;
 
   /// dimension of the elements to consider in the mesh
   UInt spatial_dimension;
 
   /// number of partitions
   UInt nb_partitions;
 
   /// partition numbers
   ElementTypeMapArray<UInt> partitions;
 
   ElementTypeMap<CSR<UInt>> ghost_partitions_csr;
   ElementTypeMapArray<UInt> ghost_partitions;
   ElementTypeMapArray<UInt> ghost_partitions_offset;
 
   Array<UInt> * permutation;
 
   ElementTypeMapArray<UInt> saved_connectivity;
 
   Array<Element> lin_to_element;
 };
 
 } // namespace akantu
 
 #ifdef AKANTU_USE_SCOTCH
 #include "mesh_partition_scotch.hh"
 #endif
 
 #endif /* __AKANTU_MESH_PARTITION_HH__ */
diff --git a/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc b/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
index f5994e699..6170637e4 100644
--- a/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
+++ b/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
@@ -1,480 +1,484 @@
 /**
  * @file   mesh_partition_scotch.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  implementation of the MeshPartitionScotch class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "mesh_partition_scotch.hh"
 #include "aka_common.hh"
 #include "aka_random_generator.hh"
 #include "aka_static_if.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstdio>
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 #if !defined(AKANTU_USE_PTSCOTCH)
 #ifndef AKANTU_SCOTCH_NO_EXTERN
 extern "C" {
 #endif // AKANTU_SCOTCH_NO_EXTERN
 #include <scotch.h>
 #ifndef AKANTU_SCOTCH_NO_EXTERN
 }
 #endif // AKANTU_SCOTCH_NO_EXTERN
 #else  // AKANTU_USE_PTSCOTCH
 #include <ptscotch.h>
 #endif // AKANTU_USE_PTSCOTCH
 
 namespace akantu {
 
 namespace {
   constexpr int scotch_version = int(SCOTCH_VERSION);
 }
 
 /* -------------------------------------------------------------------------- */
 MeshPartitionScotch::MeshPartitionScotch(const Mesh & mesh,
                                          UInt spatial_dimension, const ID & id,
                                          const MemoryID & memory_id)
     : MeshPartition(mesh, spatial_dimension, id, memory_id) {
   AKANTU_DEBUG_IN();
 
   // check if the akantu types and Scotch one are consistent
   static_assert(
       sizeof(Int) == sizeof(SCOTCH_Num),
       "The integer type of Akantu does not match the one from Scotch");
 
-  static_if(scotch_version >= 6)
-    .then([](auto && y) { SCOTCH_randomSeed(y); })
-    .else_([](auto && y) { srandom(y); })
-    (std::forward<UInt>(RandomGenerator<UInt>::seed()));
+  // static_if(scotch_version >= 6)
+  //   .then([](auto && y) {
+  //       SCOTCH_randomSeed(y);
+  //       })
+  //   .else_([](auto && y) {
+  srandom(RandomGenerator<UInt>::seed());//y);
+      // })
+    // (std::forward<UInt>(RandomGenerator<UInt>::seed()));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 static SCOTCH_Mesh * createMesh(const Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes = mesh.getNbNodes();
 
   UInt total_nb_element = 0;
   UInt nb_edge = 0;
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     total_nb_element += nb_element;
     nb_edge += nb_element * nb_nodes_per_element;
   }
 
   SCOTCH_Num vnodbas = 0;
   SCOTCH_Num vnodnbr = nb_nodes;
 
   SCOTCH_Num velmbas = vnodnbr;
   SCOTCH_Num velmnbr = total_nb_element;
 
   SCOTCH_Num * verttab = new SCOTCH_Num[vnodnbr + velmnbr + 1];
   SCOTCH_Num * vendtab = verttab + 1;
 
   SCOTCH_Num * velotab = NULL;
   SCOTCH_Num * vnlotab = NULL;
   SCOTCH_Num * vlbltab = NULL;
 
   memset(verttab, 0, (vnodnbr + velmnbr + 1) * sizeof(SCOTCH_Num));
 
   it = mesh.firstType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
     if (Mesh::getSpatialDimension(type) != spatial_dimension)
       continue;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     /// count number of occurrence of each node
     for (UInt el = 0; el < nb_element; ++el) {
       UInt * conn_val = connectivity.storage() + el * nb_nodes_per_element;
       for (UInt n = 0; n < nb_nodes_per_element; ++n) {
         verttab[*(conn_val++)]++;
       }
     }
   }
 
   /// convert the occurrence array in a csr one
   for (UInt i = 1; i < nb_nodes; ++i)
     verttab[i] += verttab[i - 1];
   for (UInt i = nb_nodes; i > 0; --i)
     verttab[i] = verttab[i - 1];
   verttab[0] = 0;
 
   /// rearrange element to get the node-element list
   SCOTCH_Num edgenbr = verttab[vnodnbr] + nb_edge;
   SCOTCH_Num * edgetab = new SCOTCH_Num[edgenbr];
 
   UInt linearized_el = 0;
 
   it = mesh.firstType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     for (UInt el = 0; el < nb_element; ++el, ++linearized_el) {
       UInt * conn_val = connectivity.storage() + el * nb_nodes_per_element;
       for (UInt n = 0; n < nb_nodes_per_element; ++n)
         edgetab[verttab[*(conn_val++)]++] = linearized_el + velmbas;
     }
   }
 
   for (UInt i = nb_nodes; i > 0; --i)
     verttab[i] = verttab[i - 1];
   verttab[0] = 0;
 
   SCOTCH_Num * verttab_tmp = verttab + vnodnbr + 1;
   SCOTCH_Num * edgetab_tmp = edgetab + verttab[vnodnbr];
 
   it = mesh.firstType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     const Array<UInt> & connectivity = mesh.getConnectivity(type, _not_ghost);
 
     for (UInt el = 0; el < nb_element; ++el) {
       *verttab_tmp = *(verttab_tmp - 1) + nb_nodes_per_element;
       verttab_tmp++;
       UInt * conn = connectivity.storage() + el * nb_nodes_per_element;
       for (UInt i = 0; i < nb_nodes_per_element; ++i) {
         *(edgetab_tmp++) = *(conn++) + vnodbas;
       }
     }
   }
 
   SCOTCH_Mesh * meshptr = new SCOTCH_Mesh;
 
   SCOTCH_meshInit(meshptr);
 
   SCOTCH_meshBuild(meshptr, velmbas, vnodbas, velmnbr, vnodnbr, verttab,
                    vendtab, velotab, vnlotab, vlbltab, edgenbr, edgetab);
 
   /// Check the mesh
   AKANTU_DEBUG_ASSERT(SCOTCH_meshCheck(meshptr) == 0,
                       "Scotch mesh is not consistent");
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     /// save initial graph
     FILE * fmesh = fopen("ScotchMesh.msh", "w");
     SCOTCH_meshSave(meshptr, fmesh);
     fclose(fmesh);
 
     /// write geometry file
     std::ofstream fgeominit;
     fgeominit.open("ScotchMesh.xyz");
     fgeominit << spatial_dimension << std::endl << nb_nodes << std::endl;
 
     const Array<Real> & nodes = mesh.getNodes();
     Real * nodes_val = nodes.storage();
     for (UInt i = 0; i < nb_nodes; ++i) {
       fgeominit << i << " ";
       for (UInt s = 0; s < spatial_dimension; ++s)
         fgeominit << *(nodes_val++) << " ";
       fgeominit << std::endl;
       ;
     }
     fgeominit.close();
   }
 #endif
 
   AKANTU_DEBUG_OUT();
   return meshptr;
 }
 
 /* -------------------------------------------------------------------------- */
 static void destroyMesh(SCOTCH_Mesh * meshptr) {
   AKANTU_DEBUG_IN();
 
   SCOTCH_Num velmbas, vnodbas, vnodnbr, velmnbr, *verttab, *vendtab, *velotab,
       *vnlotab, *vlbltab, edgenbr, *edgetab, degrptr;
 
   SCOTCH_meshData(meshptr, &velmbas, &vnodbas, &velmnbr, &vnodnbr, &verttab,
                   &vendtab, &velotab, &vnlotab, &vlbltab, &edgenbr, &edgetab,
                   &degrptr);
 
   delete[] verttab;
   delete[] edgetab;
 
   SCOTCH_meshExit(meshptr);
 
   delete meshptr;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionScotch::partitionate(UInt nb_part,
                                        const EdgeLoadFunctor & edge_load_func,
                                        const Array<UInt> & pairs) {
   AKANTU_DEBUG_IN();
 
   nb_partitions = nb_part;
 
   tweakConnectivity(pairs);
 
   AKANTU_DEBUG_INFO("Partitioning the mesh " << mesh.getID() << " in "
                                              << nb_part << " parts.");
 
   Array<Int> dxadj;
   Array<Int> dadjncy;
   Array<Int> edge_loads;
   buildDualGraph(dxadj, dadjncy, edge_loads, edge_load_func);
 
   /// variables that will hold our structures in scotch format
   SCOTCH_Graph scotch_graph;
   SCOTCH_Strat scotch_strat;
 
   /// description number and arrays for struct mesh for scotch
   SCOTCH_Num baseval = 0; // base numbering for element and
   // nodes (0 -> C , 1 -> fortran)
-  SCOTCH_Num vertnbr = dxadj.getSize() - 1; // number of vertexes
+  SCOTCH_Num vertnbr = dxadj.size() - 1; // number of vertexes
   SCOTCH_Num * parttab;                     // array of partitions
   SCOTCH_Num edgenbr = dxadj(vertnbr);      // twice  the number  of "edges"
   //(an "edge" bounds two nodes)
   SCOTCH_Num * verttab = dxadj.storage(); // array of start indices in edgetab
   SCOTCH_Num * vendtab = NULL; // array of after-last indices in edgetab
   SCOTCH_Num * velotab = NULL; // integer  load  associated with
   // every vertex ( optional )
   SCOTCH_Num * edlotab = edge_loads.storage(); // integer  load  associated with
   // every edge ( optional )
   SCOTCH_Num * edgetab = dadjncy.storage(); // adjacency array of every vertex
   SCOTCH_Num * vlbltab = NULL;              // vertex label array (optional)
 
   /// Allocate space for Scotch arrays
   parttab = new SCOTCH_Num[vertnbr];
 
   /// Initialize the strategy structure
   SCOTCH_stratInit(&scotch_strat);
 
   /// Initialize the graph structure
   SCOTCH_graphInit(&scotch_graph);
 
   /// Build the graph from the adjacency arrays
   SCOTCH_graphBuild(&scotch_graph, baseval, vertnbr, verttab, vendtab, velotab,
                     vlbltab, edgenbr, edgetab, edlotab);
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     /// save initial graph
     FILE * fgraphinit = fopen("GraphIniFile.grf", "w");
     SCOTCH_graphSave(&scotch_graph, fgraphinit);
     fclose(fgraphinit);
 
     /// write geometry file
     std::ofstream fgeominit;
     fgeominit.open("GeomIniFile.xyz");
     fgeominit << spatial_dimension << std::endl << vertnbr << std::endl;
 
     const Array<Real> & nodes = mesh.getNodes();
 
     Mesh::type_iterator f_it =
         mesh.firstType(spatial_dimension, _not_ghost, _ek_not_defined);
     Mesh::type_iterator f_end =
         mesh.lastType(spatial_dimension, _not_ghost, _ek_not_defined);
     Array<Real>::const_vector_iterator nodes_it =
         nodes.begin(spatial_dimension);
 
     UInt out_linerized_el = 0;
     for (; f_it != f_end; ++f_it) {
       ElementType type = *f_it;
 
       UInt nb_element = mesh.getNbElement(*f_it);
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
       const Array<UInt> & connectivity = mesh.getConnectivity(type);
 
       Vector<Real> mid(spatial_dimension);
       for (UInt el = 0; el < nb_element; ++el) {
         mid.set(0.);
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           UInt node = connectivity.storage()[nb_nodes_per_element * el + n];
           mid += Vector<Real>(nodes_it[node]);
         }
         mid /= nb_nodes_per_element;
 
         fgeominit << out_linerized_el++ << " ";
         for (UInt s = 0; s < spatial_dimension; ++s)
           fgeominit << mid[s] << " ";
 
         fgeominit << std::endl;
         ;
       }
     }
     fgeominit.close();
   }
 #endif
   /// Check the graph
   AKANTU_DEBUG_ASSERT(SCOTCH_graphCheck(&scotch_graph) == 0,
                       "Graph to partition is not consistent");
 
   /// Partition the mesh
   SCOTCH_graphPart(&scotch_graph, nb_part, &scotch_strat, parttab);
 
   /// Check the graph
   AKANTU_DEBUG_ASSERT(SCOTCH_graphCheck(&scotch_graph) == 0,
                       "Partitioned graph is not consistent");
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     /// save the partitioned graph
     FILE * fgraph = fopen("GraphFile.grf", "w");
     SCOTCH_graphSave(&scotch_graph, fgraph);
     fclose(fgraph);
 
     /// save the partition map
     std::ofstream fmap;
     fmap.open("MapFile.map");
     fmap << vertnbr << std::endl;
     for (Int i = 0; i < vertnbr; i++)
       fmap << i << "    " << parttab[i] << std::endl;
     fmap.close();
   }
 #endif
 
   /// free the scotch data structures
   SCOTCH_stratExit(&scotch_strat);
   SCOTCH_graphFree(&scotch_graph);
   SCOTCH_graphExit(&scotch_graph);
 
   fillPartitionInformation(mesh, parttab);
 
   delete[] parttab;
 
   restoreConnectivity();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshPartitionScotch::reorder() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Reordering the mesh " << mesh.getID());
   SCOTCH_Mesh * scotch_mesh = createMesh(mesh);
 
   UInt nb_nodes = mesh.getNbNodes();
 
   SCOTCH_Strat scotch_strat;
   // SCOTCH_Ordering scotch_order;
 
   SCOTCH_Num * permtab = new SCOTCH_Num[nb_nodes];
   SCOTCH_Num * peritab = NULL;
   SCOTCH_Num cblknbr = 0;
   SCOTCH_Num * rangtab = NULL;
   SCOTCH_Num * treetab = NULL;
 
   /// Initialize the strategy structure
   SCOTCH_stratInit(&scotch_strat);
 
   SCOTCH_Graph scotch_graph;
 
   SCOTCH_graphInit(&scotch_graph);
   SCOTCH_meshGraph(scotch_mesh, &scotch_graph);
 
 #ifndef AKANTU_NDEBUG
   if (AKANTU_DEBUG_TEST(dblDump)) {
     FILE * fgraphinit = fopen("ScotchMesh.grf", "w");
     SCOTCH_graphSave(&scotch_graph, fgraphinit);
     fclose(fgraphinit);
   }
 #endif
 
   /// Check the graph
   // AKANTU_DEBUG_ASSERT(SCOTCH_graphCheck(&scotch_graph) == 0,
   //		      "Mesh to Graph is not consistent");
 
   SCOTCH_graphOrder(&scotch_graph, &scotch_strat, permtab, peritab, &cblknbr,
                     rangtab, treetab);
 
   SCOTCH_graphExit(&scotch_graph);
   SCOTCH_stratExit(&scotch_strat);
   destroyMesh(scotch_mesh);
 
   /// Renumbering
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
     GhostType gt = (GhostType)g;
 
     Mesh::type_iterator it = mesh.firstType(_all_dimensions, gt);
     Mesh::type_iterator end = mesh.lastType(_all_dimensions, gt);
 
     for (; it != end; ++it) {
       ElementType type = *it;
 
       UInt nb_element = mesh.getNbElement(type, gt);
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
       const Array<UInt> & connectivity = mesh.getConnectivity(type, gt);
 
       UInt * conn = connectivity.storage();
       for (UInt el = 0; el < nb_element * nb_nodes_per_element; ++el, ++conn) {
         *conn = permtab[*conn];
       }
     }
   }
 
   /// \todo think of a in-place way to do it
   Real * new_coordinates = new Real[spatial_dimension * nb_nodes];
   Real * old_coordinates = mesh.getNodes().storage();
   for (UInt i = 0; i < nb_nodes; ++i) {
     memcpy(new_coordinates + permtab[i] * spatial_dimension,
            old_coordinates + i * spatial_dimension,
            spatial_dimension * sizeof(Real));
   }
   memcpy(old_coordinates, new_coordinates,
          nb_nodes * spatial_dimension * sizeof(Real));
   delete[] new_coordinates;
 
   delete[] permtab;
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/mesh_utils/mesh_utils.cc b/src/mesh_utils/mesh_utils.cc
index e0e53ad49..f54677e50 100644
--- a/src/mesh_utils/mesh_utils.cc
+++ b/src/mesh_utils/mesh_utils.cc
@@ -1,2342 +1,2342 @@
 /**
  * @file   mesh_utils.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Leonardo Snozzi <leonardo.snozzi@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Aug 20 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  All mesh utils necessary for various tasks
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh_utils.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine.hh"
 #include "mesh_accessor.hh"
 /* -------------------------------------------------------------------------- */
 #include <limits>
 #include <numeric>
 #include <queue>
 #include <set>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildNode2Elements(const Mesh & mesh,
                                    CSR<Element> & node_to_elem,
                                    UInt spatial_dimension) {
   AKANTU_DEBUG_IN();
   if (spatial_dimension == _all_dimensions)
     spatial_dimension = mesh.getSpatialDimension();
 
   /// count number of occurrence of each node
   UInt nb_nodes = mesh.getNbNodes();
 
   /// array for the node-element list
   node_to_elem.resizeRows(nb_nodes);
   node_to_elem.clearRows();
 
   AKANTU_DEBUG_ASSERT(
       mesh.firstType(spatial_dimension) != mesh.lastType(spatial_dimension),
       "Some elements must be found in right dimension to compute facets!");
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     Mesh::type_iterator first =
         mesh.firstType(spatial_dimension, *gt, _ek_not_defined);
     Mesh::type_iterator last =
         mesh.lastType(spatial_dimension, *gt, _ek_not_defined);
 
     for (; first != last; ++first) {
       ElementType type = *first;
       UInt nb_element = mesh.getNbElement(type, *gt);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           mesh.getConnectivity(type, *gt).begin(
               Mesh::getNbNodesPerElement(type));
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it)
         for (UInt n = 0; n < conn_it->size(); ++n)
           ++node_to_elem.rowOffset((*conn_it)(n));
     }
   }
 
   node_to_elem.countToCSR();
   node_to_elem.resizeCols();
 
   /// rearrange element to get the node-element list
   Element e;
   node_to_elem.beginInsertions();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     Mesh::type_iterator first =
         mesh.firstType(spatial_dimension, *gt, _ek_not_defined);
     Mesh::type_iterator last =
         mesh.lastType(spatial_dimension, *gt, _ek_not_defined);
     e.ghost_type = *gt;
     for (; first != last; ++first) {
       ElementType type = *first;
       e.type = type;
       e.kind = Mesh::getKind(type);
       UInt nb_element = mesh.getNbElement(type, *gt);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           mesh.getConnectivity(type, *gt).begin(
               Mesh::getNbNodesPerElement(type));
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it) {
         e.element = el;
         for (UInt n = 0; n < conn_it->size(); ++n)
           node_to_elem.insertInRow((*conn_it)(n), e);
       }
     }
   }
 
   node_to_elem.endInsertions();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * This function should disappear in the future (used in mesh partitioning)
  */
 // void MeshUtils::buildNode2Elements(const Mesh & mesh, CSR<UInt> & node_to_elem,
 //                                    UInt spatial_dimension) {
 //   AKANTU_DEBUG_IN();
 //   if (spatial_dimension == _all_dimensions)
 //     spatial_dimension = mesh.getSpatialDimension();
 //   UInt nb_nodes = mesh.getNbNodes();
 
 //   const Mesh::ConnectivityTypeList & type_list = mesh.getConnectivityTypeList();
 //   Mesh::ConnectivityTypeList::const_iterator it;
 
 //   UInt nb_types = type_list.size();
 //   UInt nb_good_types = 0;
 
 //   Vector<UInt> nb_nodes_per_element(nb_types);
 //   UInt ** conn_val = new UInt *[nb_types];
 //   Vector<UInt> nb_element(nb_types);
 
 //   for (it = type_list.begin(); it != type_list.end(); ++it) {
 //     ElementType type = *it;
 //     if (Mesh::getSpatialDimension(type) != spatial_dimension)
 //       continue;
 
 //     nb_nodes_per_element[nb_good_types] = Mesh::getNbNodesPerElement(type);
 //     conn_val[nb_good_types] = mesh.getConnectivity(type, _not_ghost).storage();
 //     nb_element[nb_good_types] =
-//         mesh.getConnectivity(type, _not_ghost).getSize();
+//         mesh.getConnectivity(type, _not_ghost).size();
 //     nb_good_types++;
 //   }
 
 //   AKANTU_DEBUG_ASSERT(
 //       nb_good_types != 0,
 //       "Some elements must be found in right dimension to compute facets!");
 
 //   /// array for the node-element list
 //   node_to_elem.resizeRows(nb_nodes);
 //   node_to_elem.clearRows();
 
 //   /// count number of occurrence of each node
 //   for (UInt t = 0; t < nb_good_types; ++t) {
 //     for (UInt el = 0; el < nb_element[t]; ++el) {
 //       UInt el_offset = el * nb_nodes_per_element[t];
 //       for (UInt n = 0; n < nb_nodes_per_element[t]; ++n) {
 //         ++node_to_elem.rowOffset(conn_val[t][el_offset + n]);
 //       }
 //     }
 //   }
 
 //   node_to_elem.countToCSR();
 //   node_to_elem.resizeCols();
 //   node_to_elem.beginInsertions();
 
 //   /// rearrange element to get the node-element list
 //   for (UInt t = 0, linearized_el = 0; t < nb_good_types; ++t)
 //     for (UInt el = 0; el < nb_element[t]; ++el, ++linearized_el) {
 //       UInt el_offset = el * nb_nodes_per_element[t];
 //       for (UInt n = 0; n < nb_nodes_per_element[t]; ++n)
 //         node_to_elem.insertInRow(conn_val[t][el_offset + n], linearized_el);
 //     }
 
 //   node_to_elem.endInsertions();
 //   delete[] conn_val;
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildNode2ElementsElementTypeMap(const Mesh & mesh,
                                                  CSR<UInt> & node_to_elem,
                                                  const ElementType & type,
                                                  const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
   UInt nb_nodes = mesh.getNbNodes();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
-  UInt nb_elements = mesh.getConnectivity(type, ghost_type).getSize();
+  UInt nb_elements = mesh.getConnectivity(type, ghost_type).size();
 
   UInt * conn_val = mesh.getConnectivity(type, ghost_type).storage();
 
   /// array for the node-element list
   node_to_elem.resizeRows(nb_nodes);
   node_to_elem.clearRows();
 
   /// count number of occurrence of each node
   for (UInt el = 0; el < nb_elements; ++el) {
     UInt el_offset = el * nb_nodes_per_element;
     for (UInt n = 0; n < nb_nodes_per_element; ++n)
       ++node_to_elem.rowOffset(conn_val[el_offset + n]);
   }
 
   /// convert the occurrence array in a csr one
   node_to_elem.countToCSR();
 
   node_to_elem.resizeCols();
   node_to_elem.beginInsertions();
 
   /// save the element index in the node-element list
   for (UInt el = 0; el < nb_elements; ++el) {
     UInt el_offset = el * nb_nodes_per_element;
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       node_to_elem.insertInRow(conn_val[el_offset + n], el);
     }
   }
 
   node_to_elem.endInsertions();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildFacets(Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType gt_facet = *gt;
     Mesh::type_iterator it = mesh.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end = mesh.lastType(spatial_dimension - 1, gt_facet);
     for (; it != end; ++it) {
       mesh.getConnectivity(*it, *gt).resize(0);
       // \todo inform the mesh event handler
     }
   }
 
   buildFacetsDimension(mesh, mesh, true, spatial_dimension);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildAllFacets(const Mesh & mesh, Mesh & mesh_facets,
                                UInt to_dimension) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   buildAllFacets(mesh, mesh_facets, spatial_dimension, to_dimension);
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildAllFacets(const Mesh & mesh, Mesh & mesh_facets,
                                UInt from_dimension, UInt to_dimension) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(
       mesh_facets.isMeshFacets(),
       "The mesh_facets should be initialized with initMeshFacets");
 
   const ElementTypeMapArray<UInt> * prank_to_element = nullptr;
 
   if (mesh.isDistributed()) {
     prank_to_element = &(mesh.getElementSynchronizer().getPrankToElement());
   }
 
   /// generate facets
   buildFacetsDimension(mesh, mesh_facets, false, from_dimension,
                        prank_to_element);
 
   /// copy nodes type
   MeshAccessor mesh_accessor_facets(mesh_facets);
   mesh_accessor_facets.getNodesType().copy(mesh.getNodesType());
 
   /// sort facets and generate sub-facets
   for (UInt i = from_dimension - 1; i > to_dimension; --i) {
     buildFacetsDimension(mesh_facets, mesh_facets, false, i, prank_to_element);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::buildFacetsDimension(
     const Mesh & mesh, Mesh & mesh_facets, bool boundary_only, UInt dimension,
     const ElementTypeMapArray<UInt> * prank_to_element) {
   AKANTU_DEBUG_IN();
 
   // save the current parent of mesh_facets and set it temporarly to mesh since
   // mesh is the one containing the elements for which mesh_facets has the
   // sub-elements
   // example: if the function is called with mesh = mesh_facets
   const Mesh * mesh_facets_parent = nullptr;
   try {
     mesh_facets_parent = &mesh_facets.getMeshParent();
   } catch (...) {
   }
 
   mesh_facets.defineMeshParent(mesh);
   MeshAccessor mesh_accessor(mesh_facets);
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   const Array<Real> & mesh_facets_nodes = mesh_facets.getNodes();
   const Array<Real>::const_vector_iterator mesh_facets_nodes_it =
       mesh_facets_nodes.begin(spatial_dimension);
 
   CSR<Element> node_to_elem;
   buildNode2Elements(mesh, node_to_elem, dimension);
 
   Array<UInt> counter;
   std::vector<Element> connected_elements;
 
   // init the SubelementToElement data to improve performance
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     Mesh::type_iterator first = mesh.firstType(dimension, ghost_type);
     Mesh::type_iterator last = mesh.lastType(dimension, ghost_type);
 
     for (; first != last; ++first) {
       ElementType type = *first;
 
       mesh_accessor.getSubelementToElement(type, ghost_type);
 
       Vector<ElementType> facet_types = mesh.getAllFacetTypes(type);
 
       for (UInt ft = 0; ft < facet_types.size(); ++ft) {
         ElementType facet_type = facet_types(ft);
         mesh_accessor.getElementToSubelement(facet_type, ghost_type);
         mesh_accessor.getConnectivity(facet_type, ghost_type);
       }
     }
   }
 
   Element current_element;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     GhostType facet_ghost_type = ghost_type;
 
     current_element.ghost_type = ghost_type;
     Mesh::type_iterator first = mesh.firstType(dimension, ghost_type);
     Mesh::type_iterator last = mesh.lastType(dimension, ghost_type);
 
     for (; first != last; ++first) {
       ElementType type = *first;
       Vector<ElementType> facet_types = mesh.getAllFacetTypes(type);
 
       current_element.type = type;
 
       for (UInt ft = 0; ft < facet_types.size(); ++ft) {
         ElementType facet_type = facet_types(ft);
         UInt nb_element = mesh.getNbElement(type, ghost_type);
 
         Array<std::vector<Element>> * element_to_subelement =
             &mesh_facets.getElementToSubelement(facet_type, ghost_type);
         Array<UInt> * connectivity_facets =
             &mesh_facets.getConnectivity(facet_type, ghost_type);
 
         UInt nb_facet_per_element = mesh.getNbFacetsPerElement(type, ft);
         const Array<UInt> & element_connectivity =
             mesh.getConnectivity(type, ghost_type);
 
         const Matrix<UInt> facet_local_connectivity =
             mesh.getFacetLocalConnectivity(type, ft);
         UInt nb_nodes_per_facet = connectivity_facets->getNbComponent();
         Vector<UInt> facet(nb_nodes_per_facet);
 
         for (UInt el = 0; el < nb_element; ++el) {
           current_element.element = el;
 
           for (UInt f = 0; f < nb_facet_per_element; ++f) {
             for (UInt n = 0; n < nb_nodes_per_facet; ++n)
               facet(n) =
                   element_connectivity(el, facet_local_connectivity(f, n));
 
             UInt first_node_nb_elements = node_to_elem.getNbCols(facet(0));
             counter.resize(first_node_nb_elements);
             counter.clear();
 
             // loop over the other nodes to search intersecting elements,
             // which are the elements that share another node with the
             // starting element after first_node
             CSR<Element>::iterator first_node_elements =
                 node_to_elem.begin(facet(0));
             CSR<Element>::iterator first_node_elements_end =
                 node_to_elem.end(facet(0));
             UInt local_el = 0;
             for (; first_node_elements != first_node_elements_end;
                  ++first_node_elements, ++local_el) {
               for (UInt n = 1; n < nb_nodes_per_facet; ++n) {
                 CSR<Element>::iterator node_elements_begin =
                     node_to_elem.begin(facet(n));
                 CSR<Element>::iterator node_elements_end =
                     node_to_elem.end(facet(n));
                 counter(local_el) +=
                     std::count(node_elements_begin, node_elements_end,
                                *first_node_elements);
               }
             }
 
             // counting the number of elements connected to the facets and
             // taking the minimum element number, because the facet should
             // be inserted just once
             UInt nb_element_connected_to_facet = 0;
             Element minimum_el = ElementNull;
             connected_elements.clear();
             for (UInt el_f = 0; el_f < first_node_nb_elements; el_f++) {
               Element real_el = node_to_elem(facet(0), el_f);
               if (counter(el_f) == nb_nodes_per_facet - 1) {
                 ++nb_element_connected_to_facet;
                 minimum_el = std::min(minimum_el, real_el);
                 connected_elements.push_back(real_el);
               }
             }
 
             if (minimum_el == current_element) {
               bool full_ghost_facet = false;
 
               UInt n = 0;
               while (n < nb_nodes_per_facet && mesh.isPureGhostNode(facet(n)))
                 ++n;
               if (n == nb_nodes_per_facet)
                 full_ghost_facet = true;
 
               if (!full_ghost_facet) {
                 if (!boundary_only ||
                     (boundary_only && nb_element_connected_to_facet == 1)) {
 
                   std::vector<Element> elements;
 
                   // build elements_on_facets: linearized_el must come first
                   // in order to store the facet in the correct direction
                   // and avoid to invert the sign in the normal computation
                   elements.push_back(current_element);
 
                   /// boundary facet
                   if (nb_element_connected_to_facet == 1)
                     elements.push_back(ElementNull);
                   /// internal facet
                   else if (nb_element_connected_to_facet == 2) {
                     elements.push_back(connected_elements[1]);
 
                     /// check if facet is in between ghost and normal
                     /// elements: if it's the case, the facet is either
                     /// ghost or not ghost. The criterion to decide this
                     /// is arbitrary. It was chosen to check the processor
                     /// id (prank) of the two neighboring elements. If
                     /// prank of the ghost element is lower than prank of
                     /// the normal one, the facet is not ghost, otherwise
                     /// it's ghost
                     GhostType gt[2] = {_not_ghost, _not_ghost};
                     for (UInt el = 0; el < connected_elements.size(); ++el)
                       gt[el] = connected_elements[el].ghost_type;
 
                     if (gt[0] + gt[1] == 1) {
                       if (prank_to_element) {
                         UInt prank[2];
                         for (UInt el = 0; el < 2; ++el) {
                           UInt current_el = connected_elements[el].element;
                           ElementType current_type =
                               connected_elements[el].type;
                           GhostType current_gt =
                               connected_elements[el].ghost_type;
 
                           const Array<UInt> & prank_to_el =
                               (*prank_to_element)(current_type, current_gt);
 
                           prank[el] = prank_to_el(current_el);
                         }
 
                         bool ghost_one = (gt[0] != _ghost);
 
                         if (prank[ghost_one] > prank[!ghost_one])
                           facet_ghost_type = _not_ghost;
                         else
                           facet_ghost_type = _ghost;
 
                         connectivity_facets = &mesh_facets.getConnectivity(
                             facet_type, facet_ghost_type);
                         element_to_subelement =
                             &mesh_facets.getElementToSubelement(
                                 facet_type, facet_ghost_type);
                       }
                     }
                   }
                   /// facet of facet
                   else {
                     for (UInt i = 1; i < nb_element_connected_to_facet; ++i) {
                       elements.push_back(connected_elements[i]);
                     }
                   }
 
                   element_to_subelement->push_back(elements);
                   connectivity_facets->push_back(facet);
 
                   /// current facet index
-                  UInt current_facet = connectivity_facets->getSize() - 1;
+                  UInt current_facet = connectivity_facets->size() - 1;
 
                   /// loop on every element connected to current facet and
                   /// insert current facet in the first free spot of the
                   /// subelement_to_element vector
                   for (UInt elem = 0; elem < elements.size(); ++elem) {
                     Element loc_el = elements[elem];
 
                     if (loc_el.type != _not_defined) {
 
                       Array<Element> & subelement_to_element =
                           mesh_facets.getSubelementToElement(loc_el.type,
                                                              loc_el.ghost_type);
 
                       UInt nb_facet_per_loc_element =
                           subelement_to_element.getNbComponent();
 
                       for (UInt f_in = 0; f_in < nb_facet_per_loc_element;
                            ++f_in) {
                         if (subelement_to_element(loc_el.element, f_in).type ==
                             _not_defined) {
                           subelement_to_element(loc_el.element, f_in).type =
                               facet_type;
                           subelement_to_element(loc_el.element, f_in).element =
                               current_facet;
                           subelement_to_element(loc_el.element, f_in)
                               .ghost_type = facet_ghost_type;
                           break;
                         }
                       }
                     }
                   }
 
                   /// reset connectivity in case a facet was found in
                   /// between ghost and normal elements
                   if (facet_ghost_type != ghost_type) {
                     facet_ghost_type = ghost_type;
                     connectivity_facets = &mesh_accessor.getConnectivity(
                         facet_type, facet_ghost_type);
                     element_to_subelement =
                         &mesh_accessor.getElementToSubelement(facet_type,
                                                               facet_ghost_type);
                   }
                 }
               }
             }
           }
         }
       }
     }
   }
 
   // restore the parent of mesh_facet
   if (mesh_facets_parent)
     mesh_facets.defineMeshParent(*mesh_facets_parent);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::renumberMeshNodes(Mesh & mesh,
                                   Array<UInt> & local_connectivities,
                                   UInt nb_local_element, UInt nb_ghost_element,
                                   ElementType type,
                                   Array<UInt> & old_nodes_numbers) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   std::map<UInt, UInt> renumbering_map;
-  for (UInt i = 0; i < old_nodes_numbers.getSize(); ++i) {
+  for (UInt i = 0; i < old_nodes_numbers.size(); ++i) {
     renumbering_map[old_nodes_numbers(i)] = i;
   }
 
   /// renumber the nodes
   renumberNodesInConnectivity(local_connectivities,
                               (nb_local_element + nb_ghost_element) *
                                   nb_nodes_per_element,
                               renumbering_map);
 
   std::map<UInt, UInt>::iterator it = renumbering_map.begin();
   std::map<UInt, UInt>::iterator end = renumbering_map.end();
   old_nodes_numbers.resize(renumbering_map.size());
   for (; it != end; ++it) {
     old_nodes_numbers(it->second) = it->first;
   }
   renumbering_map.clear();
 
   MeshAccessor mesh_accessor(mesh);
 
   /// copy the renumbered connectivity to the right place
   Array<UInt> & local_conn = mesh_accessor.getConnectivity(type);
   local_conn.resize(nb_local_element);
   memcpy(local_conn.storage(), local_connectivities.storage(),
          nb_local_element * nb_nodes_per_element * sizeof(UInt));
 
   Array<UInt> & ghost_conn = mesh_accessor.getConnectivity(type, _ghost);
   ghost_conn.resize(nb_ghost_element);
   memcpy(ghost_conn.storage(),
          local_connectivities.storage() +
              nb_local_element * nb_nodes_per_element,
          nb_ghost_element * nb_nodes_per_element * sizeof(UInt));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::renumberNodesInConnectivity(
     Array<UInt> & list_nodes, UInt nb_nodes,
     std::map<UInt, UInt> & renumbering_map) {
   AKANTU_DEBUG_IN();
 
   UInt * connectivity = list_nodes.storage();
   UInt new_node_num = renumbering_map.size();
   for (UInt n = 0; n < nb_nodes; ++n, ++connectivity) {
     UInt & node = *connectivity;
     std::map<UInt, UInt>::iterator it = renumbering_map.find(node);
     if (it == renumbering_map.end()) {
       UInt old_node = node;
       renumbering_map[old_node] = new_node_num;
       node = new_node_num;
       ++new_node_num;
     } else {
       node = it->second;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::purifyMesh(Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   std::map<UInt, UInt> renumbering_map;
 
   RemovedNodesEvent remove_nodes(mesh);
   Array<UInt> & nodes_removed = remove_nodes.getList();
 
   for (UInt gt = _not_ghost; gt <= _ghost; ++gt) {
     GhostType ghost_type = (GhostType)gt;
 
     Mesh::type_iterator it =
         mesh.firstType(_all_dimensions, ghost_type, _ek_not_defined);
     Mesh::type_iterator end =
         mesh.lastType(_all_dimensions, ghost_type, _ek_not_defined);
     for (; it != end; ++it) {
 
       ElementType type(*it);
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
       Array<UInt> & connectivity = mesh.getConnectivity(type, ghost_type);
-      UInt nb_element(connectivity.getSize());
+      UInt nb_element(connectivity.size());
 
       renumberNodesInConnectivity(
           connectivity, nb_element * nb_nodes_per_element, renumbering_map);
     }
   }
 
   Array<UInt> & new_numbering = remove_nodes.getNewNumbering();
   std::fill(new_numbering.begin(), new_numbering.end(), UInt(-1));
 
   std::map<UInt, UInt>::iterator it = renumbering_map.begin();
   std::map<UInt, UInt>::iterator end = renumbering_map.end();
   for (; it != end; ++it) {
     new_numbering(it->first) = it->second;
   }
 
-  for (UInt i = 0; i < new_numbering.getSize(); ++i) {
+  for (UInt i = 0; i < new_numbering.size(); ++i) {
     if (new_numbering(i) == UInt(-1))
       nodes_removed.push_back(i);
   }
 
   mesh.sendEvent(remove_nodes);
 
   AKANTU_DEBUG_OUT();
 }
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 /* -------------------------------------------------------------------------- */
 UInt MeshUtils::insertCohesiveElements(
     Mesh & mesh, Mesh & mesh_facets,
     const ElementTypeMapArray<bool> & facet_insertion,
     Array<UInt> & doubled_nodes, Array<Element> & new_elements,
     bool only_double_facets) {
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt elements_to_insert = updateFacetToDouble(mesh_facets, facet_insertion);
 
   if (elements_to_insert > 0) {
 
     if (spatial_dimension == 1) {
       doublePointFacet(mesh, mesh_facets, doubled_nodes);
     } else {
       doubleFacet(mesh, mesh_facets, spatial_dimension - 1, doubled_nodes,
                   true);
       findSubfacetToDouble<false>(mesh, mesh_facets);
 
       if (spatial_dimension == 2) {
         doubleSubfacet<2>(mesh, mesh_facets, doubled_nodes);
       } else if (spatial_dimension == 3) {
         doubleFacet(mesh, mesh_facets, 1, doubled_nodes, false);
         findSubfacetToDouble<true>(mesh, mesh_facets);
         doubleSubfacet<3>(mesh, mesh_facets, doubled_nodes);
       }
     }
 
     if (!only_double_facets)
       updateCohesiveData(mesh, mesh_facets, new_elements);
   }
 
   return elements_to_insert;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::doubleNodes(Mesh & mesh, const std::vector<UInt> & old_nodes,
                             Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   Array<Real> & position = mesh.getNodes();
   UInt spatial_dimension = mesh.getSpatialDimension();
 
-  UInt old_nb_nodes = position.getSize();
+  UInt old_nb_nodes = position.size();
   UInt new_nb_nodes = old_nb_nodes + old_nodes.size();
 
-  UInt old_nb_doubled_nodes = doubled_nodes.getSize();
+  UInt old_nb_doubled_nodes = doubled_nodes.size();
   UInt new_nb_doubled_nodes = old_nb_doubled_nodes + old_nodes.size();
 
   position.resize(new_nb_nodes);
   doubled_nodes.resize(new_nb_doubled_nodes);
 
   Array<Real>::iterator<Vector<Real>> position_begin =
       position.begin(spatial_dimension);
 
   for (UInt n = 0; n < old_nodes.size(); ++n) {
     UInt new_node = old_nb_nodes + n;
 
     /// store doubled nodes
     doubled_nodes(old_nb_doubled_nodes + n, 0) = old_nodes[n];
     doubled_nodes(old_nb_doubled_nodes + n, 1) = new_node;
 
     /// update position
     std::copy(position_begin + old_nodes[n], position_begin + old_nodes[n] + 1,
               position_begin + new_node);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::doubleFacet(Mesh & mesh, Mesh & mesh_facets,
                             UInt facet_dimension, Array<UInt> & doubled_nodes,
                             bool facet_mode) {
   AKANTU_DEBUG_IN();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it = mesh_facets.firstType(facet_dimension, gt_facet);
     Mesh::type_iterator end = mesh_facets.lastType(facet_dimension, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
-      UInt nb_facet_to_double = f_to_double.getSize();
+      UInt nb_facet_to_double = f_to_double.size();
 
       if (nb_facet_to_double == 0)
         continue;
 
       ElementType type_subfacet = Mesh::getFacetType(type_facet);
       const UInt nb_subfacet_per_facet =
           Mesh::getNbFacetsPerElement(type_facet);
       GhostType gt_subfacet = _casper;
       Array<std::vector<Element>> * f_to_subfacet = NULL;
 
       Array<Element> & subfacet_to_facet =
           mesh_facets.getSubelementToElement(type_facet, gt_facet);
 
       Array<UInt> & conn_facet =
           mesh_facets.getConnectivity(type_facet, gt_facet);
       UInt nb_nodes_per_facet = conn_facet.getNbComponent();
 
-      UInt old_nb_facet = conn_facet.getSize();
+      UInt old_nb_facet = conn_facet.size();
       UInt new_nb_facet = old_nb_facet + nb_facet_to_double;
 
       conn_facet.resize(new_nb_facet);
       subfacet_to_facet.resize(new_nb_facet);
 
       UInt new_facet = old_nb_facet - 1;
       Element new_facet_el(type_facet, 0, gt_facet);
 
       Array<Element>::iterator<Vector<Element>> subfacet_to_facet_begin =
           subfacet_to_facet.begin(nb_subfacet_per_facet);
       Array<UInt>::iterator<Vector<UInt>> conn_facet_begin =
           conn_facet.begin(nb_nodes_per_facet);
 
       for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
         UInt old_facet = f_to_double(facet);
         ++new_facet;
 
         /// adding a new facet by copying original one
 
         /// copy connectivity in new facet
         std::copy(conn_facet_begin + old_facet,
                   conn_facet_begin + old_facet + 1,
                   conn_facet_begin + new_facet);
 
         /// update subfacet_to_facet
         std::copy(subfacet_to_facet_begin + old_facet,
                   subfacet_to_facet_begin + old_facet + 1,
                   subfacet_to_facet_begin + new_facet);
 
         new_facet_el.element = new_facet;
 
         /// loop on every subfacet
         for (UInt sf = 0; sf < nb_subfacet_per_facet; ++sf) {
           Element & subfacet = subfacet_to_facet(old_facet, sf);
           if (subfacet == ElementNull)
             continue;
 
           if (gt_subfacet != subfacet.ghost_type) {
             gt_subfacet = subfacet.ghost_type;
             f_to_subfacet = &mesh_facets.getElementToSubelement(
                 type_subfacet, subfacet.ghost_type);
           }
 
           /// update facet_to_subfacet array
           (*f_to_subfacet)(subfacet.element).push_back(new_facet_el);
         }
       }
 
       /// update facet_to_subfacet and _segment_3 facets if any
       if (!facet_mode) {
         updateSubfacetToFacet(mesh_facets, type_facet, gt_facet, true);
         updateFacetToSubfacet(mesh_facets, type_facet, gt_facet, true);
         updateQuadraticSegments<true>(mesh, mesh_facets, type_facet, gt_facet,
                                       doubled_nodes);
       } else
         updateQuadraticSegments<false>(mesh, mesh_facets, type_facet, gt_facet,
                                        doubled_nodes);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt MeshUtils::updateFacetToDouble(
     Mesh & mesh_facets, const ElementTypeMapArray<bool> & facet_insertion) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh_facets.getSpatialDimension();
   UInt nb_facets_to_double = 0.;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       const Array<bool> & f_insertion = facet_insertion(type_facet, gt_facet);
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
 
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
       ElementType el_type = _not_defined;
       GhostType el_gt = _casper;
       UInt nb_facet_per_element = 0;
       Element old_facet_el(type_facet, 0, gt_facet);
 
       Array<Element> * facet_to_element = NULL;
 
-      for (UInt f = 0; f < f_insertion.getSize(); ++f) {
+      for (UInt f = 0; f < f_insertion.size(); ++f) {
 
         if (f_insertion(f) == false)
           continue;
 
         ++nb_facets_to_double;
 
         if (element_to_facet(f)[1].type == _not_defined
 #if defined(AKANTU_COHESIVE_ELEMENT)
             || element_to_facet(f)[1].kind == _ek_cohesive
 #endif
         ) {
           AKANTU_DEBUG_WARNING("attempt to double a facet on the boundary");
           continue;
         }
 
         f_to_double.push_back(f);
 
         UInt new_facet = mesh_facets.getNbElement(type_facet, gt_facet) +
-                         f_to_double.getSize() - 1;
+                         f_to_double.size() - 1;
         old_facet_el.element = f;
 
         /// update facet_to_element vector
         Element & elem_to_update = element_to_facet(f)[1];
         UInt el = elem_to_update.element;
 
         if (elem_to_update.ghost_type != el_gt ||
             elem_to_update.type != el_type) {
           el_type = elem_to_update.type;
           el_gt = elem_to_update.ghost_type;
           facet_to_element =
               &mesh_facets.getSubelementToElement(el_type, el_gt);
           nb_facet_per_element = facet_to_element->getNbComponent();
         }
 
         Element * f_update =
             std::find(facet_to_element->storage() + el * nb_facet_per_element,
                       facet_to_element->storage() + el * nb_facet_per_element +
                           nb_facet_per_element,
                       old_facet_el);
 
         AKANTU_DEBUG_ASSERT(
             facet_to_element->storage() + el * nb_facet_per_element !=
                 facet_to_element->storage() + el * nb_facet_per_element +
                     nb_facet_per_element,
             "Facet not found");
 
         f_update->element = new_facet;
 
         /// update elements connected to facet
         std::vector<Element> first_facet_list = element_to_facet(f);
         element_to_facet.push_back(first_facet_list);
 
         /// set new and original facets as boundary facets
         element_to_facet(new_facet)[0] = element_to_facet(new_facet)[1];
 
         element_to_facet(f)[1] = ElementNull;
         element_to_facet(new_facet)[1] = ElementNull;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
   return nb_facets_to_double;
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::resetFacetToDouble(Mesh & mesh_facets) {
   AKANTU_DEBUG_IN();
 
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
     GhostType gt = (GhostType)g;
 
     Mesh::type_iterator it = mesh_facets.firstType(_all_dimensions, gt);
     Mesh::type_iterator end = mesh_facets.lastType(_all_dimensions, gt);
     for (; it != end; ++it) {
       ElementType type = *it;
       mesh_facets.getDataPointer<UInt>("facet_to_double", type, gt, 1, false);
 
       mesh_facets.getDataPointer<std::vector<Element>>(
           "facets_to_subfacet_double", type, gt, 1, false);
 
       mesh_facets.getDataPointer<std::vector<Element>>(
           "elements_to_subfacet_double", type, gt, 1, false);
 
       mesh_facets.getDataPointer<std::vector<Element>>(
           "subfacets_to_subsubfacet_double", type, gt, 1, false);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool subsubfacet_mode>
 void MeshUtils::findSubfacetToDouble(Mesh & mesh, Mesh & mesh_facets) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh_facets.getSpatialDimension();
   if (spatial_dimension == 1)
     return;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
-      UInt nb_facet_to_double = f_to_double.getSize();
+      UInt nb_facet_to_double = f_to_double.size();
       if (nb_facet_to_double == 0)
         continue;
 
       ElementType type_subfacet = Mesh::getFacetType(type_facet);
       GhostType gt_subfacet = _casper;
 
       ElementType type_subsubfacet = Mesh::getFacetType(type_subfacet);
       GhostType gt_subsubfacet = _casper;
 
       Array<UInt> * conn_subfacet = NULL;
       Array<UInt> * sf_to_double = NULL;
       Array<std::vector<Element>> * sf_to_subfacet_double = NULL;
       Array<std::vector<Element>> * f_to_subfacet_double = NULL;
       Array<std::vector<Element>> * el_to_subfacet_double = NULL;
 
       UInt nb_subfacet = Mesh::getNbFacetsPerElement(type_facet);
 
       UInt nb_subsubfacet;
       UInt nb_nodes_per_sf_el;
 
       if (subsubfacet_mode) {
         nb_nodes_per_sf_el = Mesh::getNbNodesPerElement(type_subsubfacet);
         nb_subsubfacet = Mesh::getNbFacetsPerElement(type_subfacet);
       } else
         nb_nodes_per_sf_el = Mesh::getNbNodesPerElement(type_subfacet);
 
       Array<Element> & subfacet_to_facet =
           mesh_facets.getSubelementToElement(type_facet, gt_facet);
 
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
       Array<Element> * subsubfacet_to_subfacet = NULL;
 
-      UInt old_nb_facet = subfacet_to_facet.getSize() - nb_facet_to_double;
+      UInt old_nb_facet = subfacet_to_facet.size() - nb_facet_to_double;
 
       Element current_facet(type_facet, 0, gt_facet);
       std::vector<Element> element_list;
       std::vector<Element> facet_list;
       std::vector<Element> * subfacet_list;
       if (subsubfacet_mode)
         subfacet_list = new std::vector<Element>;
 
       /// map to filter subfacets
       Array<std::vector<Element>> * facet_to_subfacet = NULL;
 
       /// this is used to make sure that both new and old facets are
       /// checked
       UInt facets[2];
 
       /// loop on every facet
       for (UInt f_index = 0; f_index < 2; ++f_index) {
         for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
           facets[bool(f_index)] = f_to_double(facet);
           facets[!bool(f_index)] = old_nb_facet + facet;
 
           UInt old_facet = facets[0];
           UInt new_facet = facets[1];
 
           Element & starting_element = element_to_facet(new_facet)[0];
           current_facet.element = old_facet;
 
           /// loop on every subfacet
           for (UInt sf = 0; sf < nb_subfacet; ++sf) {
 
             Element & subfacet = subfacet_to_facet(old_facet, sf);
             if (subfacet == ElementNull)
               continue;
 
             if (gt_subfacet != subfacet.ghost_type) {
               gt_subfacet = subfacet.ghost_type;
 
               if (subsubfacet_mode) {
                 subsubfacet_to_subfacet = &mesh_facets.getSubelementToElement(
                     type_subfacet, gt_subfacet);
               } else {
                 conn_subfacet =
                     &mesh_facets.getConnectivity(type_subfacet, gt_subfacet);
                 sf_to_double = &mesh_facets.getData<UInt>(
                     "facet_to_double", type_subfacet, gt_subfacet);
 
                 f_to_subfacet_double =
                     &mesh_facets.getData<std::vector<Element>>(
                         "facets_to_subfacet_double", type_subfacet,
                         gt_subfacet);
 
                 el_to_subfacet_double =
                     &mesh_facets.getData<std::vector<Element>>(
                         "elements_to_subfacet_double", type_subfacet,
                         gt_subfacet);
 
                 facet_to_subfacet = &mesh_facets.getElementToSubelement(
                     type_subfacet, gt_subfacet);
               }
             }
 
             if (subsubfacet_mode) {
               /// loop on every subsubfacet
               for (UInt ssf = 0; ssf < nb_subsubfacet; ++ssf) {
                 Element & subsubfacet =
                     (*subsubfacet_to_subfacet)(subfacet.element, ssf);
 
                 if (subsubfacet == ElementNull)
                   continue;
 
                 if (gt_subsubfacet != subsubfacet.ghost_type) {
                   gt_subsubfacet = subsubfacet.ghost_type;
                   conn_subfacet = &mesh_facets.getConnectivity(type_subsubfacet,
                                                                gt_subsubfacet);
                   sf_to_double = &mesh_facets.getData<UInt>(
                       "facet_to_double", type_subsubfacet, gt_subsubfacet);
 
                   sf_to_subfacet_double =
                       &mesh_facets.getData<std::vector<Element>>(
                           "subfacets_to_subsubfacet_double", type_subsubfacet,
                           gt_subsubfacet);
 
                   f_to_subfacet_double =
                       &mesh_facets.getData<std::vector<Element>>(
                           "facets_to_subfacet_double", type_subsubfacet,
                           gt_subsubfacet);
 
                   el_to_subfacet_double =
                       &mesh_facets.getData<std::vector<Element>>(
                           "elements_to_subfacet_double", type_subsubfacet,
                           gt_subsubfacet);
 
                   facet_to_subfacet = &mesh_facets.getElementToSubelement(
                       type_subsubfacet, gt_subsubfacet);
                 }
 
                 UInt global_ssf = subsubfacet.element;
 
                 Vector<UInt> subsubfacet_connectivity(
                     conn_subfacet->storage() + global_ssf * nb_nodes_per_sf_el,
                     nb_nodes_per_sf_el);
 
                 /// check if subsubfacet is to be doubled
                 if (findElementsAroundSubfacet<true>(
                         mesh, mesh_facets, starting_element, current_facet,
                         subsubfacet_connectivity, element_list, facet_list,
                         subfacet_list) == false &&
                     removeElementsInVector(*subfacet_list,
                                            (*facet_to_subfacet)(global_ssf)) ==
                         false) {
 
                   sf_to_double->push_back(global_ssf);
                   sf_to_subfacet_double->push_back(*subfacet_list);
                   f_to_subfacet_double->push_back(facet_list);
                   el_to_subfacet_double->push_back(element_list);
                 }
               }
             } else {
               const UInt global_sf = subfacet.element;
 
               Vector<UInt> subfacet_connectivity(
                   conn_subfacet->storage() + global_sf * nb_nodes_per_sf_el,
                   nb_nodes_per_sf_el);
 
               /// check if subfacet is to be doubled
               if (findElementsAroundSubfacet<false>(
                       mesh, mesh_facets, starting_element, current_facet,
                       subfacet_connectivity, element_list,
                       facet_list) == false &&
                   removeElementsInVector(
                       facet_list, (*facet_to_subfacet)(global_sf)) == false) {
 
                 sf_to_double->push_back(global_sf);
                 f_to_subfacet_double->push_back(facet_list);
                 el_to_subfacet_double->push_back(element_list);
               }
             }
           }
         }
       }
 
       if (subsubfacet_mode)
         delete subfacet_list;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_COHESIVE_ELEMENT)
 void MeshUtils::updateCohesiveData(Mesh & mesh, Mesh & mesh_facets,
                                    Array<Element> & new_elements) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   bool third_dimension = spatial_dimension == 3;
 
   MeshAccessor mesh_facets_accessor(mesh_facets);
 
   for (auto gt_facet : ghost_types) {
     for (auto type_facet :
          mesh_facets.elementTypes(spatial_dimension - 1, gt_facet)) {
 
       Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
 
-      UInt nb_facet_to_double = f_to_double.getSize();
+      UInt nb_facet_to_double = f_to_double.size();
       if (nb_facet_to_double == 0)
         continue;
 
       ElementType type_cohesive = FEEngine::getCohesiveElementType(type_facet);
 
       auto & facet_to_coh_element =
           mesh_facets_accessor.getSubelementToElement(type_cohesive, gt_facet);
 
       auto & conn_facet = mesh_facets.getConnectivity(type_facet, gt_facet);
       auto & conn_cohesive = mesh.getConnectivity(type_cohesive, gt_facet);
       UInt nb_nodes_per_facet = Mesh::getNbNodesPerElement(type_facet);
 
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
-      UInt old_nb_cohesive_elements = conn_cohesive.getSize();
+      UInt old_nb_cohesive_elements = conn_cohesive.size();
       UInt new_nb_cohesive_elements =
-          conn_cohesive.getSize() + nb_facet_to_double;
+          conn_cohesive.size() + nb_facet_to_double;
 
-      UInt old_nb_facet = element_to_facet.getSize() - nb_facet_to_double;
+      UInt old_nb_facet = element_to_facet.size() - nb_facet_to_double;
       facet_to_coh_element.resize(new_nb_cohesive_elements);
       conn_cohesive.resize(new_nb_cohesive_elements);
 
-      UInt new_elements_old_size = new_elements.getSize();
+      UInt new_elements_old_size = new_elements.size();
       new_elements.resize(new_elements_old_size + nb_facet_to_double);
 
       Element c_element(type_cohesive, 0, gt_facet, _ek_cohesive);
       Element f_element(type_facet, 0, gt_facet);
 
       UInt facets[2];
 
       for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
 
         /// (in 3D cohesive elements connectivity is inverted)
         facets[third_dimension] = f_to_double(facet);
         facets[!third_dimension] = old_nb_facet + facet;
 
         UInt cohesive_element = old_nb_cohesive_elements + facet;
 
         /// store doubled facets
         f_element.element = facets[0];
         facet_to_coh_element(cohesive_element, 0) = f_element;
         f_element.element = facets[1];
         facet_to_coh_element(cohesive_element, 1) = f_element;
 
         /// modify cohesive elements' connectivity
         for (UInt n = 0; n < nb_nodes_per_facet; ++n) {
           conn_cohesive(cohesive_element, n) = conn_facet(facets[0], n);
           conn_cohesive(cohesive_element, n + nb_nodes_per_facet) =
               conn_facet(facets[1], n);
         }
 
         /// update element_to_facet vectors
         c_element.element = cohesive_element;
         element_to_facet(facets[0])[1] = c_element;
         element_to_facet(facets[1])[1] = c_element;
 
         /// add cohesive element to the element event list
         new_elements(new_elements_old_size + facet) = c_element;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::doublePointFacet(Mesh & mesh, Mesh & mesh_facets,
                                  Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   if (spatial_dimension != 1)
     return;
 
   Array<Real> & position = mesh.getNodes();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_facet = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(spatial_dimension - 1, gt_facet);
     Mesh::type_iterator end =
         mesh_facets.lastType(spatial_dimension - 1, gt_facet);
 
     for (; it != end; ++it) {
 
       ElementType type_facet = *it;
 
       Array<UInt> & conn_facet =
           mesh_facets.getConnectivity(type_facet, gt_facet);
       Array<std::vector<Element>> & element_to_facet =
           mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
       const Array<UInt> & f_to_double =
           mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
 
-      UInt nb_facet_to_double = f_to_double.getSize();
+      UInt nb_facet_to_double = f_to_double.size();
 
-      UInt old_nb_facet = element_to_facet.getSize() - nb_facet_to_double;
-      UInt new_nb_facet = element_to_facet.getSize();
+      UInt old_nb_facet = element_to_facet.size() - nb_facet_to_double;
+      UInt new_nb_facet = element_to_facet.size();
 
-      UInt old_nb_nodes = position.getSize();
+      UInt old_nb_nodes = position.size();
       UInt new_nb_nodes = old_nb_nodes + nb_facet_to_double;
 
       position.resize(new_nb_nodes);
       conn_facet.resize(new_nb_facet);
 
-      UInt old_nb_doubled_nodes = doubled_nodes.getSize();
+      UInt old_nb_doubled_nodes = doubled_nodes.size();
       doubled_nodes.resize(old_nb_doubled_nodes + nb_facet_to_double);
 
       for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
         UInt old_facet = f_to_double(facet);
         UInt new_facet = old_nb_facet + facet;
 
         ElementType type = element_to_facet(new_facet)[0].type;
         UInt el = element_to_facet(new_facet)[0].element;
         GhostType gt = element_to_facet(new_facet)[0].ghost_type;
 
         UInt old_node = conn_facet(old_facet);
         UInt new_node = old_nb_nodes + facet;
 
         /// update position
         position(new_node) = position(old_node);
 
         conn_facet(new_facet) = new_node;
         Array<UInt> & conn_segment = mesh.getConnectivity(type, gt);
         UInt nb_nodes_per_segment = conn_segment.getNbComponent();
 
         /// update facet connectivity
         UInt i;
         for (i = 0;
              conn_segment(el, i) != old_node && i <= nb_nodes_per_segment; ++i)
           ;
         conn_segment(el, i) = new_node;
 
         doubled_nodes(old_nb_doubled_nodes + facet, 0) = old_node;
         doubled_nodes(old_nb_doubled_nodes + facet, 1) = new_node;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool third_dim_segments>
 void MeshUtils::updateQuadraticSegments(Mesh & mesh, Mesh & mesh_facets,
                                         ElementType type_facet,
                                         GhostType gt_facet,
                                         Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   if (type_facet != _segment_3)
     return;
 
   Array<UInt> & f_to_double =
       mesh_facets.getData<UInt>("facet_to_double", type_facet, gt_facet);
-  UInt nb_facet_to_double = f_to_double.getSize();
+  UInt nb_facet_to_double = f_to_double.size();
 
   UInt old_nb_facet =
       mesh_facets.getNbElement(type_facet, gt_facet) - nb_facet_to_double;
 
   Array<UInt> & conn_facet = mesh_facets.getConnectivity(type_facet, gt_facet);
 
   Array<std::vector<Element>> & element_to_facet =
       mesh_facets.getElementToSubelement(type_facet, gt_facet);
 
   /// this ones matter only for segments in 3D
   Array<std::vector<Element>> * el_to_subfacet_double = NULL;
   Array<std::vector<Element>> * f_to_subfacet_double = NULL;
 
   if (third_dim_segments) {
     el_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "elements_to_subfacet_double", type_facet, gt_facet);
 
     f_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "facets_to_subfacet_double", type_facet, gt_facet);
   }
 
   std::vector<UInt> middle_nodes;
 
   for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
     UInt old_facet = f_to_double(facet);
     UInt node = conn_facet(old_facet, 2);
     if (!mesh.isPureGhostNode(node))
       middle_nodes.push_back(node);
   }
 
-  UInt n = doubled_nodes.getSize();
+  UInt n = doubled_nodes.size();
 
   doubleNodes(mesh, middle_nodes, doubled_nodes);
 
   for (UInt facet = 0; facet < nb_facet_to_double; ++facet) {
     UInt old_facet = f_to_double(facet);
     UInt old_node = conn_facet(old_facet, 2);
     if (mesh.isPureGhostNode(old_node))
       continue;
 
     UInt new_node = doubled_nodes(n, 1);
     UInt new_facet = old_nb_facet + facet;
 
     conn_facet(new_facet, 2) = new_node;
 
     if (third_dim_segments) {
       updateElementalConnectivity(mesh_facets, old_node, new_node,
                                   element_to_facet(new_facet));
 
       updateElementalConnectivity(mesh, old_node, new_node,
                                   (*el_to_subfacet_double)(facet),
                                   &(*f_to_subfacet_double)(facet));
     } else {
       updateElementalConnectivity(mesh, old_node, new_node,
                                   element_to_facet(new_facet));
     }
     ++n;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::updateSubfacetToFacet(Mesh & mesh_facets,
                                       ElementType type_subfacet,
                                       GhostType gt_subfacet, bool facet_mode) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & sf_to_double =
       mesh_facets.getData<UInt>("facet_to_double", type_subfacet, gt_subfacet);
-  UInt nb_subfacet_to_double = sf_to_double.getSize();
+  UInt nb_subfacet_to_double = sf_to_double.size();
 
   /// update subfacet_to_facet vector
   ElementType type_facet = _not_defined;
   GhostType gt_facet = _casper;
   Array<Element> * subfacet_to_facet = NULL;
   UInt nb_subfacet_per_facet = 0;
   UInt old_nb_subfacet = mesh_facets.getNbElement(type_subfacet, gt_subfacet) -
                          nb_subfacet_to_double;
 
   Array<std::vector<Element>> * facet_list = NULL;
   if (facet_mode)
     facet_list = &mesh_facets.getData<std::vector<Element>>(
         "facets_to_subfacet_double", type_subfacet, gt_subfacet);
   else
     facet_list = &mesh_facets.getData<std::vector<Element>>(
         "subfacets_to_subsubfacet_double", type_subfacet, gt_subfacet);
 
   Element old_subfacet_el(type_subfacet, 0, gt_subfacet);
   Element new_subfacet_el(type_subfacet, 0, gt_subfacet);
 
   for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
     old_subfacet_el.element = sf_to_double(sf);
     new_subfacet_el.element = old_nb_subfacet + sf;
 
     for (UInt f = 0; f < (*facet_list)(sf).size(); ++f) {
       Element & facet = (*facet_list)(sf)[f];
 
       if (facet.type != type_facet || facet.ghost_type != gt_facet) {
         type_facet = facet.type;
         gt_facet = facet.ghost_type;
 
         subfacet_to_facet =
             &mesh_facets.getSubelementToElement(type_facet, gt_facet);
         nb_subfacet_per_facet = subfacet_to_facet->getNbComponent();
       }
 
       Element * sf_update = std::find(
           subfacet_to_facet->storage() + facet.element * nb_subfacet_per_facet,
           subfacet_to_facet->storage() + facet.element * nb_subfacet_per_facet +
               nb_subfacet_per_facet,
           old_subfacet_el);
 
       AKANTU_DEBUG_ASSERT(subfacet_to_facet->storage() +
                                   facet.element * nb_subfacet_per_facet !=
                               subfacet_to_facet->storage() +
                                   facet.element * nb_subfacet_per_facet +
                                   nb_subfacet_per_facet,
                           "Subfacet not found");
 
       *sf_update = new_subfacet_el;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::updateFacetToSubfacet(Mesh & mesh_facets,
                                       ElementType type_subfacet,
                                       GhostType gt_subfacet, bool facet_mode) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & sf_to_double =
       mesh_facets.getData<UInt>("facet_to_double", type_subfacet, gt_subfacet);
-  UInt nb_subfacet_to_double = sf_to_double.getSize();
+  UInt nb_subfacet_to_double = sf_to_double.size();
 
   Array<std::vector<Element>> & facet_to_subfacet =
       mesh_facets.getElementToSubelement(type_subfacet, gt_subfacet);
 
   Array<std::vector<Element>> * facet_to_subfacet_double = NULL;
 
   if (facet_mode) {
     facet_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "facets_to_subfacet_double", type_subfacet, gt_subfacet);
   } else {
     facet_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
         "subfacets_to_subsubfacet_double", type_subfacet, gt_subfacet);
   }
 
-  UInt old_nb_subfacet = facet_to_subfacet.getSize();
+  UInt old_nb_subfacet = facet_to_subfacet.size();
   facet_to_subfacet.resize(old_nb_subfacet + nb_subfacet_to_double);
 
   for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf)
     facet_to_subfacet(old_nb_subfacet + sf) = (*facet_to_subfacet_double)(sf);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MeshUtils::doubleSubfacet(Mesh & mesh, Mesh & mesh_facets,
                                Array<UInt> & doubled_nodes) {
   AKANTU_DEBUG_IN();
 
   if (spatial_dimension == 1)
     return;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType gt_subfacet = *gt;
 
     Mesh::type_iterator it = mesh_facets.firstType(0, gt_subfacet);
     Mesh::type_iterator end = mesh_facets.lastType(0, gt_subfacet);
 
     for (; it != end; ++it) {
 
       ElementType type_subfacet = *it;
 
       Array<UInt> & sf_to_double = mesh_facets.getData<UInt>(
           "facet_to_double", type_subfacet, gt_subfacet);
-      UInt nb_subfacet_to_double = sf_to_double.getSize();
+      UInt nb_subfacet_to_double = sf_to_double.size();
 
       if (nb_subfacet_to_double == 0)
         continue;
 
       AKANTU_DEBUG_ASSERT(
           type_subfacet == _point_1,
           "Only _point_1 subfacet doubling is supported at the moment");
 
       Array<UInt> & conn_subfacet =
           mesh_facets.getConnectivity(type_subfacet, gt_subfacet);
 
-      UInt old_nb_subfacet = conn_subfacet.getSize();
+      UInt old_nb_subfacet = conn_subfacet.size();
       UInt new_nb_subfacet = old_nb_subfacet + nb_subfacet_to_double;
 
       conn_subfacet.resize(new_nb_subfacet);
 
       std::vector<UInt> nodes_to_double;
-      UInt old_nb_doubled_nodes = doubled_nodes.getSize();
+      UInt old_nb_doubled_nodes = doubled_nodes.size();
 
       /// double nodes
       for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
         UInt old_subfacet = sf_to_double(sf);
         nodes_to_double.push_back(conn_subfacet(old_subfacet));
       }
 
       doubleNodes(mesh, nodes_to_double, doubled_nodes);
 
       /// add new nodes in connectivity
       for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
         UInt new_subfacet = old_nb_subfacet + sf;
         UInt new_node = doubled_nodes(old_nb_doubled_nodes + sf, 1);
 
         conn_subfacet(new_subfacet) = new_node;
       }
 
       /// update facet and element connectivity
       Array<std::vector<Element>> & f_to_subfacet_double =
           mesh_facets.getData<std::vector<Element>>("facets_to_subfacet_double",
                                                     type_subfacet, gt_subfacet);
 
       Array<std::vector<Element>> & el_to_subfacet_double =
           mesh_facets.getData<std::vector<Element>>(
               "elements_to_subfacet_double", type_subfacet, gt_subfacet);
 
       Array<std::vector<Element>> * sf_to_subfacet_double = NULL;
 
       if (spatial_dimension == 3)
         sf_to_subfacet_double = &mesh_facets.getData<std::vector<Element>>(
             "subfacets_to_subsubfacet_double", type_subfacet, gt_subfacet);
 
       for (UInt sf = 0; sf < nb_subfacet_to_double; ++sf) {
         UInt old_node = doubled_nodes(old_nb_doubled_nodes + sf, 0);
         UInt new_node = doubled_nodes(old_nb_doubled_nodes + sf, 1);
 
         updateElementalConnectivity(mesh, old_node, new_node,
                                     el_to_subfacet_double(sf),
                                     &f_to_subfacet_double(sf));
 
         updateElementalConnectivity(mesh_facets, old_node, new_node,
                                     f_to_subfacet_double(sf));
 
         if (spatial_dimension == 3)
           updateElementalConnectivity(mesh_facets, old_node, new_node,
                                       (*sf_to_subfacet_double)(sf));
       }
 
       if (spatial_dimension == 2) {
         updateSubfacetToFacet(mesh_facets, type_subfacet, gt_subfacet, true);
         updateFacetToSubfacet(mesh_facets, type_subfacet, gt_subfacet, true);
       } else if (spatial_dimension == 3) {
         updateSubfacetToFacet(mesh_facets, type_subfacet, gt_subfacet, false);
         updateFacetToSubfacet(mesh_facets, type_subfacet, gt_subfacet, false);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::flipFacets(
     Mesh & mesh_facets, const ElementTypeMapArray<UInt> & global_connectivity,
     GhostType gt_facet) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh_facets.getSpatialDimension();
 
   /// get global connectivity for local mesh
   ElementTypeMapArray<UInt> global_connectivity_tmp("global_connectivity_tmp",
                                                     mesh_facets.getID(),
                                                     mesh_facets.getMemoryID());
 
   global_connectivity_tmp.initialize(
       mesh_facets, _spatial_dimension = spatial_dimension - 1,
       _with_nb_nodes_per_element = true, _with_nb_element = true);
   // mesh_facets.initElementTypeMapArray(global_connectivity_tmp, 1,
   //                                     spatial_dimension - 1, gt_facet,
   //                                     true, _ek_regular, true);
 
   mesh_facets.getGlobalConnectivity(global_connectivity_tmp,
                                     spatial_dimension - 1, gt_facet);
 
   /// loop on every facet
   for (auto type_facet :
        mesh_facets.elementTypes(spatial_dimension - 1, gt_facet)) {
 
     auto & connectivity = mesh_facets.getConnectivity(type_facet, gt_facet);
     const auto & g_connectivity = global_connectivity(type_facet, gt_facet);
 
     auto & el_to_f = mesh_facets.getElementToSubelement(type_facet, gt_facet);
     auto & subfacet_to_facet =
         mesh_facets.getSubelementToElement(type_facet, gt_facet);
 
     UInt nb_subfacet_per_facet = subfacet_to_facet.getNbComponent();
     UInt nb_nodes_per_facet = connectivity.getNbComponent();
-    UInt nb_facet = connectivity.getSize();
+    UInt nb_facet = connectivity.size();
 
     UInt nb_nodes_per_P1_facet =
         Mesh::getNbNodesPerElement(Mesh::getP1ElementType(type_facet));
 
     auto & global_conn_tmp = global_connectivity_tmp(type_facet, gt_facet);
 
     auto conn_it = connectivity.begin(nb_nodes_per_facet);
     auto gconn_tmp_it = global_conn_tmp.begin(nb_nodes_per_facet);
     auto conn_glob_it = g_connectivity.begin(nb_nodes_per_facet);
     auto subf_to_f = subfacet_to_facet.begin(nb_subfacet_per_facet);
 
     UInt * conn_tmp_pointer = new UInt[nb_nodes_per_facet];
     Vector<UInt> conn_tmp(conn_tmp_pointer, nb_nodes_per_facet);
 
     Element el_tmp;
     Element * subf_tmp_pointer = new Element[nb_subfacet_per_facet];
     Vector<Element> subf_tmp(subf_tmp_pointer, nb_subfacet_per_facet);
 
     for (UInt f = 0; f < nb_facet;
          ++f, ++conn_it, ++gconn_tmp_it, ++subf_to_f, ++conn_glob_it) {
 
       Vector<UInt> & gconn_tmp = *gconn_tmp_it;
       const Vector<UInt> & conn_glob = *conn_glob_it;
       Vector<UInt> & conn_local = *conn_it;
 
       /// skip facet if connectivities are the same
       if (gconn_tmp == conn_glob)
         continue;
 
       /// re-arrange connectivity
       conn_tmp = conn_local;
 
       UInt * begin = conn_glob.storage();
       UInt * end = conn_glob.storage() + nb_nodes_per_facet;
 
       for (UInt n = 0; n < nb_nodes_per_facet; ++n) {
 
         UInt * new_node = std::find(begin, end, gconn_tmp(n));
         AKANTU_DEBUG_ASSERT(new_node != end, "Node not found");
 
         UInt new_position = new_node - begin;
 
         conn_local(new_position) = conn_tmp(n);
       }
 
       /// if 3D, check if facets are just rotated
       if (spatial_dimension == 3) {
         /// find first node
         UInt * new_node = std::find(begin, end, gconn_tmp(0));
         AKANTU_DEBUG_ASSERT(new_node != end, "Node not found");
 
         UInt new_position = new_node - begin;
         UInt n = 1;
 
         /// count how many nodes in the received connectivity follow
         /// the same order of those in the local connectivity
         for (; n < nb_nodes_per_P1_facet &&
                gconn_tmp(n) ==
                    conn_glob((new_position + n) % nb_nodes_per_P1_facet);
              ++n)
           ;
 
         /// skip the facet inversion if facet is just rotated
         if (n == nb_nodes_per_P1_facet)
           continue;
       }
 
       /// update data to invert facet
       el_tmp = el_to_f(f)[0];
       el_to_f(f)[0] = el_to_f(f)[1];
       el_to_f(f)[1] = el_tmp;
 
       subf_tmp = (*subf_to_f);
       (*subf_to_f)(0) = subf_tmp(1);
       (*subf_to_f)(1) = subf_tmp(0);
     }
 
     delete[] subf_tmp_pointer;
     delete[] conn_tmp_pointer;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::fillElementToSubElementsData(Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   if (mesh.getNbElement(mesh.getSpatialDimension() - 1) == 0) {
     AKANTU_DEBUG_INFO("There are not facets, add them in the mesh file or call "
                       "the buildFacet method.");
     return;
   }
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   ElementTypeMapArray<Real> barycenters("barycenter_tmp", mesh.getID(),
                                         mesh.getMemoryID());
   barycenters.initialize(mesh, _nb_component = spatial_dimension,
                          _spatial_dimension = _all_dimensions);
   // mesh.initElementTypeMapArray(barycenters, spatial_dimension,
   // _all_dimensions);
 
   Element element;
   for (auto ghost_type : ghost_types) {
     element.ghost_type = ghost_type;
     for (auto & type : mesh.elementTypes(_all_dimensions, ghost_type)) {
       element.type = type;
 
       UInt nb_element = mesh.getNbElement(type, ghost_type);
       Array<Real> & barycenters_arr = barycenters(type, ghost_type);
       barycenters_arr.resize(nb_element);
       auto bary = barycenters_arr.begin(spatial_dimension);
       auto bary_end = barycenters_arr.end(spatial_dimension);
 
       for (UInt el = 0; bary != bary_end; ++bary, ++el) {
         element.element = el;
         mesh.getBarycenter(element, *bary);
       }
     }
   }
 
   MeshAccessor mesh_accessor(mesh);
   for (Int sp(spatial_dimension); sp >= 1; --sp) {
     if (mesh.getNbElement(sp) == 0)
       continue;
 
     for (auto ghost_type : ghost_types) {
       for (auto & type : mesh.elementTypes(sp, ghost_type)) {
         mesh_accessor.getSubelementToElement(type, ghost_type)
             .resize(mesh.getNbElement(type, ghost_type));
         mesh_accessor.getSubelementToElement(type, ghost_type).clear();
       }
 
       for (auto & type : mesh.elementTypes(sp - 1, ghost_type)) {
         mesh_accessor.getElementToSubelement(type, ghost_type)
             .resize(mesh.getNbElement(type, ghost_type));
         mesh.getElementToSubelement(type, ghost_type).clear();
       }
     }
 
     CSR<Element> nodes_to_elements;
     buildNode2Elements(mesh, nodes_to_elements, sp);
 
     Element facet_element;
 
     for (auto ghost_type : ghost_types) {
       facet_element.ghost_type = ghost_type;
       for (auto & type : mesh.elementTypes(sp - 1, ghost_type)) {
         facet_element.type = type;
 
         auto & element_to_subelement =
             mesh.getElementToSubelement(type, ghost_type);
 
         const auto & connectivity = mesh.getConnectivity(type, ghost_type);
 
         auto fit = connectivity.begin(mesh.getNbNodesPerElement(type));
         auto fend = connectivity.end(mesh.getNbNodesPerElement(type));
 
         UInt fid = 0;
         for (; fit != fend; ++fit, ++fid) {
           const Vector<UInt> & facet = *fit;
           facet_element.element = fid;
           std::map<Element, UInt> element_seen_counter;
           UInt nb_nodes_per_facet =
               mesh.getNbNodesPerElement(Mesh::getP1ElementType(type));
 
           for (UInt n(0); n < nb_nodes_per_facet; ++n) {
 
             auto eit = nodes_to_elements.begin(facet(n));
             auto eend = nodes_to_elements.end(facet(n));
             for (; eit != eend; ++eit) {
               auto & elem = *eit;
               auto cit = element_seen_counter.find(elem);
               if (cit != element_seen_counter.end()) {
                 cit->second++;
               } else {
                 element_seen_counter[elem] = 1;
               }
             }
           }
 
           std::vector<Element> connected_elements;
           auto cit = element_seen_counter.begin();
           auto cend = element_seen_counter.end();
           for (; cit != cend; ++cit) {
             if (cit->second == nb_nodes_per_facet)
               connected_elements.push_back(cit->first);
           }
 
           auto ceit = connected_elements.begin();
           auto ceend = connected_elements.end();
           for (; ceit != ceend; ++ceit)
             element_to_subelement(fid).push_back(*ceit);
 
           for (UInt ce = 0; ce < connected_elements.size(); ++ce) {
             Element & elem = connected_elements[ce];
             Array<Element> & subelement_to_element =
                 mesh_accessor.getSubelementToElement(elem.type,
                                                      elem.ghost_type);
 
             UInt f(0);
             for (; f < mesh.getNbFacetsPerElement(elem.type) &&
                    subelement_to_element(elem.element, f) != ElementNull;
                  ++f)
               ;
 
             AKANTU_DEBUG_ASSERT(
                 f < mesh.getNbFacetsPerElement(elem.type),
                 "The element " << elem << " seems to have too many facets!! ("
                                << f << " < "
                                << mesh.getNbFacetsPerElement(elem.type) << ")");
 
             subelement_to_element(elem.element, f) = facet_element;
           }
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool third_dim_points>
 bool MeshUtils::findElementsAroundSubfacet(
     const Mesh & mesh, const Mesh & mesh_facets,
     const Element & starting_element, const Element & end_facet,
     const Vector<UInt> & subfacet_connectivity,
     std::vector<Element> & elem_list, std::vector<Element> & facet_list,
     std::vector<Element> * subfacet_list) {
   AKANTU_DEBUG_IN();
 
   /// preallocated stuff before starting
   bool facet_matched = false;
 
   elem_list.clear();
   facet_list.clear();
 
   if (third_dim_points)
     subfacet_list->clear();
 
   elem_list.push_back(starting_element);
 
   const Array<UInt> * facet_connectivity = NULL;
   const Array<UInt> * sf_connectivity = NULL;
   const Array<Element> * facet_to_element = NULL;
   const Array<Element> * subfacet_to_facet = NULL;
 
   ElementType current_type = _not_defined;
   GhostType current_ghost_type = _casper;
 
   ElementType current_facet_type = _not_defined;
   GhostType current_facet_ghost_type = _casper;
 
   ElementType current_subfacet_type = _not_defined;
   GhostType current_subfacet_ghost_type = _casper;
 
   const Array<std::vector<Element>> * element_to_facet = NULL;
 
   const Element * opposing_el = NULL;
 
   std::queue<Element> elements_to_check;
   elements_to_check.push(starting_element);
 
   /// keep going until there are elements to check
   while (!elements_to_check.empty()) {
 
     /// check current element
     Element & current_el = elements_to_check.front();
 
     if (current_el.type != current_type ||
         current_el.ghost_type != current_ghost_type) {
 
       current_type = current_el.type;
       current_ghost_type = current_el.ghost_type;
 
       facet_to_element =
           &mesh_facets.getSubelementToElement(current_type, current_ghost_type);
     }
 
     /// loop over each facet of the element
     for (UInt f = 0; f < facet_to_element->getNbComponent(); ++f) {
 
       const Element & current_facet =
           (*facet_to_element)(current_el.element, f);
 
       if (current_facet == ElementNull)
         continue;
 
       if (current_facet_type != current_facet.type ||
           current_facet_ghost_type != current_facet.ghost_type) {
 
         current_facet_type = current_facet.type;
         current_facet_ghost_type = current_facet.ghost_type;
 
         element_to_facet = &mesh_facets.getElementToSubelement(
             current_facet_type, current_facet_ghost_type);
         facet_connectivity = &mesh_facets.getConnectivity(
             current_facet_type, current_facet_ghost_type);
 
         if (third_dim_points)
           subfacet_to_facet = &mesh_facets.getSubelementToElement(
               current_facet_type, current_facet_ghost_type);
       }
 
       /// check if end facet is reached
       if (current_facet == end_facet)
         facet_matched = true;
 
       /// add this facet if not already passed
       if (std::find(facet_list.begin(), facet_list.end(), current_facet) ==
               facet_list.end() &&
           hasElement(*facet_connectivity, current_facet,
                      subfacet_connectivity)) {
         facet_list.push_back(current_facet);
 
         if (third_dim_points) {
           /// check subfacets
           for (UInt sf = 0; sf < subfacet_to_facet->getNbComponent(); ++sf) {
             const Element & current_subfacet =
                 (*subfacet_to_facet)(current_facet.element, sf);
 
             if (current_subfacet == ElementNull)
               continue;
 
             if (current_subfacet_type != current_subfacet.type ||
                 current_subfacet_ghost_type != current_subfacet.ghost_type) {
               current_subfacet_type = current_subfacet.type;
               current_subfacet_ghost_type = current_subfacet.ghost_type;
 
               sf_connectivity = &mesh_facets.getConnectivity(
                   current_subfacet_type, current_subfacet_ghost_type);
             }
 
             if (std::find(subfacet_list->begin(), subfacet_list->end(),
                           current_subfacet) == subfacet_list->end() &&
                 hasElement(*sf_connectivity, current_subfacet,
                            subfacet_connectivity))
               subfacet_list->push_back(current_subfacet);
           }
         }
       } else
         continue;
 
       /// consider opposing element
       if ((*element_to_facet)(current_facet.element)[0] == current_el)
         opposing_el = &(*element_to_facet)(current_facet.element)[1];
       else
         opposing_el = &(*element_to_facet)(current_facet.element)[0];
 
       /// skip null elements since they are on a boundary
       if (*opposing_el == ElementNull)
         continue;
 
       /// skip this element if already added
       if (std::find(elem_list.begin(), elem_list.end(), *opposing_el) !=
           elem_list.end())
         continue;
 
       /// only regular elements have to be checked
       if (opposing_el->kind == _ek_regular)
         elements_to_check.push(*opposing_el);
 
       elem_list.push_back(*opposing_el);
 
 #ifndef AKANTU_NDEBUG
       const Array<UInt> & conn_elem =
           mesh.getConnectivity(opposing_el->type, opposing_el->ghost_type);
 
       AKANTU_DEBUG_ASSERT(
           hasElement(conn_elem, *opposing_el, subfacet_connectivity),
           "Subfacet doesn't belong to this element");
 #endif
     }
 
     /// erased checked element from the list
     elements_to_check.pop();
   }
 
   AKANTU_DEBUG_OUT();
   return facet_matched;
 }
 
 /* -------------------------------------------------------------------------- */
 // void MeshUtils::buildSegmentToNodeType(const Mesh & mesh, Mesh & mesh_facets) {
 //   buildAllFacets(mesh, mesh_facets, 1);
 
 //   UInt spatial_dimension = mesh.getSpatialDimension();
 
 //   const ElementTypeMapArray<UInt> & element_to_rank =
 //       mesh.getElementSynchronizer().getPrankToElement();
 //   Int local_rank = StaticCommunicator::getStaticCommunicator().whoAmI();
 
 //   for (ghost_type_t::iterator gt = ghost_type_t::begin();
 //        gt != ghost_type_t::end(); ++gt) {
 //     GhostType ghost_type = *gt;
 //     Mesh::type_iterator it = mesh_facets.firstType(1, ghost_type);
 //     Mesh::type_iterator end = mesh_facets.lastType(1, ghost_type);
 //     for (; it != end; ++it) {
 //       ElementType type = *it;
 //       UInt nb_segments = mesh_facets.getNbElement(type, ghost_type);
 
 //       // allocate the data
 //       Array<Int> & segment_to_nodetype = *(mesh_facets.getDataPointer<Int>(
 //           "segment_to_nodetype", type, ghost_type));
 
 //       std::set<Element> connected_elements;
 //       const Array<std::vector<Element>> & segment_to_2Delement =
 //           mesh_facets.getElementToSubelement(type, ghost_type);
 
 //       // loop over segments
 //       for (UInt s = 0; s < nb_segments; ++s) {
 
 //         // determine the elements connected to the segment
 //         connected_elements.clear();
 //         const std::vector<Element> & twoD_elements = segment_to_2Delement(s);
 
 //         if (spatial_dimension == 2) {
 //           // if 2D just take the elements connected to the segments
 //           connected_elements.insert(twoD_elements.begin(), twoD_elements.end());
 //         } else if (spatial_dimension == 3) {
 //           // if 3D a second loop is needed to get to the 3D elements
 //           std::vector<Element>::const_iterator facet = twoD_elements.begin();
 
 //           for (; facet != twoD_elements.end(); ++facet) {
 //             const std::vector<Element> & threeD_elements =
 //                 mesh_facets.getElementToSubelement(
 //                     facet->type, facet->ghost_type)(facet->element);
 //             connected_elements.insert(threeD_elements.begin(),
 //                                       threeD_elements.end());
 //           }
 //         }
 
 //         // get the minimum processor rank associated to the connected
 //         // elements and verify if ghost and not ghost elements are
 //         // found
 //         Int minimum_rank = std::numeric_limits<Int>::max();
 
 //         // two booleans saying if not ghost and ghost elements are found in the
 //         // loop
 //         bool ghost_found[2];
 //         ghost_found[0] = false;
 //         ghost_found[1] = false;
 
 //         std::set<Element>::iterator connected_elements_it =
 //             connected_elements.begin();
 
 //         for (; connected_elements_it != connected_elements.end();
 //              ++connected_elements_it) {
 //           if (*connected_elements_it == ElementNull)
 //             continue;
 //           ghost_found[connected_elements_it->ghost_type] = true;
 //           const Array<UInt> & el_to_rank_array = element_to_rank(
 //               connected_elements_it->type, connected_elements_it->ghost_type);
 //           minimum_rank =
 //               std::min(minimum_rank,
 //                        Int(el_to_rank_array(connected_elements_it->element)));
 //         }
 
 //         // if no ghost elements are found the segment is local
 //         if (!ghost_found[1])
 //           segment_to_nodetype(s) = -1;
 //         // if no not ghost elements are found the segment is pure ghost
 //         else if (!ghost_found[0])
 //           segment_to_nodetype(s) = -3;
 //         // if the minimum rank is equal to the local rank, the segment is master
 //         else if (local_rank == minimum_rank)
 //           segment_to_nodetype(s) = -2;
 //         // if the minimum rank is less than the local rank, the segment is slave
 //         else if (local_rank > minimum_rank)
 //           segment_to_nodetype(s) = minimum_rank;
 //         else
 //           AKANTU_DEBUG_ERROR("The local rank cannot be smaller than the "
 //                              "minimum rank if both ghost and not ghost "
 //                              "elements are found");
 //       }
 //     }
 //   }
 // }
 
 /* -------------------------------------------------------------------------- */
 UInt MeshUtils::updateLocalMasterGlobalConnectivity(Mesh & mesh,
                                                     UInt local_nb_new_nodes) {
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int rank = comm.whoAmI();
   Int nb_proc = comm.getNbProc();
   if (nb_proc == 1)
     return local_nb_new_nodes;
 
   /// resize global ids array
   Array<UInt> & nodes_global_ids = mesh.getGlobalNodesIds();
   UInt old_nb_nodes = mesh.getNbNodes() - local_nb_new_nodes;
 
   nodes_global_ids.resize(mesh.getNbNodes());
 
   /// compute the number of global nodes based on the number of old nodes
   Vector<UInt> old_local_master_nodes(nb_proc);
   for (UInt n = 0; n < old_nb_nodes; ++n)
     if (mesh.isLocalOrMasterNode(n))
       ++old_local_master_nodes(rank);
   comm.allGather(old_local_master_nodes);
   UInt old_global_nodes =
       std::accumulate(old_local_master_nodes.storage(),
                       old_local_master_nodes.storage() + nb_proc, 0);
 
   /// compute amount of local or master doubled nodes
   Vector<UInt> local_master_nodes(nb_proc);
   for (UInt n = old_nb_nodes; n < mesh.getNbNodes(); ++n)
     if (mesh.isLocalOrMasterNode(n))
       ++local_master_nodes(rank);
 
   comm.allGather(local_master_nodes);
 
   /// update global number of nodes
   UInt total_nb_new_nodes = std::accumulate(
       local_master_nodes.storage(), local_master_nodes.storage() + nb_proc, 0);
 
   if (total_nb_new_nodes == 0)
     return 0;
 
   /// set global ids of local and master nodes
   UInt starting_index =
       std::accumulate(local_master_nodes.storage(),
                       local_master_nodes.storage() + rank, old_global_nodes);
 
   for (UInt n = old_nb_nodes; n < mesh.getNbNodes(); ++n) {
     if (mesh.isLocalOrMasterNode(n)) {
       nodes_global_ids(n) = starting_index;
       ++starting_index;
     }
   }
 
   MeshAccessor mesh_accessor(mesh);
   mesh_accessor.setNbGlobalNodes(old_global_nodes + total_nb_new_nodes);
   return total_nb_new_nodes;
 }
 
 /* -------------------------------------------------------------------------- */
 // Deactivating -Wunused-parameter
 #if defined(__INTEL_COMPILER)
 //#pragma warning ( disable : 383 )
 #elif defined(__clang__) // test clang to be sure that when we test for gnu it
 // is only gnu
 #elif (defined(__GNUC__) || defined(__GNUG__))
 #define GCC_VERSION                                                            \
   (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
 #if GCC_VERSION > 40600
 #pragma GCC diagnostic push
 #endif
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #endif
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::updateElementalConnectivity(
     Mesh & mesh, UInt old_node, UInt new_node,
     const std::vector<Element> & element_list,
     __attribute__((unused)) const std::vector<Element> * facet_list) {
   AKANTU_DEBUG_IN();
 
   ElementType el_type = _not_defined;
   GhostType gt_type = _casper;
   Array<UInt> * conn_elem = NULL;
 #if defined(AKANTU_COHESIVE_ELEMENT)
   const Array<Element> * cohesive_facets = NULL;
 #endif
   UInt nb_nodes_per_element = 0;
   UInt * n_update = NULL;
 
   for (UInt el = 0; el < element_list.size(); ++el) {
     const Element & elem = element_list[el];
     if (elem.type == _not_defined)
       continue;
 
     if (elem.type != el_type || elem.ghost_type != gt_type) {
       el_type = elem.type;
       gt_type = elem.ghost_type;
       conn_elem = &mesh.getConnectivity(el_type, gt_type);
       nb_nodes_per_element = conn_elem->getNbComponent();
 #if defined(AKANTU_COHESIVE_ELEMENT)
       if (elem.kind == _ek_cohesive)
         cohesive_facets =
             &mesh.getMeshFacets().getSubelementToElement(el_type, gt_type);
 #endif
     }
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
     if (elem.kind == _ek_cohesive) {
 
       AKANTU_DEBUG_ASSERT(
           facet_list != NULL,
           "Provide a facet list in order to update cohesive elements");
 
       /// loop over cohesive element's facets
       for (UInt f = 0, n = 0; f < 2; ++f, n += nb_nodes_per_element / 2) {
         const Element & facet = (*cohesive_facets)(elem.element, f);
 
         /// skip facets if not present in the list
         if (std::find(facet_list->begin(), facet_list->end(), facet) ==
             facet_list->end())
           continue;
 
         n_update = std::find(
             conn_elem->storage() + elem.element * nb_nodes_per_element + n,
             conn_elem->storage() + elem.element * nb_nodes_per_element + n +
                 nb_nodes_per_element / 2,
             old_node);
 
         AKANTU_DEBUG_ASSERT(n_update !=
                                 conn_elem->storage() +
                                     elem.element * nb_nodes_per_element + n +
                                     nb_nodes_per_element / 2,
                             "Node not found in current element");
 
         /// update connectivity
         *n_update = new_node;
       }
     } else {
 #endif
       n_update =
           std::find(conn_elem->storage() + elem.element * nb_nodes_per_element,
                     conn_elem->storage() + elem.element * nb_nodes_per_element +
                         nb_nodes_per_element,
                     old_node);
 
       AKANTU_DEBUG_ASSERT(n_update != conn_elem->storage() +
                                           elem.element * nb_nodes_per_element +
                                           nb_nodes_per_element,
                           "Node not found in current element");
 
       /// update connectivity
       *n_update = new_node;
 #if defined(AKANTU_COHESIVE_ELEMENT)
     }
 #endif
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 // Reactivating -Wunused-parameter
 #if defined(__INTEL_COMPILER)
 //#pragma warning ( disable : 383 )
 #elif defined(__clang__) // test clang to be sure that when we test for gnu it
 // is only gnu
 #elif defined(__GNUG__)
 #if GCC_VERSION > 40600
 #pragma GCC diagnostic pop
 #else
 #pragma GCC diagnostic warning "-Wunused-parameter"
 #endif
 #endif
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
 
 //  LocalWords:  ElementType
diff --git a/src/mesh_utils/mesh_utils_distribution.cc b/src/mesh_utils/mesh_utils_distribution.cc
index 55939345d..f87bc8cc9 100644
--- a/src/mesh_utils/mesh_utils_distribution.cc
+++ b/src/mesh_utils/mesh_utils_distribution.cc
@@ -1,183 +1,178 @@
 /**
  * @file   mesh_utils_distribution.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Sun Oct  2 19:23:15 2016
  *
  * @brief  Implementation of the methods of mesh  utils distribute
  *
  * @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 "mesh_utils_distribution.hh"
 #include "element_info_per_processor.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "mesh_partition.hh"
 #include "mesh_utils.hh"
 #include "node_info_per_processor.hh"
 #include "node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 namespace MeshUtilsDistribution {
   /* ------------------------------------------------------------------------ */
   void distributeMeshCentralized(Mesh & mesh, UInt,
                                  const MeshPartition & partition) {
     MeshAccessor mesh_accessor(mesh);
     ElementSynchronizer & element_synchronizer =
         mesh_accessor.getElementSynchronizer();
     NodeSynchronizer & node_synchronizer = mesh_accessor.getNodeSynchronizer();
 
     const StaticCommunicator & comm = element_synchronizer.getCommunicator();
 
     UInt nb_proc = comm.getNbProc();
     UInt my_rank = comm.whoAmI();
 
     mesh_accessor.setNbGlobalNodes(mesh.getNbNodes());
-    mesh_accessor.getNodesGlobalIds().resize(0);
+    auto & gids = mesh_accessor.getNodesGlobalIds();
 
-    if (nb_proc == 1) {
-      UInt nb_nodes = mesh.getNbGlobalNodes();
-      mesh_accessor.getNodesGlobalIds().resize(nb_nodes);
-      auto gids = mesh_accessor.getNodesGlobalIds();
-      for (UInt n = 0; n < nb_nodes; ++n) {
-        gids(n) = n;
-      }
+    if (nb_proc == 1)
       return;
-    }
+
+    gids.resize(0);
 
     mesh.synchronizeGroupNames();
 
     AKANTU_DEBUG_ASSERT(
         partition.getNbPartition() == nb_proc,
         "The number of partition does not match the number of processors: "
             << partition.getNbPartition() << " != " << nb_proc);
 
     /**
      * connectivity and communications scheme construction
      */
     Mesh::type_iterator it =
         mesh.firstType(_all_dimensions, _not_ghost, _ek_not_defined);
     Mesh::type_iterator end =
         mesh.lastType(_all_dimensions, _not_ghost, _ek_not_defined);
     UInt count = 0;
     /* --- MAIN LOOP ON TYPES --- */
     for (; it != end; ++it) {
       ElementType type = *it;
 
       /// \todo change this ugly way to avoid a problem if an element
       /// type is present in the mesh but not in the partitions
       try {
         partition.getPartition(type, _not_ghost);
       } catch (...) {
         continue;
       }
 
       MasterElementInfoPerProc proc_infos(element_synchronizer, count, my_rank,
                                           type, partition);
       proc_infos.synchronizeConnectivities();
       proc_infos.synchronizePartitions();
       proc_infos.synchronizeTags();
       proc_infos.synchronizeGroups();
       ++count;
     }
 
     { /// Ending the synchronization of elements by sending a stop message
       MasterElementInfoPerProc proc_infos(element_synchronizer, count, my_rank,
                                           _not_defined, partition);
       ++count;
     }
 
     /**
      * Nodes synchronization
      */
     MasterNodeInfoPerProc node_proc_infos(node_synchronizer, count, my_rank);
     node_proc_infos.synchronizeNodes();
     node_proc_infos.synchronizeTypes();
     node_proc_infos.synchronizeGroups();
 
     MeshUtils::fillElementToSubElementsData(mesh);
 
     mesh_accessor.setDistributed();
 
     AKANTU_DEBUG_OUT();
   }
 
   /* ------------------------------------------------------------------------ */
   void distributeMeshCentralized(Mesh & mesh, UInt root) {
     MeshAccessor mesh_accessor(mesh);
     ElementSynchronizer & element_synchronizer =
         mesh_accessor.getElementSynchronizer();
     NodeSynchronizer & node_synchronizer = mesh_accessor.getNodeSynchronizer();
 
     const StaticCommunicator & comm = element_synchronizer.getCommunicator();
 
     UInt nb_proc = comm.getNbProc();
 
     mesh_accessor.getNodesGlobalIds().resize(0);
 
     if (nb_proc == 1)
       return;
 
     mesh.synchronizeGroupNames();
 
     /**
      * connectivity and communications scheme construction on distant
      * processors
      */
     UInt count = 0;
     bool need_synchronize = true;
     do {
       /* --------<<<<-SIZE--------------------------------------------------- */
       SlaveElementInfoPerProc proc_infos(element_synchronizer, count, root);
       need_synchronize = proc_infos.needSynchronize();
 
       if (need_synchronize) {
         proc_infos.synchronizeConnectivities();
         proc_infos.synchronizePartitions();
         proc_infos.synchronizeTags();
         proc_infos.synchronizeGroups();
       }
       ++count;
     } while (need_synchronize);
 
     /**
      * Nodes synchronization
      */
 
     SlaveNodeInfoPerProc node_proc_infos(node_synchronizer, count, root);
 
     node_proc_infos.synchronizeNodes();
     node_proc_infos.synchronizeTypes();
     node_proc_infos.synchronizeGroups();
 
     MeshUtils::fillElementToSubElementsData(mesh);
 
     mesh_accessor.setDistributed();
   }
 
 } // MeshUtilsDistribution
 
 } // akantu
diff --git a/src/mesh_utils/mesh_utils_pbc.cc b/src/mesh_utils/mesh_utils_pbc.cc
index bc11d7891..bf406ba4b 100644
--- a/src/mesh_utils/mesh_utils_pbc.cc
+++ b/src/mesh_utils/mesh_utils_pbc.cc
@@ -1,298 +1,298 @@
 /**
  * @file   mesh_utils_pbc.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Wed Feb 09 2011
  * @date last modification: Tue Sep 15 2015
  *
  * @brief  periodic boundary condition connectivity tweak
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 #include "mesh_accessor.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// class that sorts a set of nodes of same coordinates in 'dir' direction
 class CoordinatesComparison {
 public:
   CoordinatesComparison(const UInt dimension, const UInt dir_1, const UInt dir_2,
                         Real normalization, Real tolerance, const Array<Real> & coords)
     : dim(dimension), dir_1(dir_1), dir_2(dir_2), normalization(normalization),
       tolerance(tolerance), coords_it(coords.begin(dim)) {}
   // answers the question whether n2 is larger or equal to n1
   bool operator()(const UInt n1, const UInt n2) {
     Vector<Real> coords_n1 = coords_it[n1];
     Vector<Real> coords_n2 = coords_it[n2];
     return this->operator()(coords_n1, coords_n2);
   }
 
   bool operator()(const Vector<Real> & coords_n1, const Vector<Real> & coords_n2) {
     Real diff = coords_n1(dir_1) - coords_n2(dir_1);;
     if (dim == 2 || std::abs(diff) / normalization > tolerance)
       return diff > 0. ? false : true;
     else if (dim > 2) {
       diff = coords_n1(dir_2) - coords_n2(dir_2);;
       return diff > 0 ? false : true;
     }
     return true;
   }
 
 private:
   UInt dim;
   UInt dir_1;
   UInt dir_2;
   Real normalization;
   Real tolerance;
   const Array<Real>::const_vector_iterator coords_it;
 };
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::computePBCMap(const Mesh & mesh, const UInt dir,
                               std::map<UInt, UInt> & pbc_pair) {
   Array<UInt> selected_left;
   Array<UInt> selected_right;
 
   const UInt dim = mesh.getSpatialDimension();
   Array<Real>::const_vector_iterator it = mesh.getNodes().begin(dim);
   Array<Real>::const_vector_iterator end = mesh.getNodes().end(dim);
 
   if (dim <= dir)
     return;
 
   const Vector<Real> & lower_bounds = mesh.getLowerBounds();
   const Vector<Real> & upper_bounds = mesh.getUpperBounds();
 
   AKANTU_DEBUG_INFO("min " << lower_bounds(dir));
   AKANTU_DEBUG_INFO("max " << upper_bounds(dir));
 
   for (UInt node = 0; it != end; ++it, ++node) {
     const Vector<Real> & coords = *it;
     AKANTU_DEBUG_TRACE("treating " << coords(dir));
     if (Math::are_float_equal(coords(dir), lower_bounds(dir))) {
       AKANTU_DEBUG_TRACE("pushing node " << node << " on the left side");
       selected_left.push_back(node);
     } else if (Math::are_float_equal(coords(dir), upper_bounds(dir))) {
       selected_right.push_back(node);
       AKANTU_DEBUG_TRACE("pushing node " << node << " on the right side");
     }
   }
 
   AKANTU_DEBUG_INFO(
-      "found " << selected_left.getSize() << " and " << selected_right.getSize()
+      "found " << selected_left.size() << " and " << selected_right.size()
                << " nodes at each boundary for direction " << dir);
 
   // match pairs
   MeshUtils::matchPBCPairs(mesh, dir, selected_left, selected_right, pbc_pair);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::computePBCMap(const Mesh & mesh,
                               const SurfacePair & surface_pair,
                               std::map<UInt, UInt> & pbc_pair) {
 
   Array<UInt> selected_first;
   Array<UInt> selected_second;
 
   // find nodes on surfaces
   const ElementGroup & first_surf = mesh.getElementGroup(surface_pair.first);
   const ElementGroup & second_surf = mesh.getElementGroup(surface_pair.second);
 
   // if this surface pair is not on this proc
   if (first_surf.getNbNodes() == 0 || second_surf.getNbNodes() == 0) {
     AKANTU_DEBUG_WARNING("computePBCMap has at least one surface without any "
                          "nodes. I will ignore it.");
     return;
   }
 
   // copy nodes from element group
   selected_first.copy(first_surf.getNodeGroup().getNodes());
   selected_second.copy(second_surf.getNodeGroup().getNodes());
 
   // coordinates
   const Array<Real> & coords = mesh.getNodes();
   const UInt dim = mesh.getSpatialDimension();
 
   // variables to find min and max of surfaces
   Real first_max[3], first_min[3];
   Real second_max[3], second_min[3];
   for (UInt i = 0; i < dim; ++i) {
     first_min[i] = std::numeric_limits<Real>::max();
     second_min[i] = std::numeric_limits<Real>::max();
     first_max[i] = -std::numeric_limits<Real>::max();
     second_max[i] = -std::numeric_limits<Real>::max();
   }
 
   // find min and max of surface nodes
   for (Array<UInt>::scalar_iterator it = selected_first.begin();
        it != selected_first.end(); ++it) {
     for (UInt i = 0; i < dim; ++i) {
       if (first_min[i] > coords(*it, i))
         first_min[i] = coords(*it, i);
       if (first_max[i] < coords(*it, i))
         first_max[i] = coords(*it, i);
     }
   }
   for (Array<UInt>::scalar_iterator it = selected_second.begin();
        it != selected_second.end(); ++it) {
     for (UInt i = 0; i < dim; ++i) {
       if (second_min[i] > coords(*it, i))
         second_min[i] = coords(*it, i);
       if (second_max[i] < coords(*it, i))
         second_max[i] = coords(*it, i);
     }
   }
 
   // find direction of pbc
   Int first_dir = -1;
 #ifndef AKANTU_NDEBUG
   Int second_dir = -2;
 #endif
   for (UInt i = 0; i < dim; ++i) {
     if (Math::are_float_equal(first_min[i], first_max[i])) {
       first_dir = i;
     }
 #ifndef AKANTU_NDEBUG
     if (Math::are_float_equal(second_min[i], second_max[i])) {
       second_dir = i;
     }
 #endif
   }
 
   AKANTU_DEBUG_ASSERT(first_dir == second_dir,
                       "Surface pair has not same direction. Surface "
                           << surface_pair.first << " dir=" << first_dir
                           << " ; Surface " << surface_pair.second
                           << " dir=" << second_dir);
   UInt dir = first_dir;
 
   // match pairs
   if (first_min[dir] < second_min[dir])
     MeshUtils::matchPBCPairs(mesh, dir, selected_first, selected_second,
                              pbc_pair);
   else
     MeshUtils::matchPBCPairs(mesh, dir, selected_second, selected_first,
                              pbc_pair);
 }
 
 /* -------------------------------------------------------------------------- */
 void MeshUtils::matchPBCPairs(const Mesh & mesh, const UInt dir,
                               Array<UInt> & selected_left,
                               Array<UInt> & selected_right,
                               std::map<UInt, UInt> & pbc_pair) {
 
   // tolerance is that large because most meshers generate points coordinates
   // with single precision only (it is the case of GMSH for instance)
   Real tolerance = 1e-7;
   const UInt dim = mesh.getSpatialDimension();
   Real normalization = mesh.getUpperBounds()(dir) - mesh.getLowerBounds()(dir);
 
   AKANTU_DEBUG_ASSERT(std::abs(normalization) > Math::getTolerance(),
                       "In matchPBCPairs: The normalization is zero. "
                           << "Did you compute the bounding box of the mesh?");
 
   UInt odir_1 = UInt(-1), odir_2 = UInt(-1);
 
   if (dim == 3) {
     if (dir == _x) {
       odir_1 = _y;
       odir_2 = _z;
     } else if (dir == _y) {
       odir_1 = _x;
       odir_2 = _z;
     } else if (dir == _z) {
       odir_1 = _x;
       odir_2 = _y;
     }
   } else if (dim == 2) {
     if (dir == _x) {
       odir_1 = _y;
     } else if (dir == _y) {
       odir_1 = _x;
     }
   }
 
   CoordinatesComparison compare_nodes(dim, odir_1, odir_2, normalization,
                                       tolerance, mesh.getNodes());
 
   std::sort(selected_left.begin(), selected_left.end(), compare_nodes);
   std::sort(selected_right.begin(), selected_right.end(), compare_nodes);
 
   Array<UInt>::scalar_iterator it_left = selected_left.begin();
   Array<UInt>::scalar_iterator end_left = selected_left.end();
 
   Array<UInt>::scalar_iterator it_right = selected_right.begin();
   Array<UInt>::scalar_iterator end_right = selected_right.end();
 
   Array<Real>::const_vector_iterator nit = mesh.getNodes().begin(dim);
 
   while ((it_left != end_left) && (it_right != end_right)) {
     UInt i1 = *it_left;
     UInt i2 = *it_right;
 
     Vector<Real> coords1 = nit[i1];
     Vector<Real> coords2 = nit[i2];
 
     AKANTU_DEBUG_TRACE("do I pair? " << i1 << "(" << coords1 << ") with" << i2
                                      << "(" << coords2 << ") in direction "
                                      << dir);
 
     Real dx = 0.0;
     Real dy = 0.0;
     if (dim >= 2)
       dx = coords1(odir_1) - coords2(odir_1);
     if (dim == 3)
       dy = coords1(odir_2) - coords2(odir_2);
 
     if (std::abs(dx * dx + dy * dy) / normalization < tolerance) {
       // then i match these pairs
       if (pbc_pair.count(i2)) {
         i2 = pbc_pair[i2];
       }
       pbc_pair[i1] = i2;
 
       AKANTU_DEBUG_TRACE("pairing "
                          << i1 << "(" << coords1
                          << ") with" << i2 << "(" << coords2
                          << ") in direction " << dir);
       ++it_left;
       ++it_right;
     } else if (compare_nodes(coords1, coords2)) {
       ++it_left;
     } else {
       ++it_right;
     }
   }
   AKANTU_DEBUG_INFO("found " << pbc_pair.size() << " pairs for direction "
                              << dir);
 }
 
 } // akantu
diff --git a/src/model/boundary_condition_tmpl.hh b/src/model/boundary_condition_tmpl.hh
index 8d42ed878..a82cfdae7 100644
--- a/src/model/boundary_condition_tmpl.hh
+++ b/src/model/boundary_condition_tmpl.hh
@@ -1,268 +1,268 @@
 /**
  * @file   boundary_condition_tmpl.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  implementation of the applyBC
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_group.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & dual) {
   this->model = &model;
   this->primal = &primal;
   this->dual = &dual;
   if (this->model->getSpatialDimension() > 1)
     this->model->initFEEngineBoundary();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & primal_increment,
                                           Array<Real> & dual) {
   this->initBC(model, primal, dual);
   this->primal_increment = &primal_increment;
 }
 /* -------------------------------------------------------------------------- */
 /* Partial specialization for DIRICHLET functors */
 template <typename ModelType>
 template <typename FunctorType>
 struct BoundaryCondition<ModelType>::TemplateFunctionWrapper<
     FunctorType, BC::Functor::_dirichlet> {
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance) {
     ModelType & model = bc_instance.getModel();
     Array<Real> & primal = bc_instance.getPrimal();
     const Array<Real> & coords = model.getMesh().getNodes();
     Array<bool> & boundary_flags = model.getBlockedDOFs();
     UInt dim = model.getMesh().getSpatialDimension();
 
     Array<Real>::vector_iterator primal_iter =
         primal.begin(primal.getNbComponent());
     Array<Real>::const_vector_iterator coords_iter = coords.begin(dim);
     Array<bool>::vector_iterator flags_iter =
         boundary_flags.begin(boundary_flags.getNbComponent());
 
     for (auto  n : group.getNodeGroup()) {
       Vector<bool> flag(flags_iter[n]);
       Vector<Real> primal(primal_iter[n]);
       Vector<Real> coords(coords_iter[n]);
       func(n, flag, primal, coords);
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* Partial specialization for NEUMANN functors */
 template <typename ModelType>
 template <typename FunctorType>
 struct BoundaryCondition<ModelType>::TemplateFunctionWrapper<
     FunctorType, BC::Functor::_neumann> {
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance) {
     UInt dim = bc_instance.getModel().getSpatialDimension();
     switch (dim) {
     case 1: {
       AKANTU_DEBUG_TO_IMPLEMENT();
       break;
     }
     case 2:
     case 3: {
       applyBC(func, group, bc_instance, _not_ghost);
       applyBC(func, group, bc_instance, _ghost);
       break;
     }
     }
   }
 
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance,
                              GhostType ghost_type) {
     ModelType & model = bc_instance.getModel();
     Array<Real> & dual = bc_instance.getDual();
     const Mesh & mesh = model.getMesh();
     const Array<Real> & nodes_coords = mesh.getNodes();
     const FEEngine & fem_boundary = model.getFEEngineBoundary();
 
     UInt dim = model.getSpatialDimension();
     UInt nb_degree_of_freedom = dual.getNbComponent();
 
     IntegrationPoint quad_point;
     quad_point.ghost_type = ghost_type;
 
     ElementGroup::type_iterator type_it = group.firstType(dim - 1, ghost_type);
     ElementGroup::type_iterator type_end = group.lastType(dim - 1, ghost_type);
 
     // Loop over the boundary element types
     for (; type_it != type_end; ++type_it) {
       const Array<UInt> & element_ids = group.getElements(*type_it, ghost_type);
 
       Array<UInt>::const_scalar_iterator elem_iter = element_ids.begin();
       Array<UInt>::const_scalar_iterator elem_iter_end = element_ids.end();
 
       UInt nb_quad_points =
           fem_boundary.getNbIntegrationPoints(*type_it, ghost_type);
-      UInt nb_elements = element_ids.getSize();
+      UInt nb_elements = element_ids.size();
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(*type_it);
 
       Array<Real> * dual_before_integ = new Array<Real>(
           nb_elements * nb_quad_points, nb_degree_of_freedom, 0.);
       Array<Real> * quad_coords =
           new Array<Real>(nb_elements * nb_quad_points, dim);
 
       const Array<Real> & normals_on_quad =
           fem_boundary.getNormalsOnIntegrationPoints(*type_it, ghost_type);
 
       fem_boundary.interpolateOnIntegrationPoints(
           nodes_coords, *quad_coords, dim, *type_it, ghost_type, element_ids);
       Array<Real>::const_vector_iterator normals_begin =
           normals_on_quad.begin(dim);
       Array<Real>::const_vector_iterator normals_iter;
       Array<Real>::const_vector_iterator quad_coords_iter =
           quad_coords->begin(dim);
       Array<Real>::vector_iterator dual_iter =
           dual_before_integ->begin(nb_degree_of_freedom);
 
       quad_point.type = *type_it;
       for (; elem_iter != elem_iter_end; ++elem_iter) {
         UInt el = *elem_iter;
         quad_point.element = el;
         normals_iter = normals_begin + el * nb_quad_points;
         for (UInt q(0); q < nb_quad_points; ++q) {
           quad_point.num_point = q;
           func(quad_point, *dual_iter, *quad_coords_iter, *normals_iter);
           ++dual_iter;
           ++quad_coords_iter;
           ++normals_iter;
         }
       }
 
       delete quad_coords;
 
       /* -------------------------------------------------------------------- */
       // Initialization of iterators
       Array<Real>::matrix_iterator dual_iter_mat =
           dual_before_integ->begin(nb_degree_of_freedom, 1);
       elem_iter = element_ids.begin();
       Array<Real>::const_matrix_iterator shapes_iter_begin =
           fem_boundary.getShapes(*type_it, ghost_type)
               .begin(1, nb_nodes_per_element);
 
       Array<Real> * dual_by_shapes =
           new Array<Real>(nb_elements * nb_quad_points,
                           nb_degree_of_freedom * nb_nodes_per_element);
 
       Array<Real>::matrix_iterator dual_by_shapes_iter =
           dual_by_shapes->begin(nb_degree_of_freedom, nb_nodes_per_element);
 
       Array<Real>::const_matrix_iterator shapes_iter;
 
       /* -------------------------------------------------------------------- */
       // Loop computing dual x shapes
       for (; elem_iter != elem_iter_end; ++elem_iter) {
         shapes_iter = shapes_iter_begin + *elem_iter * nb_quad_points;
 
         for (UInt q(0); q < nb_quad_points;
              ++q, ++dual_iter_mat, ++dual_by_shapes_iter, ++shapes_iter) {
           dual_by_shapes_iter->mul<false, false>(*dual_iter_mat, *shapes_iter);
         }
       }
 
       delete dual_before_integ;
 
       Array<Real> * dual_by_shapes_integ = new Array<Real>(
           nb_elements, nb_degree_of_freedom * nb_nodes_per_element);
       fem_boundary.integrate(*dual_by_shapes, *dual_by_shapes_integ,
                              nb_degree_of_freedom * nb_nodes_per_element,
                              *type_it, ghost_type, element_ids);
       delete dual_by_shapes;
 
       // assemble the result into force vector
       model.getDOFManager().assembleElementalArrayLocalArray(
           *dual_by_shapes_integ, dual, *type_it, ghost_type, 1., element_ids);
       delete dual_by_shapes_integ;
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void BoundaryCondition<ModelType>::applyBC(const FunctorType & func) {
   GroupManager::const_element_group_iterator bit =
       model->getMesh().getGroupManager().element_group_begin();
   GroupManager::const_element_group_iterator bend =
       model->getMesh().getGroupManager().element_group_end();
   for (; bit != bend; ++bit)
     applyBC(func, *bit);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void
 BoundaryCondition<ModelType>::applyBC(const FunctorType & func,
                                       const std::string & group_name) {
   try {
     const ElementGroup & element_group =
         model->getMesh().getElementGroup(group_name);
     applyBC(func, element_group);
   } catch (akantu::debug::Exception e) {
     AKANTU_EXCEPTION("Error applying a boundary condition onto \""
                      << group_name << "\"! [" << e.what() << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void
 BoundaryCondition<ModelType>::applyBC(const FunctorType & func,
                                       const ElementGroup & element_group) {
 #if !defined(AKANTU_NDEBUG)
   if (element_group.getDimension() != model->getSpatialDimension() - 1)
     AKANTU_DEBUG_WARNING("The group "
                          << element_group.getName()
                          << " does not contain only boundaries elements");
 #endif
 
   TemplateFunctionWrapper<FunctorType>::applyBC(func, element_group, *this);
 }
 
 } // akantu
diff --git a/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc b/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
index 84bd2b33c..3ea76cbf8 100644
--- a/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
+++ b/src/model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
@@ -1,310 +1,310 @@
 /**
  * @file   neighborhood_max_criterion.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Thu Oct 15 2015
  * @date last modification: Tue Nov 24 2015
  *
  * @brief  Implementation of class NeighborhoodMaxCriterion
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "neighborhood_max_criterion.hh"
 #include "grid_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NeighborhoodMaxCriterion::NeighborhoodMaxCriterion(
     Model & model, const ElementTypeMapReal & quad_coordinates,
     const ID & criterion_id, const ID & id, const MemoryID & memory_id)
     : NeighborhoodBase(model, quad_coordinates, id, memory_id),
       Parsable(_st_non_local, id), is_highest("is_highest", id, memory_id),
       criterion(criterion_id, id, memory_id) {
 
   AKANTU_DEBUG_IN();
 
   this->registerParam("radius", neighborhood_radius, 100.,
                       _pat_parsable | _pat_readable, "Non local radius");
 
   Mesh & mesh = this->model.getMesh();
   /// allocate the element type map arrays for _not_ghosts: One entry per quad
   GhostType ghost_type = _not_ghost;
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
 
   for (; it != last_type; ++it) {
-    UInt new_size = this->quad_coordinates(*it, ghost_type).getSize();
+    UInt new_size = this->quad_coordinates(*it, ghost_type).size();
     this->is_highest.alloc(new_size, 1, *it, ghost_type, true);
     this->criterion.alloc(new_size, 1, *it, ghost_type, true);
   }
 
   /// criterion needs allocation also for ghost
   ghost_type = _ghost;
   it = mesh.firstType(spatial_dimension, ghost_type);
   last_type = mesh.lastType(spatial_dimension, ghost_type);
   for (; it != last_type; ++it) {
-    UInt new_size = this->quad_coordinates(*it, ghost_type).getSize();
+    UInt new_size = this->quad_coordinates(*it, ghost_type).size();
     this->criterion.alloc(new_size, 1, *it, ghost_type, true);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 NeighborhoodMaxCriterion::~NeighborhoodMaxCriterion() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::initNeighborhood() {
   AKANTU_DEBUG_IN();
 
   /// parse the input parameter
   const Parser & parser = getStaticParser();
   const ParserSection & section_neighborhood =
       *(parser.getSubSections(_st_neighborhood).first);
   this->parseSection(section_neighborhood);
 
   AKANTU_DEBUG_INFO("Creating the grid");
   this->createGrid();
 
   /// insert the non-ghost quads into the grid
   this->insertAllQuads(_not_ghost);
 
   /// store the number of current ghost elements for each type in the mesh
   ElementTypeMap<UInt> nb_ghost_protected;
   Mesh & mesh = this->model.getMesh();
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, _ghost);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, _ghost);
   for (; it != last_type; ++it)
     nb_ghost_protected(mesh.getNbElement(*it, _ghost), *it, _ghost);
 
   /// create the grid synchronizer
   this->createGridSynchronizer();
 
   /// insert the ghost quads into the grid
   this->insertAllQuads(_ghost);
 
   /// create the pair lists
   this->updatePairList();
 
   /// remove the unneccessary ghosts
   this->cleanupExtraGhostElements(nb_ghost_protected);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::createGridSynchronizer() {
   this->is_creating_grid = true;
   std::set<SynchronizationTag> tags;
   tags.insert(_gst_nh_criterion);
 
   std::stringstream sstr;
   sstr << getID() << ":grid_synchronizer";
   this->grid_synchronizer = std::make_unique<GridSynchronizer>(
       this->model.getMesh(), *spatial_grid, * this, tags, sstr.str(), 0, false);
   this->is_creating_grid = false;
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::insertAllQuads(const GhostType & ghost_type) {
   IntegrationPoint q;
   q.ghost_type = ghost_type;
   Mesh & mesh = this->model.getMesh();
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
   for (; it != last_type; ++it) {
     UInt nb_element = mesh.getNbElement(*it, ghost_type);
     UInt nb_quad =
         this->model.getFEEngine().getNbIntegrationPoints(*it, ghost_type);
 
     const Array<Real> & quads = this->quad_coordinates(*it, ghost_type);
     q.type = *it;
 
     Array<Real>::const_vector_iterator quad = quads.begin(spatial_dimension);
 
     for (UInt e = 0; e < nb_element; ++e) {
       q.element = e;
       for (UInt nq = 0; nq < nb_quad; ++nq) {
         q.num_point = nq;
         q.global_num = q.element * nb_quad + nq;
         spatial_grid->insert(q, *quad);
         ++quad;
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::findMaxQuads(
     std::vector<IntegrationPoint> & max_quads) {
   AKANTU_DEBUG_IN();
 
   /// clear the element type maps
   this->is_highest.clear();
   this->criterion.clear();
 
   /// update the values of the criterion
   this->model.updateDataForNonLocalCriterion(criterion);
 
   /// start the exchange the value of the criterion on the ghost elements
   this->model.asynchronousSynchronize(_gst_nh_criterion);
 
   /// compare to not-ghost neighbors
   checkNeighbors(_not_ghost);
 
   /// finish the exchange
   this->model.waitEndSynchronize(_gst_nh_criterion);
 
   /// compare to ghost neighbors
   checkNeighbors(_ghost);
 
   /// extract the quads with highest criterion in their neighborhood
   IntegrationPoint quad;
   quad.ghost_type = _not_ghost;
   Mesh & mesh = this->model.getMesh();
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, _not_ghost);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, _not_ghost);
   for (; it != last_type; ++it) {
     quad.type = *it;
     Array<bool>::const_scalar_iterator is_highest_it =
         is_highest(*it, _not_ghost).begin();
     Array<bool>::const_scalar_iterator is_highest_end =
         is_highest(*it, _not_ghost).end();
 
     UInt nb_quadrature_points =
         this->model.getFEEngine().getNbIntegrationPoints(*it, _not_ghost);
     UInt q = 0;
 
     /// loop over is_highest for the current element type
     for (; is_highest_it != is_highest_end; ++is_highest_it, ++q) {
       if (*is_highest_it) {
         /// gauss point has the highest stress in his neighbourhood
         quad.element = q / nb_quadrature_points;
         quad.global_num = q;
         quad.num_point = q % nb_quadrature_points;
         max_quads.push_back(quad);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::checkNeighbors(const GhostType & ghost_type2) {
   AKANTU_DEBUG_IN();
 
   PairList::const_iterator first_pair = pair_list[ghost_type2].begin();
   PairList::const_iterator last_pair = pair_list[ghost_type2].end();
 
   // Compute the weights
   for (; first_pair != last_pair; ++first_pair) {
     const IntegrationPoint & lq1 = first_pair->first;
     const IntegrationPoint & lq2 = first_pair->second;
 
     Array<bool> & has_highest_eq_stress_1 =
         is_highest(lq1.type, lq1.ghost_type);
 
     const Array<Real> & criterion_1 = this->criterion(lq1.type, lq1.ghost_type);
     const Array<Real> & criterion_2 = this->criterion(lq2.type, lq2.ghost_type);
 
     if (criterion_1(lq1.global_num) < criterion_2(lq2.global_num))
       has_highest_eq_stress_1(lq1.global_num) = false;
     else if (ghost_type2 != _ghost) {
       Array<bool> & has_highest_eq_stress_2 =
           is_highest(lq2.type, lq2.ghost_type);
       has_highest_eq_stress_2(lq2.global_num) = false;
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NeighborhoodMaxCriterion::cleanupExtraGhostElements(
     const ElementTypeMap<UInt> & nb_ghost_protected) {
 
   Mesh & mesh = this->model.getMesh();
   /// create remove elements event
   RemovedElementsEvent remove_elem(mesh);
   /// create set of ghosts to keep
   std::set<Element> relevant_ghost_elements;
   PairList::const_iterator first_pair = pair_list[_ghost].begin();
   PairList::const_iterator last_pair = pair_list[_ghost].end();
   for (; first_pair != last_pair; ++first_pair) {
     const IntegrationPoint & q2 = first_pair->second;
     relevant_ghost_elements.insert(q2);
   }
 
   Array<Element> ghosts_to_erase(0);
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, _ghost);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, _ghost);
 
   Element element;
   element.ghost_type = _ghost;
 
   std::set<Element>::const_iterator end = relevant_ghost_elements.end();
   for (; it != last_type; ++it) {
     element.type = *it;
     UInt nb_ghost_elem = mesh.getNbElement(*it, _ghost);
     UInt nb_ghost_elem_protected = 0;
     try {
       nb_ghost_elem_protected = nb_ghost_protected(*it, _ghost);
     } catch (...) {
     }
 
     if (!remove_elem.getNewNumbering().exists(*it, _ghost))
       remove_elem.getNewNumbering().alloc(nb_ghost_elem, 1, *it, _ghost);
     else
       remove_elem.getNewNumbering(*it, _ghost).resize(nb_ghost_elem);
     Array<UInt> & new_numbering = remove_elem.getNewNumbering(*it, _ghost);
     for (UInt g = 0; g < nb_ghost_elem; ++g) {
       element.element = g;
       if (element.element >= nb_ghost_elem_protected &&
           relevant_ghost_elements.find(element) == end) {
         ghosts_to_erase.push_back(element);
         new_numbering(element.element) = UInt(-1);
       }
     }
     /// renumber remaining ghosts
     UInt ng = 0;
     for (UInt g = 0; g < nb_ghost_elem; ++g) {
       if (new_numbering(g) != UInt(-1)) {
         new_numbering(g) = ng;
         ++ng;
       }
     }
   }
 
   mesh.sendEvent(remove_elem);
   this->onElementsRemoved(ghosts_to_erase, remove_elem.getNewNumbering(),
                           remove_elem);
 }
 
 } // namespace akantu
diff --git a/src/model/common/non_local_toolbox/non_local_manager.cc b/src/model/common/non_local_toolbox/non_local_manager.cc
index 39f70665b..2d85162e6 100644
--- a/src/model/common/non_local_toolbox/non_local_manager.cc
+++ b/src/model/common/non_local_toolbox/non_local_manager.cc
@@ -1,630 +1,630 @@
 /**
  * @file   non_local_manager.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Apr 13 2012
  * @date last modification: Wed Dec 16 2015
  *
  * @brief  Implementation of non-local manager
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_local_manager.hh"
 #include "grid_synchronizer.hh"
 #include "model.hh"
 #include "non_local_neighborhood.hh"
 /* -------------------------------------------------------------------------- */
 #include <numeric>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NonLocalManager::NonLocalManager(Model & model, const ID & id,
                                  const MemoryID & memory_id)
     : Memory(id, memory_id), Parsable(_st_neighborhoods, id),
       spatial_dimension(model.getMesh().getSpatialDimension()), model(model),
       integration_points_positions("integration_points_positions", id,
                                    memory_id),
       volumes("volumes", id, memory_id), compute_stress_calls(0),
       dummy_registry(nullptr), dummy_grid(nullptr) {
   Mesh & mesh = this->model.getMesh();
   mesh.registerEventHandler(*this, _ehp_non_local_manager);
 
   /// parse the neighborhood information from the input file
   const Parser & parser = getStaticParser();
 
   /// iterate over all the non-local sections and store them in a map
   std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
       weight_sect = parser.getSubSections(_st_non_local);
   Parser::const_section_iterator it = weight_sect.first;
   for (; it != weight_sect.second; ++it) {
     const ParserSection & section = *it;
     ID name = section.getName();
     this->weight_function_types[name] = section;
   }
 
   this->initializeNonLocal();
 }
 
 /* -------------------------------------------------------------------------- */
 NonLocalManager::~NonLocalManager() = default;
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::registerNonLocalManagerCallback(
     std::shared_ptr<NonLocalManagerCallback> & callback) {
   this->callback = callback;
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::initializeNonLocal() {
   volumes.initialize(this->model.getFEEngine(),
                      _spatial_dimension = spatial_dimension);
 
   this->callback->insertIntegrationPointsInNeighborhoods(_not_ghost);
 
   /// store the number of current ghost elements for each type in the mesh
   ElementTypeMap<UInt> nb_ghost_protected;
   Mesh & mesh = this->model.getMesh();
   for (auto type : mesh.elementTypes(spatial_dimension, _ghost))
     nb_ghost_protected(mesh.getNbElement(type, _ghost), type, _ghost);
 
   /// exchange the missing ghosts for the non-local neighborhoods
   this->createNeighborhoodSynchronizers();
 
   /// insert the ghost quadrature points of the non-local materials into the
   /// non-local neighborhoods
   this->callback->insertIntegrationPointsInNeighborhoods(_ghost);
 
   FEEngine & fee = this->model.getFEEngine();
   this->updatePairLists();
 
   /// cleanup the unneccessary ghost elements
   this->cleanupExtraGhostElements(nb_ghost_protected);
   this->setJacobians(fee, _ek_regular);
 
   this->initNonLocalVariables();
   this->computeWeights();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::setJacobians(const FEEngine & fe_engine,
                                    const ElementKind & kind) {
   Mesh & mesh = this->model.getMesh();
   for (auto ghost_type : ghost_types) {
     for (auto type : mesh.elementTypes(spatial_dimension, ghost_type, kind)) {
       jacobians(type, ghost_type) =
           &fe_engine.getIntegratorInterface().getJacobians(type, ghost_type);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::createNeighborhood(const ID & weight_func,
                                          const ID & neighborhood_id) {
 
   AKANTU_DEBUG_IN();
 
   const ParserSection & section = this->weight_function_types[weight_func];
   const ID weight_func_type = section.getOption();
   /// create new neighborhood for given ID
   std::stringstream sstr;
   sstr << id << ":neighborhood:" << neighborhood_id;
 
   if (weight_func_type == "base_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<BaseWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
 #if defined(AKANTU_DAMAGE_NON_LOCAL)
   else if (weight_func_type == "remove_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<RemoveDamagedWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
   else if (weight_func_type == "stress_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<StressBasedWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
   else if (weight_func_type == "damage_wf")
     neighborhoods[neighborhood_id] =
         std::make_unique<NonLocalNeighborhood<DamagedWeightFunction>>(
             *this, this->integration_points_positions, sstr.str());
 #endif
   else
     AKANTU_EXCEPTION("error in weight function type provided in material file");
 
   neighborhoods[neighborhood_id]->parseSection(section);
   neighborhoods[neighborhood_id]->initNeighborhood();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::createNeighborhoodSynchronizers() {
   /// exchange all the neighborhood IDs, so that every proc knows how many
   /// neighborhoods exist globally
   /// First: Compute locally the maximum ID size
   UInt max_id_size = 0;
   UInt current_size = 0;
   NeighborhoodMap::const_iterator it;
   for (it = neighborhoods.begin(); it != neighborhoods.end(); ++it) {
     current_size = it->first.size();
     if (current_size > max_id_size)
       max_id_size = current_size;
   }
 
   /// get the global maximum ID size on each proc
   StaticCommunicator & static_communicator =
       akantu::StaticCommunicator::getStaticCommunicator();
   static_communicator.allReduce(max_id_size, _so_max);
 
   /// get the rank for this proc and the total nb proc
   UInt prank = static_communicator.whoAmI();
   UInt psize = static_communicator.getNbProc();
 
   /// exchange the number of neighborhoods on each proc
   Array<Int> nb_neighborhoods_per_proc(psize);
   nb_neighborhoods_per_proc(prank) = neighborhoods.size();
   static_communicator.allGather(nb_neighborhoods_per_proc);
 
   /// compute the total number of neighborhoods
   UInt nb_neighborhoods_global = std::accumulate(
       nb_neighborhoods_per_proc.begin(), nb_neighborhoods_per_proc.end(), 0);
 
   /// allocate an array of chars to store the names of all neighborhoods
   Array<char> buffer(nb_neighborhoods_global, max_id_size);
 
   /// starting index on this proc
   UInt starting_index =
       std::accumulate(nb_neighborhoods_per_proc.begin(),
                       nb_neighborhoods_per_proc.begin() + prank, 0);
 
   it = neighborhoods.begin();
   /// store the names of local neighborhoods in the buffer
   for (UInt i = 0; i < neighborhoods.size(); ++i, ++it) {
     UInt c = 0;
     for (; c < it->first.size(); ++c)
       buffer(i + starting_index, c) = it->first[c];
 
     for (; c < max_id_size; ++c)
       buffer(i + starting_index, c) = char(0);
   }
 
   /// store the nb of data to send in the all gather
   Array<Int> buffer_size(nb_neighborhoods_per_proc);
   buffer_size *= max_id_size;
   /// exchange the names of all the neighborhoods with all procs
   static_communicator.allGatherV(buffer, buffer_size);
 
   for (UInt i = 0; i < nb_neighborhoods_global; ++i) {
     std::stringstream neighborhood_id;
     for (UInt c = 0; c < max_id_size; ++c) {
       if (buffer(i, c) == char(0))
         break;
       neighborhood_id << buffer(i, c);
     }
     global_neighborhoods.insert(neighborhood_id.str());
   }
 
   /// this proc does not know all the neighborhoods -> create dummy
   /// grid so that this proc can participate in the all gather for
   /// detecting the overlap of neighborhoods this proc doesn't know
   Vector<Real> grid_center(this->spatial_dimension,
                            std::numeric_limits<Real>::max());
   Vector<Real> spacing(this->spatial_dimension, 0.);
 
   dummy_grid = std::make_unique<SpatialGrid<IntegrationPoint>>(
       this->spatial_dimension, spacing, grid_center);
   std::set<SynchronizationTag> tags;
   tags.insert(_gst_mnl_for_average);
   tags.insert(_gst_mnl_weight);
 
   for (auto & neighborhood_id : global_neighborhoods) {
     it = neighborhoods.find(neighborhood_id);
     if (it != neighborhoods.end()) {
       it->second->createGridSynchronizer();
     } else {
       std::stringstream sstr;
       sstr << this->id << ":" << neighborhood_id << ":grid_synchronizer";
       dummy_synchronizers[neighborhood_id] = std::make_unique<GridSynchronizer>(
           this->model.getMesh(), *dummy_grid, sstr.str(), this->memory_id,
           false);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::averageInternals(const GhostType & ghost_type) {
   /// update the weights of the weight function
   if (ghost_type == _not_ghost)
     this->computeWeights();
 
   /// loop over all neighborhoods and compute the non-local variables
   for (auto & neighborhood : neighborhoods) {
     /// loop over all the non-local variables of the given neighborhood
     for (auto & non_local_variable : non_local_variables) {
       NonLocalVariable & non_local_var = *non_local_variable.second;
       neighborhood.second->weightedAverageOnNeighbours(
           non_local_var.local, non_local_var.non_local,
           non_local_var.nb_component, ghost_type);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::computeWeights() {
   AKANTU_DEBUG_IN();
 
   this->updateWeightFunctionInternals();
   this->volumes.clear();
 
   for (auto global_neighborhood : global_neighborhoods) {
     auto it = neighborhoods.find(global_neighborhood);
 
     if (it != neighborhoods.end())
       it->second->updateWeights();
     else {
       dummy_synchronizers[global_neighborhood]->synchronize(dummy_accessor,
                                                             _gst_mnl_weight);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::updatePairLists() {
   AKANTU_DEBUG_IN();
 
   integration_points_positions.initialize(
       this->model.getFEEngine(), _nb_component = spatial_dimension,
       _spatial_dimension = spatial_dimension);
 
   /// compute the position of the quadrature points
   this->model.getFEEngine().computeIntegrationPointsCoordinates(
       integration_points_positions);
 
   for (auto & pair : neighborhoods)
     pair.second->updatePairList();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::registerNonLocalVariable(const ID & variable_name,
                                                const ID & nl_variable_name,
                                                UInt nb_component) {
 
   AKANTU_DEBUG_IN();
 
   auto non_local_variable_it = non_local_variables.find(variable_name);
 
   if (non_local_variable_it == non_local_variables.end())
     non_local_variables[nl_variable_name] = std::make_unique<NonLocalVariable>(
         variable_name, nl_variable_name, this->id, nb_component);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementTypeMapReal &
 NonLocalManager::registerWeightFunctionInternal(const ID & field_name) {
 
   AKANTU_DEBUG_IN();
 
   auto it = this->weight_function_internals.find(field_name);
   if (it == weight_function_internals.end()) {
     weight_function_internals[field_name] =
         std::make_unique<ElementTypeMapReal>(field_name, this->id,
                                              this->memory_id);
   }
 
   return *(weight_function_internals[field_name]);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::updateWeightFunctionInternals() {
   for (auto & pair : this->weight_function_internals) {
     auto & internals = *pair.second;
     internals.clear();
     for (auto ghost_type : ghost_types)
       this->callback->updateLocalInternal(internals, ghost_type, _ek_regular);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::initNonLocalVariables() {
   /// loop over all the non-local variables
   for (auto & pair : non_local_variables) {
     auto & variable = *pair.second;
     variable.non_local.initialize(this->model.getFEEngine(),
                                   _nb_component = variable.nb_component,
                                   _spatial_dimension = spatial_dimension);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::computeAllNonLocalStresses() {
 
   /// update the flattened version of the internals
   for (auto & pair : non_local_variables) {
     auto & variable = *pair.second;
     variable.local.clear();
     variable.non_local.clear();
     for (auto ghost_type : ghost_types) {
       this->callback->updateLocalInternal(variable.local, ghost_type,
                                           _ek_regular);
     }
   }
 
   this->volumes.clear();
 
   for (auto & pair : neighborhoods) {
     auto & neighborhood = *pair.second;
     neighborhood.asynchronousSynchronize(_gst_mnl_for_average);
   }
 
   this->averageInternals(_not_ghost);
 
   AKANTU_DEBUG_INFO("Wait distant non local stresses");
 
   for (auto & pair : neighborhoods) {
     auto & neighborhood = *pair.second;
     neighborhood.waitEndSynchronize(_gst_mnl_for_average);
   }
 
   this->averageInternals(_ghost);
 
   /// copy the results in the materials
   for (auto & pair : non_local_variables) {
     auto & variable = *pair.second;
     for (auto ghost_type : ghost_types) {
       this->callback->updateNonLocalInternal(variable.non_local, ghost_type,
                                              _ek_regular);
     }
   }
 
   this->callback->computeNonLocalStresses(_not_ghost);
 
   ++this->compute_stress_calls;
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::cleanupExtraGhostElements(
     ElementTypeMap<UInt> & nb_ghost_protected) {
 
   using ElementSet = std::set<Element>;
   ElementSet relevant_ghost_elements;
 
   /// loop over all the neighborhoods and get their protected ghosts
   for (auto & pair : neighborhoods) {
     auto & neighborhood = *pair.second;
     ElementSet to_keep_per_neighborhood;
 
     neighborhood.cleanupExtraGhostElements(to_keep_per_neighborhood);
     for (auto & element : to_keep_per_neighborhood)
       relevant_ghost_elements.insert(element);
   }
 
   /// remove all unneccessary ghosts from the mesh
   /// Create list of element to remove and new numbering for element to keep
   Mesh & mesh = this->model.getMesh();
   ElementSet ghost_to_erase;
 
   RemovedElementsEvent remove_elem(mesh);
   auto & new_numberings = remove_elem.getNewNumbering();
   Element element;
   element.ghost_type = _ghost;
 
   for (auto & type : mesh.elementTypes(spatial_dimension, _ghost)) {
     element.type = type;
     UInt nb_ghost_elem = mesh.getNbElement(type, _ghost);
     UInt nb_ghost_elem_protected = 0;
     try {
       nb_ghost_elem_protected = nb_ghost_protected(type, _ghost);
     } catch (...) {
     }
 
     if (!new_numberings.exists(type, _ghost))
       new_numberings.alloc(nb_ghost_elem, 1, type, _ghost);
     else
       new_numberings(type, _ghost).resize(nb_ghost_elem);
 
     Array<UInt> & new_numbering = new_numberings(type, _ghost);
     for (UInt g = 0; g < nb_ghost_elem; ++g) {
       element.element = g;
       if (element.element >= nb_ghost_elem_protected &&
           relevant_ghost_elements.find(element) ==
               relevant_ghost_elements.end()) {
         remove_elem.getList().push_back(element);
         new_numbering(element.element) = UInt(-1);
       }
     }
     /// renumber remaining ghosts
     UInt ng = 0;
     for (UInt g = 0; g < nb_ghost_elem; ++g) {
       if (new_numbering(g) != UInt(-1)) {
         new_numbering(g) = ng;
         ++ng;
       }
     }
   }
 
   for (auto & type : mesh.elementTypes(spatial_dimension, _not_ghost)) {
     UInt nb_elem = mesh.getNbElement(type, _not_ghost);
     if (!new_numberings.exists(type, _not_ghost))
       new_numberings.alloc(nb_elem, 1, type, _not_ghost);
     Array<UInt> & new_numbering = new_numberings(type, _not_ghost);
     for (UInt e = 0; e < nb_elem; ++e) {
       new_numbering(e) = e;
     }
   }
   mesh.sendEvent(remove_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     __attribute__((unused)) const RemovedElementsEvent & event) {
 
   FEEngine & fee = this->model.getFEEngine();
   this->removeIntegrationPointsFromMap(
       event.getNewNumbering(), spatial_dimension, integration_points_positions,
       fee, _ek_regular);
   this->removeIntegrationPointsFromMap(event.getNewNumbering(), 1, volumes, fee,
                                        _ek_regular);
 
   /// loop over all the neighborhoods and call onElementsRemoved
   std::set<ID>::const_iterator global_neighborhood_it =
       global_neighborhoods.begin();
   NeighborhoodMap::iterator it;
   for (; global_neighborhood_it != global_neighborhoods.end();
        ++global_neighborhood_it) {
     it = neighborhoods.find(*global_neighborhood_it);
     if (it != neighborhoods.end())
       it->second->onElementsRemoved(element_list, new_numbering, event);
     else
       dummy_synchronizers[*global_neighborhood_it]->onElementsRemoved(
           element_list, new_numbering, event);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::onElementsAdded(__attribute__((unused))
                                       const Array<Element> & element_list,
                                       __attribute__((unused))
                                       const NewElementsEvent & event) {
   this->resizeElementTypeMap(1, volumes, model.getFEEngine());
   this->resizeElementTypeMap(spatial_dimension, integration_points_positions,
                              model.getFEEngine());
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::resizeElementTypeMap(UInt nb_component,
                                            ElementTypeMapReal & element_map,
                                            const FEEngine & fee,
                                            const ElementKind el_kind) {
   Mesh & mesh = this->model.getMesh();
 
   for (auto gt : ghost_types) {
     for (auto type : mesh.elementTypes(spatial_dimension, gt, el_kind)) {
       UInt nb_element = mesh.getNbElement(type, gt);
       UInt nb_quads = fee.getNbIntegrationPoints(type, gt);
       if (!element_map.exists(type, gt))
         element_map.alloc(nb_element * nb_quads, nb_component, type, gt);
       else
         element_map(type, gt).resize(nb_element * nb_quads);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::removeIntegrationPointsFromMap(
     const ElementTypeMapArray<UInt> & new_numbering, UInt nb_component,
     ElementTypeMapReal & element_map, const FEEngine & fee,
     const ElementKind el_kind) {
 
   for (auto gt : ghost_types) {
     for (auto type : new_numbering.elementTypes(_all_dimensions, gt, el_kind)) {
       if (element_map.exists(type, gt)) {
         const Array<UInt> & renumbering = new_numbering(type, gt);
 
         Array<Real> & vect = element_map(type, gt);
         UInt nb_quad_per_elem = fee.getNbIntegrationPoints(type, gt);
-        Array<Real> tmp(renumbering.getSize() * nb_quad_per_elem, nb_component);
+        Array<Real> tmp(renumbering.size() * nb_quad_per_elem, nb_component);
 
         AKANTU_DEBUG_ASSERT(
-            tmp.getSize() == vect.getSize(),
+            tmp.size() == vect.size(),
             "Something strange append some mater was created from nowhere!!");
 
         AKANTU_DEBUG_ASSERT(
-            tmp.getSize() == vect.getSize(),
+            tmp.size() == vect.size(),
             "Something strange append some mater was created or disappeared in "
-                << vect.getID() << "(" << vect.getSize()
-                << "!=" << tmp.getSize()
+                << vect.getID() << "(" << vect.size()
+                << "!=" << tmp.size()
                 << ") "
                    "!!");
 
         UInt new_size = 0;
-        for (UInt i = 0; i < renumbering.getSize(); ++i) {
+        for (UInt i = 0; i < renumbering.size(); ++i) {
           UInt new_i = renumbering(i);
           if (new_i != UInt(-1)) {
             memcpy(tmp.storage() + new_i * nb_component * nb_quad_per_elem,
                    vect.storage() + i * nb_component * nb_quad_per_elem,
                    nb_component * nb_quad_per_elem * sizeof(Real));
             ++new_size;
           }
         }
         tmp.resize(new_size * nb_quad_per_elem);
         vect.copy(tmp);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 UInt NonLocalManager::getNbData(const Array<Element> & elements,
                                 const ID & id) const {
   UInt size = 0;
   UInt nb_quadrature_points = this->model.getNbIntegrationPoints(elements);
   auto it = non_local_variables.find(id);
 
   AKANTU_DEBUG_ASSERT(it != non_local_variables.end(),
                       "The non-local variable " << id << " is not registered");
 
   size += it->second->nb_component * sizeof(Real) * nb_quadrature_points;
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::packData(CommunicationBuffer & buffer,
                                const Array<Element> & elements,
                                const ID & id) const {
 
   auto it = non_local_variables.find(id);
 
   AKANTU_DEBUG_ASSERT(it != non_local_variables.end(),
                       "The non-local variable " << id << " is not registered");
 
   DataAccessor<Element>::packElementalDataHelper<Real>(
       it->second->local, buffer, elements, true, this->model.getFEEngine());
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLocalManager::unpackData(CommunicationBuffer & buffer,
                                  const Array<Element> & elements,
                                  const ID & id) const {
   auto it = non_local_variables.find(id);
 
   AKANTU_DEBUG_ASSERT(it != non_local_variables.end(),
                       "The non-local variable " << id << " is not registered");
 
   DataAccessor<Element>::unpackElementalDataHelper<Real>(
       it->second->local, buffer, elements, true, this->model.getFEEngine());
 }
 
 } // namespace akantu
diff --git a/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh b/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
index f162363a1..aaf62126c 100644
--- a/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
+++ b/src/model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
@@ -1,276 +1,276 @@
 /**
  * @file   non_local_neighborhood_tmpl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Sep 28 2015
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Implementation of class non-local neighborhood
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_local_manager.hh"
 #include "non_local_neighborhood.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_NON_LOCAL_NEIGHBORHOOD_TMPL_HH__
 #define __AKANTU_NON_LOCAL_NEIGHBORHOOD_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 NonLocalNeighborhood<WeightFunction>::NonLocalNeighborhood(
     NonLocalManager & manager, const ElementTypeMapReal & quad_coordinates,
     const ID & id, const MemoryID & memory_id)
     : NonLocalNeighborhoodBase(manager.getModel(), quad_coordinates, id,
                                memory_id),
       non_local_manager(manager) {
   AKANTU_DEBUG_IN();
 
   this->weight_function =
       std::make_unique<WeightFunction>(manager);
 
   this->registerSubSection(_st_weight_function, "weight_parameter",
                            *weight_function);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 NonLocalNeighborhood<WeightFunction>::~NonLocalNeighborhood() = default;
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::computeWeights() {
   AKANTU_DEBUG_IN();
 
   this->weight_function->setRadius(this->neighborhood_radius);
   Vector<Real> q1_coord(this->spatial_dimension);
   Vector<Real> q2_coord(this->spatial_dimension);
 
   UInt nb_weights_per_pair = 2; /// w1: q1->q2, w2: q2->q1
 
   /// get the elementtypemap for the neighborhood volume for each quadrature
   /// point
   ElementTypeMapReal & quadrature_points_volumes =
       this->non_local_manager.getVolumes();
 
   /// update the internals of the weight function if applicable (not
   /// all the weight functions have internals and do noting in that
   /// case)
   weight_function->updateInternals();
 
   for (auto ghost_type : ghost_types) {
     /// allocate the array to store the weight, if it doesn't exist already
     if (!(pair_weight[ghost_type])) {
       pair_weight[ghost_type] =
           std::make_unique<Array<Real>>(0, nb_weights_per_pair);
     }
 
     /// resize the array to the correct size
     pair_weight[ghost_type]->resize(pair_list[ghost_type].size());
     /// set entries to zero
     pair_weight[ghost_type]->clear();
 
     /// loop over all pairs in the current pair list array and their
     /// corresponding weights
     PairList::const_iterator first_pair = pair_list[ghost_type].begin();
     PairList::const_iterator last_pair = pair_list[ghost_type].end();
     Array<Real>::vector_iterator weight_it =
         pair_weight[ghost_type]->begin(nb_weights_per_pair);
 
     // Compute the weights
     for (; first_pair != last_pair; ++first_pair, ++weight_it) {
       Vector<Real> & weight = *weight_it;
       const IntegrationPoint & q1 = first_pair->first;
       const IntegrationPoint & q2 = first_pair->second;
 
       /// get the coordinates for the given pair of quads
       Array<Real>::const_vector_iterator coords_type_1_it =
           this->quad_coordinates(q1.type, q1.ghost_type)
               .begin(this->spatial_dimension);
       q1_coord = coords_type_1_it[q1.global_num];
       Array<Real>::const_vector_iterator coords_type_2_it =
           this->quad_coordinates(q2.type, q2.ghost_type)
               .begin(this->spatial_dimension);
       q2_coord = coords_type_2_it[q2.global_num];
 
       Array<Real> & quad_volumes_1 =
           quadrature_points_volumes(q1.type, q1.ghost_type);
       const Array<Real> & jacobians_2 =
           this->non_local_manager.getJacobians(q2.type, q2.ghost_type);
       const Real & q2_wJ = jacobians_2(q2.global_num);
 
       /// compute distance between the two quadrature points
       Real r = q1_coord.distance(q2_coord);
 
       /// compute the weight for averaging on q1 based on the distance
       Real w1 = this->weight_function->operator()(r, q1, q2);
       weight(0) = q2_wJ * w1;
 
       quad_volumes_1(q1.global_num) += weight(0);
 
       if (q2.ghost_type != _ghost && q1.global_num != q2.global_num) {
         const Array<Real> & jacobians_1 =
             this->non_local_manager.getJacobians(q1.type, q1.ghost_type);
         Array<Real> & quad_volumes_2 =
             quadrature_points_volumes(q2.type, q2.ghost_type);
         /// compute the weight for averaging on q2
         const Real & q1_wJ = jacobians_1(q1.global_num);
         Real w2 = this->weight_function->operator()(r, q2, q1);
         weight(1) = q1_wJ * w2;
         quad_volumes_2(q2.global_num) += weight(1);
       } else
         weight(1) = 0.;
     }
   }
 
   ///  normalize the weights
   for (UInt gt = _not_ghost; gt <= _ghost; ++gt) {
     GhostType ghost_type2 = (GhostType)gt;
 
     PairList::const_iterator first_pair = pair_list[ghost_type2].begin();
     PairList::const_iterator last_pair = pair_list[ghost_type2].end();
 
     Array<Real>::vector_iterator weight_it =
         pair_weight[ghost_type2]->begin(nb_weights_per_pair);
 
     // Compute the weights
     for (; first_pair != last_pair; ++first_pair, ++weight_it) {
       Vector<Real> & weight = *weight_it;
 
       const IntegrationPoint & q1 = first_pair->first;
       const IntegrationPoint & q2 = first_pair->second;
 
       Array<Real> & quad_volumes_1 =
           quadrature_points_volumes(q1.type, q1.ghost_type);
       Array<Real> & quad_volumes_2 =
           quadrature_points_volumes(q2.type, q2.ghost_type);
 
       Real q1_volume = quad_volumes_1(q1.global_num);
 
       weight(0) *= 1. / q1_volume;
       if (ghost_type2 != _ghost) {
         Real q2_volume = quad_volumes_2(q2.global_num);
         weight(1) *= 1. / q2_volume;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::saveWeights(
     const std::string & filename) const {
   std::ofstream pout;
 
   std::stringstream sstr;
 
   const StaticCommunicator & comm = model.getMesh().getCommunicator();
 
   Int prank = comm.whoAmI();
   sstr << filename << "." << prank;
 
   pout.open(sstr.str().c_str());
 
   for (UInt gt = _not_ghost; gt <= _ghost; ++gt) {
     GhostType ghost_type = (GhostType)gt;
 
     AKANTU_DEBUG_ASSERT((pair_weight[ghost_type]),
                         "the weights have not been computed yet");
 
     Array<Real> & weights = *(pair_weight[ghost_type]);
     Array<Real>::const_vector_iterator weights_it = weights.begin(2);
-    for (UInt i = 0; i < weights.getSize(); ++i, ++weights_it)
+    for (UInt i = 0; i < weights.size(); ++i, ++weights_it)
       pout << "w1: " << (*weights_it)(0) << " w2: " << (*weights_it)(1)
            << std::endl;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::weightedAverageOnNeighbours(
     const ElementTypeMapReal & to_accumulate, ElementTypeMapReal & accumulated,
     UInt nb_degree_of_freedom, const GhostType & ghost_type2) const {
   AKANTU_DEBUG_IN();
   std::set<ID>::iterator it = non_local_variables.find(accumulated.getName());
   /// do averaging only for variables registered in the neighborhood
   if (it != non_local_variables.end()) {
     PairList::const_iterator first_pair = pair_list[ghost_type2].begin();
     PairList::const_iterator last_pair = pair_list[ghost_type2].end();
 
     Array<Real>::vector_iterator weight_it = pair_weight[ghost_type2]->begin(2);
 
     // Compute the weights
     for (; first_pair != last_pair; ++first_pair, ++weight_it) {
       Vector<Real> & weight = *weight_it;
 
       const IntegrationPoint & q1 = first_pair->first;
       const IntegrationPoint & q2 = first_pair->second;
 
       const Vector<Real> to_acc_1 =
           to_accumulate(q1.type, q1.ghost_type)
               .begin(nb_degree_of_freedom)[q1.global_num];
       const Vector<Real> to_acc_2 =
           to_accumulate(q2.type, q2.ghost_type)
               .begin(nb_degree_of_freedom)[q2.global_num];
       Vector<Real> acc_1 = accumulated(q1.type, q1.ghost_type)
                                .begin(nb_degree_of_freedom)[q1.global_num];
       Vector<Real> acc_2 = accumulated(q2.type, q2.ghost_type)
                                .begin(nb_degree_of_freedom)[q2.global_num];
 
       acc_1 += weight(0) * to_acc_2;
 
       if (ghost_type2 != _ghost) {
         acc_2 += weight(1) * to_acc_1;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 template <class WeightFunction>
 void NonLocalNeighborhood<WeightFunction>::updateWeights() {
   // Update the weights for the non local variable averaging
   if (this->weight_function->getUpdateRate() &&
       (this->non_local_manager.getNbStressCalls() %
            this->weight_function->getUpdateRate() ==
        0)) {
     this->synchronize(_gst_mnl_weight);
     this->computeWeights();
   }
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_NON_LOCAL_NEIGHBORHOOD_TMPL__ */
diff --git a/src/model/dof_manager.cc b/src/model/dof_manager.cc
index 68bb1c209..0cd583dae 100644
--- a/src/model/dof_manager.cc
+++ b/src/model/dof_manager.cc
@@ -1,597 +1,597 @@
 /**
  * @file   dof_manager.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 12 09:52:30 2015
  *
  * @brief  Implementation of the common parts of the DOFManagers
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 #include "element_group.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 #include "node_group.hh"
 #include "non_linear_solver.hh"
 #include "sparse_matrix.hh"
 #include "static_communicator.hh"
 #include "time_step_solver.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), mesh(nullptr), local_system_size(0),
       pure_local_system_size(0), system_size(0),
       communicator(StaticCommunicator::getStaticCommunicator()) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFManager(Mesh & mesh, const ID & id, const MemoryID & memory_id)
     : Memory(id, memory_id), mesh(&mesh), local_system_size(0),
       pure_local_system_size(0), system_size(0),
       communicator(mesh.getCommunicator()) {
   this->mesh->registerEventHandler(*this, _ehp_dof_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::~DOFManager() = default;
 
 /* -------------------------------------------------------------------------- */
 // void DOFManager::getEquationsNumbers(const ID &, Array<UInt> &) {
 //   AKANTU_DEBUG_TO_IMPLEMENT();
 // }
 
 /* -------------------------------------------------------------------------- */
 std::vector<ID> DOFManager::getDOFIDs() const {
   std::vector<ID> keys;
   for (const auto & dof_data : this->dofs)
     keys.push_back(dof_data.first);
 
   return keys;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayLocalArray(
     const Array<Real> & elementary_vect, Array<Real> & array_assembeled,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element;
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
 
   UInt * filter_it = NULL;
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
     filter_it = filter_elements.storage();
   } else {
     nb_element = this->mesh->getNbElement(type, ghost_type);
   }
 
-  AKANTU_DEBUG_ASSERT(elementary_vect.getSize() == nb_element,
+  AKANTU_DEBUG_ASSERT(elementary_vect.size() == nb_element,
                       "The vector elementary_vect("
                           << elementary_vect.getID()
                           << ") has not the good size.");
 
   const Array<UInt> & connectivity =
       this->mesh->getConnectivity(type, ghost_type);
   // Array<UInt>::const_vector_iterator conn_begin =
   //     connectivity.begin(nb_nodes_per_element);
   // Array<UInt>::const_vector_iterator conn_it = conn_begin;
 
   Array<Real>::const_matrix_iterator elem_it =
       elementary_vect.begin(nb_degree_of_freedom, nb_nodes_per_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++elem_it) {
     UInt element = el;
     if (filter_it != NULL) {
       // 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 != NULL)
       ++filter_it;
     //    else
     //      ++conn_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToResidual(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ElementType & type, const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToResidual(dof_id, array_localy_assembeled, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::assembleElementalArrayToLumpedMatrix(
     const ID & dof_id, const Array<Real> & elementary_vect,
     const ID & lumped_mtx, const ElementType & type,
     const GhostType & ghost_type, Real scale_factor,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_degree_of_freedom =
       elementary_vect.getNbComponent() / nb_nodes_per_element;
   Array<Real> array_localy_assembeled(this->mesh->getNbNodes(),
                                       nb_degree_of_freedom);
 
   array_localy_assembeled.clear();
 
   this->assembleElementalArrayLocalArray(
       elementary_vect, array_localy_assembeled, type, ghost_type, scale_factor,
       filter_elements);
 
   this->assembleToLumpedMatrix(dof_id, array_localy_assembeled, lumped_mtx, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData::DOFData(const ID & dof_id)
     : support_type(_dst_generic), group_support("__mesh__"), dof(NULL),
       blocked_dofs(NULL), increment(NULL), previous(NULL),
       solution(0, 1, dof_id + ":solution"),
       local_equation_number(0, 1, dof_id + ":local_equation_number") {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData::~DOFData() {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData & DOFManager::getNewDOFData(const ID & dof_id) {
   DOFStorage::iterator it = this->dofs.find(dof_id);
   if (it != this->dofs.end()) {
     AKANTU_EXCEPTION("This dof array has already been registered");
   }
 
   std::unique_ptr<DOFData> dofs_storage = std::make_unique<DOFData>(dof_id);
   this->dofs[dof_id] = std::move(dofs_storage);
   return *dofs_storage;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::registerDOFsInternal(const ID & dof_id,
                                       Array<Real> & dofs_array) {
   DOFData & dofs_storage = this->getDOFData(dof_id);
   dofs_storage.dof = &dofs_array;
 
   UInt nb_local_dofs = 0;
   UInt nb_pure_local = 0;
 
   const DOFSupportType & support_type = dofs_storage.support_type;
 
   switch (support_type) {
   case _dst_nodal: {
     UInt nb_nodes = 0;
     const ID & group = dofs_storage.group_support;
 
     NodeGroup * node_group = NULL;
     if (group == "__mesh__") {
       nb_nodes = this->mesh->getNbNodes();
     } else {
       node_group = &this->mesh->getElementGroup(group).getNodeGroup();
-      nb_nodes = node_group->getSize();
+      nb_nodes = node_group->size();
     }
 
     nb_local_dofs = nb_nodes;
     AKANTU_DEBUG_ASSERT(
-        dofs_array.getSize() == nb_local_dofs,
+        dofs_array.size() == nb_local_dofs,
         "The array of dof is too shot to be associated to nodes.");
 
     for (UInt n = 0; n < nb_nodes; ++n) {
       UInt node = n;
       if (node_group)
         node = node_group->getNodes()(n);
 
       nb_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
     }
 
     nb_pure_local *= dofs_array.getNbComponent();
     nb_local_dofs *= dofs_array.getNbComponent();
     break;
   }
   case _dst_generic: {
     nb_local_dofs = nb_pure_local =
-        dofs_array.getSize() * dofs_array.getNbComponent();
+        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;
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   comm.allReduce(nb_pure_local, _so_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 != NULL) {
     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 != NULL) {
     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, NULL);
   } else {
     if (derivatives[order - 1] != NULL) {
       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 != NULL) {
     AKANTU_EXCEPTION("The blocked dofs array for "
                      << dof_id << " has already been registered");
   }
 
   dof.blocked_dofs = &blocked_dofs;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::splitSolutionPerDOFs() {
   DOFStorage::iterator it = this->dofs.begin();
   DOFStorage::iterator end = this->dofs.end();
 
   for (; it != end; ++it) {
     DOFData & dof_data = *it->second;
-    dof_data.solution.resize(dof_data.dof->getSize() *
+    dof_data.solution.resize(dof_data.dof->size() *
                              dof_data.dof->getNbComponent());
     this->getSolutionPerDOFs(it->first, dof_data.solution);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix &
 DOFManager::registerSparseMatrix(const ID & matrix_id,
                                  std::unique_ptr<SparseMatrix> & matrix) {
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it != this->matrices.end()) {
     AKANTU_EXCEPTION("The matrix " << matrix_id << " already exists in "
                                    << this->id);
   }
 
   SparseMatrix & ret = *matrix;
   this->matrices[matrix_id] = std::move(matrix);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 /// Get an instance of a new SparseMatrix
 Array<Real> & DOFManager::getNewLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it != this->lumped_matrices.end()) {
     AKANTU_EXCEPTION("The lumped matrix " << matrix_id << " already exists in "
                                           << this->id);
   }
 
   auto mtx =
       std::make_unique<Array<Real>>(this->local_system_size, 1, matrix_id);
   this->lumped_matrices[matrix_id] = std::move(mtx);
   return *this->lumped_matrices[matrix_id];
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::registerNonLinearSolver(
     const ID & non_linear_solver_id,
     std::unique_ptr<NonLinearSolver> & non_linear_solver) {
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it != this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   NonLinearSolver & ret = *non_linear_solver;
   this->non_linear_solvers[non_linear_solver_id] = std::move(non_linear_solver);
 
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::registerTimeStepSolver(
     const ID & time_step_solver_id,
     std::unique_ptr<TimeStepSolver> & time_step_solver) {
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it != this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " already exists in "
                                               << this->id);
   }
 
   TimeStepSolver & ret = *time_step_solver;
   this->time_step_solvers[time_step_solver_id] = std::move(time_step_solver);
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManager::getMatrix(const ID & id) {
   ID matrix_id = this->id + ":mtx:" + id;
   SparseMatricesMap::const_iterator it = this->matrices.find(matrix_id);
   if (it == this->matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The matrix " << matrix_id << " does not exists in "
                                           << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasMatrix(const ID & id) const {
   ID mtx_id = this->id + ":mtx:" + id;
   SparseMatricesMap::const_iterator it = this->matrices.find(mtx_id);
   return it != this->matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & DOFManager::getLumpedMatrix(const ID & id) {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManager::getLumpedMatrix(const ID & id) const {
   ID matrix_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(matrix_id);
   if (it == this->lumped_matrices.end()) {
     AKANTU_SILENT_EXCEPTION("The lumped matrix "
                             << matrix_id << " does not exists in " << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasLumpedMatrix(const ID & id) const {
   ID mtx_id = this->id + ":lumped_mtx:" + id;
   LumpedMatricesMap::const_iterator it = this->lumped_matrices.find(mtx_id);
   return it != this->lumped_matrices.end();
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & DOFManager::getNonLinearSolver(const ID & id) {
   ID non_linear_solver_id = this->id + ":nls:" + id;
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(non_linear_solver_id);
   if (it == this->non_linear_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << non_linear_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasNonLinearSolver(const ID & id) const {
   ID solver_id = this->id + ":nls:" + id;
   NonLinearSolversMap::const_iterator it =
       this->non_linear_solvers.find(solver_id);
   return it != this->non_linear_solvers.end();
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManager::getTimeStepSolver(const ID & id) {
   ID time_step_solver_id = this->id + ":tss:" + id;
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   if (it == this->time_step_solvers.end()) {
     AKANTU_EXCEPTION("The non linear solver " << time_step_solver_id
                                               << " does not exists in "
                                               << this->id);
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFManager::hasTimeStepSolver(const ID & solver_id) const {
   ID time_step_solver_id = this->id + ":tss:" + solver_id;
   TimeStepSolversMap::const_iterator it =
       this->time_step_solvers.find(time_step_solver_id);
   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.getSize();
+  nb_new_local_dofs = nodes_list.size();
   for (const auto & node : nodes_list) {
     nb_new_pure_local += this->mesh->isLocalOrMasterNode(node) ? 1 : 0;
   }
 
   const auto & dof_array = *dof_data.dof;
   nb_new_pure_local *= dof_array.getNbComponent();
   nb_new_local_dofs *= dof_array.getNbComponent();
 
   this->pure_local_system_size += nb_new_pure_local;
   this->local_system_size += nb_new_local_dofs;
 
   UInt nb_new_global = nb_new_pure_local;
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   comm.allReduce(nb_new_global, _so_sum);
 
   this->system_size += nb_new_global;
 
   return std::make_pair(nb_new_local_dofs, nb_new_pure_local);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManager::onNodesAdded(const Array<UInt> & nodes_list,
                               const NewNodesEvent &) {
   for (auto & pair : this->dofs) {
     const auto & dof_id = pair.first;
     auto & dof_data = this->getDOFData(dof_id);
     if (dof_data.support_type != _dst_nodal)
       continue;
 
     const auto & group = dof_data.group_support;
 
     if (group == "__mesh__") {
       this->updateNodalDOFs(dof_id, nodes_list);
     } else {
       const auto & node_group =
           this->mesh->getElementGroup(group).getNodeGroup();
       Array<UInt> new_nodes_list;
       for (const auto & node : nodes_list) {
-        if (node_group.find(node) != -1)
+        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_default.cc b/src/model/dof_manager_default.cc
index 0f5ee63ae..5e7e2312b 100644
--- a/src/model/dof_manager_default.cc
+++ b/src/model/dof_manager_default.cc
@@ -1,917 +1,913 @@
 /**
  * @file   dof_manager_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 11 16:21:01 2015
  *
  * @brief  Implementation of the default DOFManager
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "element_group.hh"
 #include "node_synchronizer.hh"
 #include "non_linear_solver_default.hh"
 #include "sparse_matrix_aij.hh"
 #include "static_communicator.hh"
 #include "terms_to_assemble.hh"
 #include "time_step_solver_default.hh"
 /* -------------------------------------------------------------------------- */
+#include <algorithm>
 #include <memory>
 #include <numeric>
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addSymmetricElementalMatrixToSymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = i; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           matrix(c_irn, c_jcn) += elementary_mat(i, j);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addUnsymmetricElementalMatrixToSymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = 0; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           if (c_jcn >= c_irn) {
             matrix(c_irn, c_jcn) += elementary_mat(i, j);
           }
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void DOFManagerDefault::addElementalMatrixToUnsymmetric(
     SparseMatrixAIJ & matrix, const Matrix<Real> & elementary_mat,
     const Vector<UInt> & equation_numbers, UInt max_size) {
   for (UInt i = 0; i < elementary_mat.rows(); ++i) {
     UInt c_irn = equation_numbers(i);
     if (c_irn < max_size) {
       for (UInt j = 0; j < elementary_mat.cols(); ++j) {
         UInt c_jcn = equation_numbers(j);
         if (c_jcn < max_size) {
           matrix(c_irn, c_jcn) += elementary_mat(i, j);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(const ID & id, const MemoryID & memory_id)
     : DOFManager(id, memory_id), residual(0, 1, std::string(id + ":residual")),
       global_residual(nullptr),
       global_solution(0, 1, std::string(id + ":global_solution")),
       global_blocked_dofs(0, 1, std::string(id + ":global_blocked_dofs")),
       previous_global_blocked_dofs(
           0, 1, std::string(id + ":previous_global_blocked_dofs")),
       dofs_type(0, 1, std::string(id + ":dofs_type")),
       data_cache(0, 1, std::string(id + ":data_cache_array")),
       jacobian_release(0),
       global_equation_number(0, 1, "global_equation_number"),
       first_global_dof_id(0), synchronizer(nullptr) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(Mesh & mesh, const ID & id,
                                      const MemoryID & memory_id)
     : DOFManager(mesh, id, memory_id),
       residual(0, 1, std::string(id + ":residual")), global_residual(nullptr),
       global_solution(0, 1, std::string(id + ":global_solution")),
       global_blocked_dofs(0, 1, std::string(id + ":global_blocked_dofs")),
       previous_global_blocked_dofs(
           0, 1, std::string(id + ":previous_global_blocked_dofs")),
       dofs_type(0, 1, std::string(id + ":dofs_type")),
       data_cache(0, 1, std::string(id + ":data_cache_array")),
       jacobian_release(0),
       global_equation_number(0, 1, "global_equation_number"),
       first_global_dof_id(0), synchronizer(nullptr) {
   if (this->mesh->isDistributed())
     this->synchronizer = std::make_unique<DOFSynchronizer>(
         *this, this->id + ":dof_synchronizer", this->memory_id, communicator);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::~DOFManagerDefault() = default;
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::assembleToGlobalArray(
     const ID & dof_id, const Array<T> & array_to_assemble,
     Array<T> & global_array, T scale_factor) {
   AKANTU_DEBUG_IN();
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
 
   UInt nb_degree_of_freedoms =
-      array_to_assemble.getSize() * array_to_assemble.getNbComponent();
+      array_to_assemble.size() * array_to_assemble.getNbComponent();
 
-  AKANTU_DEBUG_ASSERT(equation_number.getSize() == nb_degree_of_freedoms,
+  AKANTU_DEBUG_ASSERT(equation_number.size() == nb_degree_of_freedoms,
                       "The array to assemble does not have a correct size."
                           << " (" << array_to_assemble.getID() << ")");
 
   typename Array<T>::const_scalar_iterator arr_it =
       array_to_assemble.begin_reinterpret(nb_degree_of_freedoms);
   Array<UInt>::const_scalar_iterator equ_it = equation_number.begin();
 
   for (UInt d = 0; d < nb_degree_of_freedoms; ++d, ++arr_it, ++equ_it) {
     global_array(*equ_it) += scale_factor * (*arr_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFDataDefault::DOFDataDefault(const ID & dof_id)
     : DOFData(dof_id), associated_nodes(0, 1, dof_id + "associated_nodes") {}
 
 /* -------------------------------------------------------------------------- */
 DOFManager::DOFData & DOFManagerDefault::getNewDOFData(const ID & dof_id) {
   this->dofs[dof_id] = std::make_unique<DOFDataDefault>(dof_id);
   return *this->dofs[dof_id];
 }
 
 /* -------------------------------------------------------------------------- */
 class GlobalDOFInfoDataAccessor : public DataAccessor<UInt> {
 public:
   typedef
       typename std::unordered_map<UInt, std::vector<UInt>>::size_type size_type;
 
   GlobalDOFInfoDataAccessor() = default;
 
   void addDOFToNode(UInt node, UInt dof) { dofs_per_node[node].push_back(dof); }
   UInt getNthDOFForNode(UInt nth_dof, UInt node) const {
     return dofs_per_node.find(node)->second[nth_dof];
   }
 
   virtual UInt getNbData(const Array<UInt> & nodes,
                          const SynchronizationTag & tag) const {
     if (tag == _gst_size) {
-      return nodes.getSize() * sizeof(size_type);
+      return nodes.size() * sizeof(size_type);
     }
 
     if (tag == _gst_update) {
       UInt total_size = 0;
       for (auto node : nodes) {
         auto it = dofs_per_node.find(node);
         if (it != dofs_per_node.end())
           total_size += CommunicationBuffer::sizeInBuffer(it->second);
       }
       return total_size;
     }
 
     return 0;
   }
 
   virtual void packData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                         const SynchronizationTag & tag) const {
     for (auto node : nodes) {
       auto it = dofs_per_node.find(node);
       if (tag == _gst_size) {
         if (it != dofs_per_node.end()) {
           buffer << it->second.size();
         } else {
           buffer << 0;
         }
       } else if (tag == _gst_update) {
         if (it != dofs_per_node.end())
           buffer << it->second;
       }
     }
   }
 
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<UInt> & nodes,
                           const SynchronizationTag & tag) {
     for (auto node : nodes) {
       auto it = dofs_per_node.find(node);
       if (tag == _gst_size) {
         size_type size;
         buffer >> size;
         if (size != 0)
           dofs_per_node[node].resize(size);
       } else if (tag == _gst_update) {
         if (it != dofs_per_node.end())
           buffer >> it->second;
       }
     }
   }
 
 protected:
   std::unordered_map<UInt, std::vector<UInt>> dofs_per_node;
 };
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFsInternal(const ID & dof_id, UInt nb_dofs,
                                              UInt nb_pure_local_dofs) {
   // auto prank = this->communicator.whoAmI();
   // auto psize = this->communicator.getNbProc();
 
   // access the relevant data to update
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   const auto & support_type = dof_data.support_type;
 
   const auto & group = dof_data.group_support;
 
   if (support_type == _dst_nodal and group != "__mesh__") {
     auto & support_nodes =
         this->mesh->getElementGroup(group).getNodeGroup().getNodes();
     this->updateDOFsData(
         dof_data, nb_dofs, nb_pure_local_dofs,
         [&support_nodes](UInt node) -> UInt { return support_nodes[node]; });
   } else {
 
     this->updateDOFsData(dof_data, nb_dofs, nb_pure_local_dofs,
                          [](UInt node) -> UInt { return node; });
   }
 
   // update the synchronizer if needed
   if (this->synchronizer)
     this->synchronizer->registerDOFs(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFs(const ID & dof_id,
                                      Array<Real> & dofs_array,
                                      const DOFSupportType & support_type) {
   // stores the current numbers of dofs
   UInt nb_dofs_old = this->local_system_size;
   UInt nb_pure_local_dofs_old = this->pure_local_system_size;
 
   // update or create the dof_data
   DOFManager::registerDOFs(dof_id, dofs_array, support_type);
 
   UInt nb_dofs = this->local_system_size - nb_dofs_old;
   UInt nb_pure_local_dofs =
       this->pure_local_system_size - nb_pure_local_dofs_old;
 
   this->registerDOFsInternal(dof_id, nb_dofs, nb_pure_local_dofs);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::registerDOFs(const ID & dof_id,
                                      Array<Real> & dofs_array,
                                      const ID & group_support) {
   // stores the current numbers of dofs
   UInt nb_dofs_old = this->local_system_size;
   UInt nb_pure_local_dofs_old = this->pure_local_system_size;
 
   // update or create the dof_data
   DOFManager::registerDOFs(dof_id, dofs_array, group_support);
 
   UInt nb_dofs = this->local_system_size - nb_dofs_old;
   UInt nb_pure_local_dofs =
       this->pure_local_system_size - nb_pure_local_dofs_old;
 
   this->registerDOFsInternal(dof_id, nb_dofs, nb_pure_local_dofs);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const MatrixType & matrix_type) {
   ID matrix_id = this->id + ":mtx:" + id;
   std::unique_ptr<SparseMatrix> sm =
       std::make_unique<SparseMatrixAIJ>(*this, matrix_type, matrix_id);
   return this->registerSparseMatrix(matrix_id, sm);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const ID & matrix_to_copy_id) {
 
   ID matrix_id = this->id + ":mtx:" + id;
   SparseMatrixAIJ & sm_to_copy = this->getMatrix(matrix_to_copy_id);
   std::unique_ptr<SparseMatrix> sm =
       std::make_unique<SparseMatrixAIJ>(sm_to_copy, matrix_id);
   return this->registerSparseMatrix(matrix_id, sm);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ & DOFManagerDefault::getMatrix(const ID & id) {
   SparseMatrix & matrix = DOFManager::getMatrix(id);
 
   return dynamic_cast<SparseMatrixAIJ &>(matrix);
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver &
 DOFManagerDefault::getNewNonLinearSolver(const ID & id,
                                          const NonLinearSolverType & type) {
   ID non_linear_solver_id = this->id + ":nls:" + id;
   std::unique_ptr<NonLinearSolver> nls;
   switch (type) {
 #if defined(AKANTU_IMPLICIT)
   case _nls_newton_raphson:
   case _nls_newton_raphson_modified: {
     nls = std::make_unique<NonLinearSolverNewtonRaphson>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
   case _nls_linear: {
     nls = std::make_unique<NonLinearSolverLinear>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
 #endif
   case _nls_lumped: {
     nls = std::make_unique<NonLinearSolverLumped>(
         *this, type, non_linear_solver_id, this->memory_id);
     break;
   }
   default:
     AKANTU_EXCEPTION("The asked type of non linear solver is not supported by "
                      "this dof manager");
   }
 
   return this->registerNonLinearSolver(non_linear_solver_id, nls);
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver &
 DOFManagerDefault::getNewTimeStepSolver(const ID & id,
                                         const TimeStepSolverType & type,
                                         NonLinearSolver & non_linear_solver) {
   ID time_step_solver_id = this->id + ":tss:" + id;
 
   std::unique_ptr<TimeStepSolver> tss = std::make_unique<TimeStepSolverDefault>(
       *this, type, non_linear_solver, time_step_solver_id, this->memory_id);
 
   return this->registerTimeStepSolver(time_step_solver_id, tss);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearResidual() {
   this->residual.resize(this->local_system_size);
   this->residual.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearMatrix(const ID & mtx) {
   this->getMatrix(mtx).clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::clearLumpedMatrix(const ID & mtx) {
   this->getLumpedMatrix(mtx).clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::updateGlobalBlockedDofs() {
   DOFStorage::iterator it = this->dofs.begin();
   DOFStorage::iterator end = this->dofs.end();
 
   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.getSize();
+  UInt nb_degree_of_freedoms = equation_number.size();
   local_array.resize(nb_degree_of_freedoms / local_array.getNbComponent());
 
   auto loc_it = local_array.begin_reinterpret(nb_degree_of_freedoms);
   auto equ_it = equation_number.begin();
 
   for (UInt d = 0; d < nb_degree_of_freedoms; ++d, ++loc_it, ++equ_it) {
     (*loc_it) = global_array(*equ_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 // void DOFManagerDefault::getEquationsNumbers(const ID & dof_id,
 //                                             Array<UInt> & equation_numbers) {
 //   AKANTU_DEBUG_IN();
 //   this->getArrayPerDOFs(dof_id, this->global_equation_number,
 //   equation_numbers); AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::getSolutionPerDOFs(const ID & dof_id,
                                            Array<Real> & solution_array) {
   AKANTU_DEBUG_IN();
   this->getArrayPerDOFs(dof_id, this->global_solution, solution_array);
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::getLumpedMatrixPerDOFs(const ID & dof_id,
                                                const ID & lumped_mtx,
                                                Array<Real> & lumped) {
   AKANTU_DEBUG_IN();
   this->getArrayPerDOFs(dof_id, this->getLumpedMatrix(lumped_mtx), lumped);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleToResidual(
     const ID & dof_id, const Array<Real> & array_to_assemble,
     Real scale_factor) {
   AKANTU_DEBUG_IN();
 
   this->assembleToGlobalArray(dof_id, array_to_assemble, this->residual,
                               scale_factor);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleToLumpedMatrix(
     const ID & dof_id, const Array<Real> & array_to_assemble,
     const ID & lumped_mtx, Real scale_factor) {
   AKANTU_DEBUG_IN();
 
   Array<Real> & lumped = this->getLumpedMatrix(lumped_mtx);
   this->assembleToGlobalArray(dof_id, array_to_assemble, lumped, scale_factor);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleMatMulVectToResidual(const ID & dof_id,
                                                      const ID & A_id,
                                                      const Array<Real> & x,
                                                      Real scale_factor) {
   SparseMatrixAIJ & A = this->getMatrix(A_id);
 
   // Array<Real> data_cache(this->local_system_size, 1, 0.);
   this->data_cache.resize(this->local_system_size);
   this->data_cache.clear();
 
   this->assembleToGlobalArray(dof_id, x, data_cache, 1.);
 
   A.matVecMul(data_cache, this->residual, scale_factor, 1.);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleLumpedMatMulVectToResidual(
     const ID & dof_id, const ID & A_id, const Array<Real> & x,
     Real scale_factor) {
   const Array<Real> & A = this->getLumpedMatrix(A_id);
 
   //  Array<Real> data_cache(this->local_system_size, 1, 0.);
   this->data_cache.resize(this->local_system_size);
   this->data_cache.clear();
 
   this->assembleToGlobalArray(dof_id, x, data_cache, scale_factor);
 
   Array<Real>::const_scalar_iterator A_it = A.begin();
   Array<Real>::const_scalar_iterator A_end = A.end();
   Array<Real>::const_scalar_iterator x_it = data_cache.begin();
   Array<Real>::scalar_iterator r_it = this->residual.begin();
 
   for (; A_it != A_end; ++A_it, ++x_it, ++r_it) {
     *r_it += *A_it * *x_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleElementalMatricesToMatrix(
     const ID & matrix_id, const ID & dof_id, const Array<Real> & elementary_mat,
     const ElementType & type, const GhostType & ghost_type,
     const MatrixType & elemental_matrix_type,
     const Array<UInt> & filter_elements) {
   AKANTU_DEBUG_IN();
 
   DOFData & dof_data = this->getDOFData(dof_id);
 
   AKANTU_DEBUG_ASSERT(dof_data.support_type == _dst_nodal,
                       "This function applies only on Nodal dofs");
 
   this->addToProfile(matrix_id, dof_id, type, ghost_type);
 
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
   SparseMatrixAIJ & A = this->getMatrix(matrix_id);
 
   UInt nb_element;
   if (ghost_type == _not_ghost) {
     nb_element = this->mesh->getNbElement(type);
   } else {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   UInt * filter_it = nullptr;
   if (filter_elements != empty_filter) {
-    nb_element = filter_elements.getSize();
+    nb_element = filter_elements.size();
     filter_it = filter_elements.storage();
   } else {
     if (dof_data.group_support != "__mesh__") {
       const Array<UInt> & group_elements =
           this->mesh->getElementGroup(dof_data.group_support)
               .getElements(type, ghost_type);
-      nb_element = group_elements.getSize();
+      nb_element = group_elements.size();
       filter_it = group_elements.storage();
     } else {
       nb_element = this->mesh->getNbElement(type, ghost_type);
     }
   }
 
-  AKANTU_DEBUG_ASSERT(elementary_mat.getSize() == nb_element,
+  AKANTU_DEBUG_ASSERT(elementary_mat.size() == nb_element,
                       "The vector elementary_mat("
                           << elementary_mat.getID()
                           << ") has not the good size.");
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   UInt nb_degree_of_freedom = dof_data.dof->getNbComponent();
 
   const Array<UInt> & connectivity =
       this->mesh->getConnectivity(type, ghost_type);
   auto conn_begin = connectivity.begin(nb_nodes_per_element);
   auto conn_it = conn_begin;
 
   UInt size_mat = nb_nodes_per_element * nb_degree_of_freedom;
 
   Vector<UInt> element_eq_nb(nb_degree_of_freedom * nb_nodes_per_element);
   Array<Real>::const_matrix_iterator el_mat_it =
       elementary_mat.begin(size_mat, size_mat);
 
   for (UInt e = 0; e < nb_element; ++e, ++el_mat_it) {
     if (filter_it)
       conn_it = conn_begin + *filter_it;
 
     this->extractElementEquationNumber(equation_number, *conn_it,
                                        nb_degree_of_freedom, element_eq_nb);
     std::transform(element_eq_nb.storage(),
                    element_eq_nb.storage() + element_eq_nb.size(),
                    element_eq_nb.storage(), [&](UInt & local) -> UInt {
                      return this->localToGlobalEquationNumber(local);
                    });
 
     if (filter_it)
       ++filter_it;
     else
       ++conn_it;
 
     if (A.getMatrixType() == _symmetric)
       if (elemental_matrix_type == _symmetric)
         this->addSymmetricElementalMatrixToSymmetric(
-            A, *el_mat_it, element_eq_nb, A.getSize());
+            A, *el_mat_it, element_eq_nb, A.size());
       else
         this->addUnsymmetricElementalMatrixToSymmetric(
-            A, *el_mat_it, element_eq_nb, A.getSize());
+            A, *el_mat_it, element_eq_nb, A.size());
     else
       this->addElementalMatrixToUnsymmetric(A, *el_mat_it, element_eq_nb,
-                                            A.getSize());
+                                            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.addToMatrix(gi, gj, term);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::addToProfile(const ID & matrix_id, const ID & dof_id,
                                      const ElementType & type,
                                      const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   const DOFData & dof_data = this->getDOFData(dof_id);
 
   if (dof_data.support_type != _dst_nodal)
     return;
 
   auto mat_dof = std::make_pair(matrix_id, dof_id);
   auto type_pair = std::make_pair(type, ghost_type);
 
   auto prof_it = this->matrix_profiled_dofs.find(mat_dof);
   if (prof_it != this->matrix_profiled_dofs.end() &&
       std::find(prof_it->second.begin(), prof_it->second.end(), type_pair) !=
           prof_it->second.end())
     return;
 
   UInt nb_degree_of_freedom_per_node = dof_data.dof->getNbComponent();
 
   const Array<UInt> & equation_number = this->getLocalEquationNumbers(dof_id);
 
   SparseMatrixAIJ & A = this->getMatrix(matrix_id);
 
-  UInt size = A.getSize();
+  UInt size = A.size();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   const auto & connectivity = this->mesh->getConnectivity(type, ghost_type);
   auto cbegin = connectivity.begin(nb_nodes_per_element);
   auto cit = cbegin;
 
-  UInt nb_elements = connectivity.getSize();
+  UInt nb_elements = connectivity.size();
   UInt * ge_it = nullptr;
   if (dof_data.group_support != "__mesh__") {
     const Array<UInt> & group_elements =
         this->mesh->getElementGroup(dof_data.group_support)
             .getElements(type, ghost_type);
     ge_it = group_elements.storage();
-    nb_elements = group_elements.getSize();
+    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.addToProfile(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()) {
-    Array<bool>::const_scalar_iterator it = global_blocked_dofs.begin();
-    Array<bool>::const_scalar_iterator end = global_blocked_dofs.end();
+    auto are_equal =
+        std::equal(global_blocked_dofs.begin(), global_blocked_dofs.end(),
+                   previous_global_blocked_dofs.begin());
 
-    Array<bool>::const_scalar_iterator pit =
-        previous_global_blocked_dofs.begin();
-
-    for (; it != end && *it == *pit; ++it, ++pit)
-      ;
-
-    if (it != end)
+    if (are_equal)
       J.applyBoundary();
 
     previous_global_blocked_dofs.copy(global_blocked_dofs);
   } else {
     J.applyBoundary();
   }
 
   this->jacobian_release = J.getValueRelease();
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManagerDefault::getGlobalResidual() {
   if (this->synchronizer) {
     if (not this->global_residual) {
       this->global_residual =
           std::make_unique<Array<Real>>(0, 1, "global_residual");
     }
 
     if (this->synchronizer->getCommunicator().whoAmI() == 0) {
       this->global_residual->resize(this->system_size);
       this->synchronizer->gather(this->residual, *this->global_residual);
     } else {
       this->synchronizer->gather(this->residual);
     }
 
     return *this->global_residual;
   } else {
     return this->residual;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManagerDefault::getResidual() const {
   return this->residual;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::setGlobalSolution(const Array<Real> & solution) {
   if (this->synchronizer) {
     if (this->synchronizer->getCommunicator().whoAmI() == 0) {
       this->synchronizer->scatter(this->global_solution, solution);
     } else {
       this->synchronizer->scatter(this->global_solution);
     }
   } else {
-    AKANTU_DEBUG_ASSERT(solution.getSize() == this->global_solution.getSize(),
+    AKANTU_DEBUG_ASSERT(solution.size() == this->global_solution.size(),
                         "Sequential call to this function needs the solution "
                         "to be the same size as the global_solution");
     this->global_solution.copy(solution);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::onNodesAdded(const Array<UInt> & nodes_list,
                                      const NewNodesEvent & event) {
   DOFManager::onNodesAdded(nodes_list, event);
 
   if (this->synchronizer)
     this->synchronizer->onNodesAdded(nodes_list);
 }
 
 /* -------------------------------------------------------------------------- */
 std::pair<UInt, UInt>
 DOFManagerDefault::updateNodalDOFs(const ID & dof_id,
                                    const Array<UInt> & nodes_list) {
   UInt nb_new_local_dofs, nb_new_pure_local;
   std::tie(nb_new_local_dofs, nb_new_pure_local) =
       DOFManager::updateNodalDOFs(dof_id, nodes_list);
 
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   updateDOFsData(dof_data, nb_new_local_dofs, nb_new_pure_local,
                  [&nodes_list](UInt pos) -> UInt { return nodes_list[pos]; });
 
   return std::make_pair(nb_new_local_dofs, nb_new_pure_local);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::updateDOFsData(DOFDataDefault & dof_data,
                                        UInt nb_new_local_dofs,
                                        UInt nb_new_pure_local,
                                        std::function<UInt(UInt)> getNode) {
   auto prank = this->communicator.whoAmI();
   auto psize = this->communicator.getNbProc();
 
   // access the relevant data to update
   const auto & support_type = dof_data.support_type;
 
   GlobalDOFInfoDataAccessor data_accessor;
 
   // resize all relevant arrays
   this->residual.resize(this->local_system_size);
   this->dofs_type.resize(this->local_system_size);
   this->global_solution.resize(this->local_system_size);
   this->global_blocked_dofs.resize(this->local_system_size);
   this->previous_global_blocked_dofs.resize(this->local_system_size);
   this->global_equation_number.resize(this->local_system_size);
 
   for (auto & lumped_matrix : lumped_matrices)
     lumped_matrix.second->resize(this->local_system_size);
 
   dof_data.local_equation_number.reserve(
-      dof_data.local_equation_number.getSize() + nb_new_local_dofs);
+      dof_data.local_equation_number.size() + nb_new_local_dofs);
 
   // determine the first local/global dof id to use
   Array<UInt> nb_dofs_per_proc(psize);
   nb_dofs_per_proc(prank) = nb_new_pure_local;
   this->communicator.allGather(nb_dofs_per_proc);
 
   this->first_global_dof_id += std::accumulate(
       nb_dofs_per_proc.begin(), nb_dofs_per_proc.begin() + prank, 0);
   UInt first_dof_id = this->local_system_size - nb_new_local_dofs;
 
   if (support_type == _dst_nodal) {
-    dof_data.associated_nodes.reserve(dof_data.associated_nodes.getSize() +
+    dof_data.associated_nodes.reserve(dof_data.associated_nodes.size() +
                                       nb_new_local_dofs);
   }
 
   // update per dof info
   for (UInt d = 0; d < nb_new_local_dofs; ++d) {
     UInt local_eq_num = first_dof_id + d;
     dof_data.local_equation_number.push_back(local_eq_num);
 
     bool is_local_dof = true;
 
     // determine the dof type
     switch (support_type) {
     case _dst_nodal: {
       UInt node = getNode(d / dof_data.dof->getNbComponent());
 
       this->dofs_type(local_eq_num) = this->mesh->getNodeType(node);
       dof_data.associated_nodes.push_back(node);
 
       is_local_dof = this->mesh->isLocalOrMasterNode(node);
 
       if (is_local_dof) {
         data_accessor.addDOFToNode(node, first_global_dof_id);
       }
 
       break;
     }
     case _dst_generic: {
       this->dofs_type(local_eq_num) = _nt_normal;
       break;
     }
     default: { AKANTU_EXCEPTION("This type of dofs is not handled yet."); }
     }
 
     // update global id for local dofs
     if (is_local_dof) {
       this->global_equation_number(local_eq_num) = this->first_global_dof_id;
       this->global_to_local_mapping[this->first_global_dof_id] = local_eq_num;
       ++this->first_global_dof_id;
     } else {
       this->global_equation_number(local_eq_num) = 0;
     }
   }
 
   // synchronize the global numbering for slaves
   if (support_type == _dst_nodal && this->synchronizer) {
     auto nb_dofs_per_node = dof_data.dof->getNbComponent();
 
     auto & node_synchronizer = this->mesh->getNodeSynchronizer();
     node_synchronizer.synchronizeOnce(data_accessor, _gst_size);
     node_synchronizer.synchronizeOnce(data_accessor, _gst_update);
 
     std::vector<UInt> counters(nb_new_local_dofs / nb_dofs_per_node);
 
     for (UInt d = 0; d < nb_new_local_dofs; ++d) {
       UInt local_eq_num = first_dof_id + d;
       if (not this->isSlaveDOF(local_eq_num))
         continue;
 
       UInt node = d / nb_dofs_per_node;
       UInt dof_count = counters[node]++;
       node = getNode(node);
 
       UInt global_dof_id = data_accessor.getNthDOFForNode(dof_count, node);
 
       this->global_equation_number(local_eq_num) = global_dof_id;
       this->global_to_local_mapping[global_dof_id] = local_eq_num;
     }
   }
 }
 
 } // namespace akantu
 
 //  LocalWords:  dof dofs
diff --git a/src/model/heat_transfer/heat_transfer_model.cc b/src/model/heat_transfer/heat_transfer_model.cc
index e77a516fd..fe9ea60d0 100644
--- a/src/model/heat_transfer/heat_transfer_model.cc
+++ b/src/model/heat_transfer/heat_transfer_model.cc
@@ -1,1282 +1,1282 @@
 /**
  * @file   heat_transfer_model.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Srinivasa Babu Ramisetti <srinivasa.ramisetti@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Rui Wang <rui.wang@epfl.ch>
  *
  * @date creation: Sun May 01 2011
  * @date last modification: Mon Nov 30 2015
  *
  * @brief  Implementation of HeatTransferModel class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "heat_transfer_model.hh"
 #include "group_manager_inline_impl.cc"
 #include "dumpable_inline_impl.hh"
 #include "aka_math.hh"
 #include "aka_common.hh"
 #include "fe_engine_template.hh"
 #include "mesh.hh"
 #include "static_communicator.hh"
 #include "parser.hh"
 #include "generalized_trapezoidal.hh"
 
 #ifdef AKANTU_USE_MUMPS
 #include "solver_mumps.hh"
 #endif
 
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_paraview.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_element_partition.hh"
 #include "dumper_internal_material_field.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 const HeatTransferModelOptions
     default_heat_transfer_model_options(_explicit_lumped_capacity);
 
 /* -------------------------------------------------------------------------- */
 HeatTransferModel::HeatTransferModel(Mesh & mesh, UInt dim, const ID & id,
                                      const MemoryID & memory_id)
     : Model(mesh, dim, id, memory_id), Parsable(_st_heat, id), integrator(NULL),
       conductivity_matrix(NULL), capacity_matrix(NULL), jacobian_matrix(NULL),
       temperature_gradient("temperature_gradient", id),
       temperature_on_qpoints("temperature_on_qpoints", id),
       conductivity_on_qpoints("conductivity_on_qpoints", id),
       k_gradt_on_qpoints("k_gradt_on_qpoints", id),
       int_bt_k_gT("int_bt_k_gT", id), bt_k_gT("bt_k_gT", id),
       conductivity(spatial_dimension, spatial_dimension),
       thermal_energy("thermal_energy", id), solver(NULL), pbc_synch(NULL) {
   AKANTU_DEBUG_IN();
 
   createSynchronizerRegistry(this);
 
   std::stringstream sstr;
   sstr << id << ":fem";
   registerFEEngineObject<MyFEEngineType>(sstr.str(), mesh, spatial_dimension);
 
   this->temperature = NULL;
   this->residual = NULL;
   this->blocked_dofs = NULL;
 
 #ifdef AKANTU_USE_IOHELPER
   this->mesh.registerDumper<DumperParaview>("paraview_all", id, true);
   this->mesh.addDumpMesh(mesh, spatial_dimension, _not_ghost, _ek_regular);
 #endif
 
   this->registerParam("conductivity", conductivity, _pat_parsmod);
   this->registerParam("conductivity_variation", conductivity_variation, 0.,
                       _pat_parsmod);
   this->registerParam("temperature_reference", T_ref, 0., _pat_parsmod);
   this->registerParam("capacity", capacity, _pat_parsmod);
   this->registerParam("density", density, _pat_parsmod);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initModel() {
   getFEEngine().initShapeFunctions(_not_ghost);
   getFEEngine().initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initParallel(MeshPartition * partition,
                                      DataAccessor * data_accessor) {
   AKANTU_DEBUG_IN();
 
   if (data_accessor == NULL)
     data_accessor = this;
   Synchronizer & synch_parallel = createParallelSynch(partition, data_accessor);
 
   synch_registry->registerSynchronizer(synch_parallel, _gst_htm_capacity);
   synch_registry->registerSynchronizer(synch_parallel, _gst_htm_temperature);
   synch_registry->registerSynchronizer(synch_parallel,
                                        _gst_htm_gradient_temperature);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initPBC() {
   AKANTU_DEBUG_IN();
 
   Model::initPBC();
   pbc_synch = new PBCSynchronizer(pbc_pair);
 
   synch_registry->registerSynchronizer(*pbc_synch, _gst_htm_capacity);
   synch_registry->registerSynchronizer(*pbc_synch, _gst_htm_temperature);
   changeLocalEquationNumberForPBC(pbc_pair, 1);
 
   // as long as there are ones on the diagonal of the matrix, we can put
   // boudandary true for slaves
   std::map<UInt, UInt>::iterator it = pbc_pair.begin();
   std::map<UInt, UInt>::iterator end = pbc_pair.end();
   while (it != end) {
     (*blocked_dofs)((*it).first, 0) = true;
     ++it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initArrays() {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = getFEEngine().getMesh().getNbNodes();
 
   std::stringstream sstr_temp;
   sstr_temp << Model::id << ":temperature";
   std::stringstream sstr_temp_rate;
   sstr_temp_rate << Model::id << ":temperature_rate";
   std::stringstream sstr_inc;
   sstr_inc << Model::id << ":increment";
   std::stringstream sstr_ext_flx;
   sstr_ext_flx << Model::id << ":external_flux";
   std::stringstream sstr_residual;
   sstr_residual << Model::id << ":residual";
   std::stringstream sstr_lump;
   sstr_lump << Model::id << ":lumped";
   std::stringstream sstr_boun;
   sstr_boun << Model::id << ":blocked_dofs";
 
   temperature = &(alloc<Real>(sstr_temp.str(), nb_nodes, 1, REAL_INIT_VALUE));
   temperature_rate =
       &(alloc<Real>(sstr_temp_rate.str(), nb_nodes, 1, REAL_INIT_VALUE));
   increment = &(alloc<Real>(sstr_inc.str(), nb_nodes, 1, REAL_INIT_VALUE));
   external_heat_rate =
       &(alloc<Real>(sstr_ext_flx.str(), nb_nodes, 1, REAL_INIT_VALUE));
   residual = &(alloc<Real>(sstr_residual.str(), nb_nodes, 1, REAL_INIT_VALUE));
   capacity_lumped =
       &(alloc<Real>(sstr_lump.str(), nb_nodes, 1, REAL_INIT_VALUE));
   blocked_dofs = &(alloc<bool>(sstr_boun.str(), nb_nodes, 1, false));
 
   Mesh::ConnectivityTypeList::const_iterator it;
 
   /* --------------------------------------------------------------------------
    */
   // byelementtype vectors
   getFEEngine().getMesh().initElementTypeMapArray(temperature_on_qpoints, 1,
                                                   spatial_dimension);
 
   getFEEngine().getMesh().initElementTypeMapArray(
       temperature_gradient, spatial_dimension, spatial_dimension);
 
   getFEEngine().getMesh().initElementTypeMapArray(
       conductivity_on_qpoints, spatial_dimension * spatial_dimension,
       spatial_dimension);
 
   getFEEngine().getMesh().initElementTypeMapArray(
       k_gradt_on_qpoints, spatial_dimension, spatial_dimension);
 
   getFEEngine().getMesh().initElementTypeMapArray(bt_k_gT, 1, spatial_dimension,
                                                   true);
 
   getFEEngine().getMesh().initElementTypeMapArray(int_bt_k_gT, 1,
                                                   spatial_dimension, true);
 
   getFEEngine().getMesh().initElementTypeMapArray(thermal_energy, 1,
                                                   spatial_dimension);
 
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
     GhostType gt = (GhostType)g;
 
     const Mesh::ConnectivityTypeList & type_list =
         getFEEngine().getMesh().getConnectivityTypeList(gt);
 
     for (it = type_list.begin(); it != type_list.end(); ++it) {
       if (Mesh::getSpatialDimension(*it) != spatial_dimension)
         continue;
       UInt nb_element = getFEEngine().getMesh().getNbElement(*it, gt);
       UInt nb_quad_points =
           this->getFEEngine().getNbIntegrationPoints(*it, gt) * nb_element;
 
       temperature_on_qpoints(*it, gt).resize(nb_quad_points);
       temperature_on_qpoints(*it, gt).clear();
 
       temperature_gradient(*it, gt).resize(nb_quad_points);
       temperature_gradient(*it, gt).clear();
 
       conductivity_on_qpoints(*it, gt).resize(nb_quad_points);
       conductivity_on_qpoints(*it, gt).clear();
 
       k_gradt_on_qpoints(*it, gt).resize(nb_quad_points);
       k_gradt_on_qpoints(*it, gt).clear();
 
       bt_k_gT(*it, gt).resize(nb_quad_points);
       bt_k_gT(*it, gt).clear();
 
       int_bt_k_gT(*it, gt).resize(nb_element);
       int_bt_k_gT(*it, gt).clear();
 
       thermal_energy(*it, gt).resize(nb_element);
       thermal_energy(*it, gt).clear();
     }
   }
 
   /* --------------------------------------------------------------------------
    */
   dof_synchronizer = new DOFSynchronizer(getFEEngine().getMesh(), 1);
   dof_synchronizer->initLocalDOFEquationNumbers();
   dof_synchronizer->initGlobalDOFEquationNumbers();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 void HeatTransferModel::initSolver(__attribute__((unused))
                                    SolverOptions & options) {
 #if !defined(AKANTU_USE_MUMPS) // or other solver in the future \todo add
                                // AKANTU_HAS_SOLVER in CMake
   AKANTU_DEBUG_ERROR("You should at least activate one solver.");
 #else
   UInt nb_global_nodes = mesh.getNbGlobalNodes();
 
   delete jacobian_matrix;
   std::stringstream sstr;
   sstr << Memory::id << ":jacobian_matrix";
   jacobian_matrix =
       new SparseMatrix(nb_global_nodes, _symmetric, sstr.str(), memory_id);
 
   jacobian_matrix->buildProfile(mesh, *dof_synchronizer, 1);
 
   delete conductivity_matrix;
   std::stringstream sstr_sti;
   sstr_sti << Memory::id << ":conductivity_matrix";
   conductivity_matrix =
       new SparseMatrix(*jacobian_matrix, sstr_sti.str(), memory_id);
 
 #ifdef AKANTU_USE_MUMPS
   std::stringstream sstr_solv;
   sstr_solv << Memory::id << ":solver";
   solver = new SolverMumps(*jacobian_matrix, sstr_solv.str());
 
   dof_synchronizer->initScatterGatherCommunicationScheme();
 #else
   AKANTU_DEBUG_ERROR("You should at least activate one solver.");
 #endif // AKANTU_USE_MUMPS
 
   if (solver)
     solver->initialize(options);
 #endif // AKANTU_HAS_SOLVER
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initImplicit(bool dynamic,
                                      SolverOptions & solver_options) {
   AKANTU_DEBUG_IN();
 
   method = dynamic ? _implicit_dynamic : _static;
   initSolver(solver_options);
 
   if (method == _implicit_dynamic) {
     if (integrator)
       delete integrator;
     integrator = new TrapezoidalRule1();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 HeatTransferModel::~HeatTransferModel() {
   AKANTU_DEBUG_IN();
   if (integrator)
     delete integrator;
   if (conductivity_matrix)
     delete conductivity_matrix;
   if (capacity_matrix)
     delete capacity_matrix;
   if (jacobian_matrix)
     delete jacobian_matrix;
   if (solver)
     delete solver;
 
   delete pbc_synch;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacityLumped(const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   FEEngine & fem = getFEEngine();
 
   const Mesh::ConnectivityTypeList & type_list =
       fem.getMesh().getConnectivityTypeList(ghost_type);
 
   Mesh::ConnectivityTypeList::const_iterator it;
   for (it = type_list.begin(); it != type_list.end(); ++it) {
     if (Mesh::getSpatialDimension(*it) != spatial_dimension)
       continue;
 
     UInt nb_element = getFEEngine().getMesh().getNbElement(*it, ghost_type);
     UInt nb_quadrature_points =
         getFEEngine().getNbIntegrationPoints(*it, ghost_type);
 
     Array<Real> rho_1(nb_element * nb_quadrature_points, 1, capacity * density);
     fem.assembleFieldLumped(rho_1, 1, *capacity_lumped,
                             dof_synchronizer->getLocalDOFEquationNumbers(), *it,
                             ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacityLumped() {
   AKANTU_DEBUG_IN();
 
   capacity_lumped->clear();
 
   assembleCapacityLumped(_not_ghost);
   assembleCapacityLumped(_ghost);
 
   getSynchronizerRegistry().synchronize(_gst_htm_capacity);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::updateResidual(
     __attribute__((unused)) bool compute_conductivity) {
   AKANTU_DEBUG_IN();
   /// @f$ r = q_{ext} - q_{int} - C \dot T @f$
 
   // start synchronization
   synch_registry->asynchronousSynchronize(_gst_htm_temperature);
   // finalize communications
   synch_registry->waitEndSynchronize(_gst_htm_temperature);
 
   // clear the array
   /// first @f$ r = q_{ext} @f$
   //  residual->clear();
   residual->copy(*external_heat_rate);
 
   /// then @f$ r -= q_{int} @f$
   // update the not ghost ones
 
   updateResidual(_not_ghost);
   // update for the received ghosts
   updateResidual(_ghost);
 
   /*  if (method == _explicit_lumped_capacity) {
       this->solveExplicitLumped();
     }*/
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleConductivityMatrix(bool compute_conductivity) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix.");
 
   conductivity_matrix->clear();
 
   switch (mesh.getSpatialDimension()) {
   case 1:
     this->assembleConductivityMatrix<1>(_not_ghost, compute_conductivity);
     break;
   case 2:
     this->assembleConductivityMatrix<2>(_not_ghost, compute_conductivity);
     break;
   case 3:
     this->assembleConductivityMatrix<3>(_not_ghost, compute_conductivity);
     break;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void HeatTransferModel::assembleConductivityMatrix(const GhostType & ghost_type,
                                                    bool compute_conductivity) {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh = this->getFEEngine().getMesh();
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
   for (; it != last_type; ++it) {
     this->assembleConductivityMatrix<dim>(*it, ghost_type,
                                           compute_conductivity);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void HeatTransferModel::assembleConductivityMatrix(const ElementType & type,
                                                    const GhostType & ghost_type,
                                                    bool compute_conductivity) {
   AKANTU_DEBUG_IN();
 
   SparseMatrix & K = *conductivity_matrix;
   const Array<Real> & shapes_derivatives =
       this->getFEEngine().getShapesDerivatives(type, ghost_type);
 
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points =
       getFEEngine().getNbIntegrationPoints(type, ghost_type);
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_d_b_size = nb_nodes_per_element;
 
   Array<Real> * bt_d_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
   Matrix<Real> Bt_D(nb_nodes_per_element, dim);
 
   Array<Real>::const_iterator<Matrix<Real> > shapes_derivatives_it =
       shapes_derivatives.begin(dim, nb_nodes_per_element);
 
   Array<Real>::iterator<Matrix<Real> > Bt_D_B_it =
       bt_d_b->begin(bt_d_b_size, bt_d_b_size);
 
   if (compute_conductivity)
     this->computeConductivityOnQuadPoints(ghost_type);
   Array<Real>::iterator<Matrix<Real> > D_it =
       conductivity_on_qpoints(type, ghost_type).begin(dim, dim);
   Array<Real>::iterator<Matrix<Real> > D_end =
       conductivity_on_qpoints(type, ghost_type).end(dim, dim);
 
   for (; D_it != D_end; ++D_it, ++Bt_D_B_it, ++shapes_derivatives_it) {
     Matrix<Real> & D = *D_it;
     const Matrix<Real> & B = *shapes_derivatives_it;
     Matrix<Real> & Bt_D_B = *Bt_D_B_it;
 
     Bt_D.mul<true, false>(B, D);
     Bt_D_B.mul<false, false>(Bt_D, B);
   }
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_d_b_size * bt_d_b_size, "K_e");
 
   this->getFEEngine().integrate(*bt_d_b, *K_e, bt_d_b_size * bt_d_b_size, type,
                                 ghost_type);
 
   delete bt_d_b;
 
   this->getFEEngine().assembleMatrix(*K_e, K, 1, type, ghost_type);
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 void HeatTransferModel::updateResidualInternal() {
 
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Update the residual");
   // f = q_ext - q_int - Mddot = q - Mddot;
 
   if (method != _static) {
     // f -= Mddot
     if (capacity_matrix) {
       // if full mass_matrix
       Array<Real> * Mddot = new Array<Real>(*temperature_rate, true, "Mddot");
       *Mddot *= *capacity_matrix;
       *residual -= *Mddot;
       delete Mddot;
     } else if (capacity_lumped) {
 
       // else lumped mass
-      UInt nb_nodes = temperature_rate->getSize();
+      UInt nb_nodes = temperature_rate->size();
       UInt nb_degree_of_freedom = temperature_rate->getNbComponent();
 
       Real * capacity_val = capacity_lumped->storage();
       Real * temp_rate_val = temperature_rate->storage();
       Real * res_val = residual->storage();
       bool * blocked_dofs_val = blocked_dofs->storage();
 
       for (UInt n = 0; n < nb_nodes * nb_degree_of_freedom; ++n) {
         if (!(*blocked_dofs_val)) {
           *res_val -= *temp_rate_val ** capacity_val;
         }
         blocked_dofs_val++;
         res_val++;
         capacity_val++;
         temp_rate_val++;
       }
     } else {
       AKANTU_DEBUG_ERROR("No function called to assemble the mass matrix.");
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::solveStatic() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Solving Ku = f");
   AKANTU_DEBUG_ASSERT(conductivity_matrix != NULL,
                       "You should first initialize the implicit solver and "
                       "assemble the stiffness matrix");
 
-  UInt nb_nodes = temperature->getSize();
+  UInt nb_nodes = temperature->size();
   UInt nb_degree_of_freedom = temperature->getNbComponent() * nb_nodes;
 
   jacobian_matrix->copyContent(*conductivity_matrix);
   jacobian_matrix->applyBoundary(*blocked_dofs);
 
   increment->clear();
 
   solver->setRHS(*residual);
   solver->factorize();
   solver->solve(*increment);
 
   Real * increment_val = increment->storage();
   Real * temperature_val = temperature->storage();
   bool * blocked_dofs_val = blocked_dofs->storage();
 
   for (UInt j = 0; j < nb_degree_of_freedom;
        ++j, ++temperature_val, ++increment_val, ++blocked_dofs_val) {
     if (!(*blocked_dofs_val)) {
       *temperature_val += *increment_val;
     } else {
       *increment_val = 0.0;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeConductivityOnQuadPoints(
     const GhostType & ghost_type) {
   const Mesh::ConnectivityTypeList & type_list =
       this->getFEEngine().getMesh().getConnectivityTypeList(ghost_type);
   Mesh::ConnectivityTypeList::const_iterator it;
 
   for (it = type_list.begin(); it != type_list.end(); ++it) {
     if (Mesh::getSpatialDimension(*it) != spatial_dimension)
       continue;
 
     Array<Real> & temperature_interpolated =
         temperature_on_qpoints(*it, ghost_type);
 
     // compute the temperature on quadrature points
     this->getFEEngine().interpolateOnIntegrationPoints(
         *temperature, temperature_interpolated, 1, *it, ghost_type);
 
     Array<Real>::matrix_iterator C_it =
         conductivity_on_qpoints(*it, ghost_type)
             .begin(spatial_dimension, spatial_dimension);
     Array<Real>::matrix_iterator C_end =
         conductivity_on_qpoints(*it, ghost_type)
             .end(spatial_dimension, spatial_dimension);
 
     Array<Real>::iterator<Real> T_it = temperature_interpolated.begin();
 
     for (; C_it != C_end; ++C_it, ++T_it) {
       Matrix<Real> & C = *C_it;
       Real & T = *T_it;
       C = conductivity;
 
       Matrix<Real> variation(spatial_dimension, spatial_dimension,
                              conductivity_variation * (T - T_ref));
       C += conductivity_variation;
     }
   }
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeKgradT(const GhostType & ghost_type,
                                       bool compute_conductivity) {
 
   if (compute_conductivity)
     computeConductivityOnQuadPoints(ghost_type);
 
   const Mesh::ConnectivityTypeList & type_list =
       this->getFEEngine().getMesh().getConnectivityTypeList(ghost_type);
   Mesh::ConnectivityTypeList::const_iterator it;
 
   for (it = type_list.begin(); it != type_list.end(); ++it) {
     const ElementType & type = *it;
     if (Mesh::getSpatialDimension(*it) != spatial_dimension)
       continue;
 
     Array<Real> & gradient = temperature_gradient(*it, ghost_type);
     this->getFEEngine().gradientOnIntegrationPoints(*temperature, gradient, 1,
                                                     *it, ghost_type);
 
     Array<Real>::matrix_iterator C_it =
         conductivity_on_qpoints(*it, ghost_type)
             .begin(spatial_dimension, spatial_dimension);
 
     Array<Real>::vector_iterator BT_it = gradient.begin(spatial_dimension);
 
     Array<Real>::vector_iterator k_BT_it =
         k_gradt_on_qpoints(type, ghost_type).begin(spatial_dimension);
     Array<Real>::vector_iterator k_BT_end =
         k_gradt_on_qpoints(type, ghost_type).end(spatial_dimension);
 
     for (; k_BT_it != k_BT_end; ++k_BT_it, ++BT_it, ++C_it) {
       Vector<Real> & k_BT = *k_BT_it;
       Vector<Real> & BT = *BT_it;
       Matrix<Real> & C = *C_it;
 
       k_BT.mul<false>(C, BT);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::updateResidual(const GhostType & ghost_type,
                                        bool compute_conductivity) {
   AKANTU_DEBUG_IN();
 
   const Mesh::ConnectivityTypeList & type_list =
       this->getFEEngine().getMesh().getConnectivityTypeList(ghost_type);
   Mesh::ConnectivityTypeList::const_iterator it;
 
   for (it = type_list.begin(); it != type_list.end(); ++it) {
     if (Mesh::getSpatialDimension(*it) != spatial_dimension)
       continue;
 
     Array<Real> & shapes_derivatives = const_cast<Array<Real> &>(
         getFEEngine().getShapesDerivatives(*it, ghost_type));
 
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(*it);
 
     // compute k \grad T
     computeKgradT(ghost_type, compute_conductivity);
 
     Array<Real>::vector_iterator k_BT_it =
         k_gradt_on_qpoints(*it, ghost_type).begin(spatial_dimension);
 
     Array<Real>::matrix_iterator B_it =
         shapes_derivatives.begin(spatial_dimension, nb_nodes_per_element);
 
     Array<Real>::vector_iterator Bt_k_BT_it =
         bt_k_gT(*it, ghost_type).begin(nb_nodes_per_element);
 
     Array<Real>::vector_iterator Bt_k_BT_end =
         bt_k_gT(*it, ghost_type).end(nb_nodes_per_element);
 
     for (; Bt_k_BT_it != Bt_k_BT_end; ++Bt_k_BT_it, ++B_it, ++k_BT_it) {
       Vector<Real> & k_BT = *k_BT_it;
       Vector<Real> & Bt_k_BT = *Bt_k_BT_it;
       Matrix<Real> & B = *B_it;
 
       Bt_k_BT.mul<true>(B, k_BT);
     }
 
     this->getFEEngine().integrate(bt_k_gT(*it, ghost_type),
                                   int_bt_k_gT(*it, ghost_type),
                                   nb_nodes_per_element, *it, ghost_type);
 
     this->getFEEngine().assembleArray(
         int_bt_k_gT(*it, ghost_type), *residual,
         dof_synchronizer->getLocalDOFEquationNumbers(), 1, *it, ghost_type,
         empty_filter, -1);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::solveExplicitLumped() {
   AKANTU_DEBUG_IN();
 
   /// finally @f$ r -= C \dot T @f$
   // lumped C
-  UInt nb_nodes = temperature_rate->getSize();
+  UInt nb_nodes = temperature_rate->size();
   UInt nb_degree_of_freedom = temperature_rate->getNbComponent();
 
   Real * capacity_val = capacity_lumped->storage();
   Real * temp_rate_val = temperature_rate->storage();
   Real * res_val = residual->storage();
   bool * blocked_dofs_val = blocked_dofs->storage();
 
   for (UInt n = 0; n < nb_nodes * nb_degree_of_freedom; ++n) {
     if (!(*blocked_dofs_val)) {
       *res_val -= *capacity_val ** temp_rate_val;
     }
     blocked_dofs_val++;
     res_val++;
     capacity_val++;
     temp_rate_val++;
   }
 
 #ifndef AKANTU_NDEBUG
   getSynchronizerRegistry().synchronize(akantu::_gst_htm_gradient_temperature);
 #endif
 
   capacity_val = capacity_lumped->storage();
   res_val = residual->storage();
   blocked_dofs_val = blocked_dofs->storage();
   Real * inc = increment->storage();
 
   for (UInt n = 0; n < nb_nodes * nb_degree_of_freedom; ++n) {
     if (!(*blocked_dofs_val)) {
       *inc = (*res_val / *capacity_val);
     }
     res_val++;
     blocked_dofs_val++;
     inc++;
     capacity_val++;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::explicitPred() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(integrator, "integrator was not instanciated");
   integrator->integrationSchemePred(time_step, *temperature, *temperature_rate,
                                     *blocked_dofs);
 
-  UInt nb_nodes = temperature->getSize();
+  UInt nb_nodes = temperature->size();
   UInt nb_degree_of_freedom = temperature->getNbComponent();
 
   Real * temp = temperature->storage();
   for (UInt n = 0; n < nb_nodes * nb_degree_of_freedom; ++n, ++temp)
     if (*temp < 0.)
       *temp = 0.;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::explicitCorr() {
   AKANTU_DEBUG_IN();
 
   integrator->integrationSchemeCorrTempRate(
       time_step, *temperature, *temperature_rate, *blocked_dofs, *increment);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::implicitPred() {
   AKANTU_DEBUG_IN();
 
   if (method == _implicit_dynamic)
     integrator->integrationSchemePred(time_step, *temperature,
                                       *temperature_rate, *blocked_dofs);
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 
 void HeatTransferModel::implicitCorr() {
 
   AKANTU_DEBUG_IN();
 
   if (method == _implicit_dynamic) {
     integrator->integrationSchemeCorrTemp(
         time_step, *temperature, *temperature_rate, *blocked_dofs, *increment);
   } else {
-    UInt nb_nodes = temperature->getSize();
+    UInt nb_nodes = temperature->size();
     UInt nb_degree_of_freedom = temperature->getNbComponent() * nb_nodes;
 
     Real * incr_val = increment->storage();
     Real * temp_val = temperature->storage();
     bool * boun_val = blocked_dofs->storage();
 
     for (UInt j = 0; j < nb_degree_of_freedom;
          ++j, ++temp_val, ++incr_val, ++boun_val) {
       *incr_val *= (1. - *boun_val);
       *temp_val += *incr_val;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getStableTimeStep() {
   AKANTU_DEBUG_IN();
 
   Real el_size;
   Real min_el_size = std::numeric_limits<Real>::max();
   Real conductivitymax = conductivity(0, 0);
 
   // get the biggest parameter from k11 until k33//
   for (UInt i = 0; i < spatial_dimension; i++)
     for (UInt j = 0; j < spatial_dimension; j++)
       conductivitymax = std::max(conductivity(i, j), conductivitymax);
 
   const Mesh::ConnectivityTypeList & type_list =
       getFEEngine().getMesh().getConnectivityTypeList();
   Mesh::ConnectivityTypeList::const_iterator it;
   for (it = type_list.begin(); it != type_list.end(); ++it) {
     if (getFEEngine().getMesh().getSpatialDimension(*it) != spatial_dimension)
       continue;
 
     UInt nb_nodes_per_element =
         getFEEngine().getMesh().getNbNodesPerElement(*it);
 
     Array<Real> coord(0, nb_nodes_per_element * spatial_dimension);
     FEEngine::extractNodalToElementField(getFEEngine().getMesh(),
                                          getFEEngine().getMesh().getNodes(),
                                          coord, *it, _not_ghost);
 
     Array<Real>::matrix_iterator el_coord =
         coord.begin(spatial_dimension, nb_nodes_per_element);
     UInt nb_element = getFEEngine().getMesh().getNbElement(*it);
 
     for (UInt el = 0; el < nb_element; ++el, ++el_coord) {
       el_size = getFEEngine().getElementInradius(*el_coord, *it);
       min_el_size = std::min(min_el_size, el_size);
     }
 
     AKANTU_DEBUG_INFO("The minimum element size : "
                       << min_el_size
                       << " and the max conductivity is : " << conductivitymax);
   }
 
   Real min_dt =
       2 * min_el_size * min_el_size * density * capacity / conductivitymax;
 
   StaticCommunicator::getStaticCommunicator().allReduce(&min_dt, 1, _so_min);
 
   AKANTU_DEBUG_OUT();
 
   return min_dt;
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::readMaterials() {
   std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
       sub_sect = this->parser->getSubSections(_st_heat);
 
   Parser::const_section_iterator it = sub_sect.first;
   const ParserSection & section = *it;
 
   this->parseSection(section);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void HeatTransferModel::initFull(const ModelOptions & options) {
   Model::initFull(options);
 
   readMaterials();
 
   const HeatTransferModelOptions & my_options =
       dynamic_cast<const HeatTransferModelOptions &>(options);
 
   method = my_options.analysis_method;
 
   // initialize the vectors
   initArrays();
   temperature->clear();
   temperature_rate->clear();
   external_heat_rate->clear();
 
   // initialize pbc
   if (pbc_pair.size() != 0)
     initPBC();
 
   if (method == _explicit_lumped_capacity) {
     integrator = new ForwardEuler();
   }
   if (method == _implicit_dynamic) {
     initImplicit(true);
   }
   if (method == _static) {
     initImplicit(false);
   }
 }
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacity() {
   AKANTU_DEBUG_IN();
 
   if (!capacity_matrix) {
     std::stringstream sstr;
     sstr << id << ":capacity_matrix";
     capacity_matrix = new SparseMatrix(*jacobian_matrix, sstr.str(), memory_id);
   }
 
   assembleCapacity(_not_ghost);
   //  assembleMass(_ghost);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 class ComputeRhoFunctor {
 public:
   ComputeRhoFunctor(const HeatTransferModel & model) : model(model){};
 
   void operator()(Matrix<Real> & rho, const Element &,
                   const Matrix<Real> &) const {
     rho.set(model.getCapacity());
   }
 
 private:
   const HeatTransferModel & model;
 };
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacity(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
 
   ComputeRhoFunctor rho_functor(*this);
 
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension, ghost_type);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     fem.assembleFieldMatrix(rho_functor, 1, *capacity_matrix, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 void HeatTransferModel::computeRho(Array<Real> & rho, ElementType type,
                                    GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   FEEngine & fem = this->getFEEngine();
   UInt nb_element = fem.getMesh().getNbElement(type, ghost_type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   rho.resize(nb_element * nb_quadrature_points);
   Real * rho_1_val = rho.storage();
 
   /// compute @f$ rho @f$ for each nodes of each element
   for (UInt el = 0; el < nb_element; ++el) {
 
     for (UInt n = 0; n < nb_quadrature_points; ++n) {
       *rho_1_val++ = this->capacity;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <>
 bool HeatTransferModel::testConvergence<_scc_increment>(Real tolerance,
                                                         Real & error) {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = temperature->getSize();
+  UInt nb_nodes = temperature->size();
   UInt nb_degree_of_freedom = temperature->getNbComponent();
 
   error = 0;
   Real norm[2] = {0., 0.};
   Real * increment_val = increment->storage();
   bool * blocked_dofs_val = blocked_dofs->storage();
   Real * temperature_val = temperature->storage();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     bool is_local_node = mesh.isLocalOrMasterNode(n);
     for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
       if (!(*blocked_dofs_val) && is_local_node) {
         norm[0] += *increment_val * *increment_val;
         norm[1] += *temperature_val * *temperature_val;
       }
       blocked_dofs_val++;
       increment_val++;
       temperature_val++;
     }
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(norm, 2, _so_sum);
 
   norm[0] = sqrt(norm[0]);
   norm[1] = sqrt(norm[1]);
 
   AKANTU_DEBUG_ASSERT(!Math::isnan(norm[0]),
                       "Something goes wrong in the solve phase");
 
   if (norm[1] < Math::getTolerance()) {
     error = norm[0];
     AKANTU_DEBUG_OUT();
     //    cout<<"Error 1: "<<error<<endl;
     return error < tolerance;
   }
 
   AKANTU_DEBUG_OUT();
   if (norm[1] > Math::getTolerance())
     error = norm[0] / norm[1];
   else
     error = norm[0]; // In case the total displacement is zero!
 
   //  cout<<"Error 2: "<<error<<endl;
 
   return (error < tolerance);
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initFEEngineBoundary(bool create_surface) {
 
   if (create_surface)
     MeshUtils::buildFacets(getFEEngine().getMesh());
 
   FEEngine & fem_boundary = getFEEngineBoundary();
   fem_boundary.initShapeFunctions();
   fem_boundary.computeNormalsOnIntegrationPoints();
 }
 
 /* -------------------------------------------------------------------------- */
 
 Real HeatTransferModel::computeThermalEnergyByNode() {
   AKANTU_DEBUG_IN();
 
   Real ethermal = 0.;
 
   Array<Real>::vector_iterator heat_rate_it =
       residual->begin(residual->getNbComponent());
 
   Array<Real>::vector_iterator heat_rate_end =
       residual->end(residual->getNbComponent());
 
   UInt n = 0;
   for (; heat_rate_it != heat_rate_end; ++heat_rate_it, ++n) {
     Real heat = 0;
     bool is_local_node = mesh.isLocalOrMasterNode(n);
     bool is_not_pbc_slave_node = !isPBCSlaveNode(n);
     bool count_node = is_local_node && is_not_pbc_slave_node;
 
     Vector<Real> & heat_rate = *heat_rate_it;
     for (UInt i = 0; i < heat_rate.size(); ++i) {
       if (count_node)
         heat += heat_rate[i] * time_step;
     }
     ethermal += heat;
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(&ethermal, 1, _so_sum);
 
   AKANTU_DEBUG_OUT();
   return ethermal;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class iterator>
 void HeatTransferModel::getThermalEnergy(
     iterator Eth, Array<Real>::const_iterator<Real> T_it,
     Array<Real>::const_iterator<Real> T_end) const {
   for (; T_it != T_end; ++T_it, ++Eth) {
     *Eth = capacity * density ** T_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getThermalEnergy(const ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
 
   UInt nb_quadrature_points = getFEEngine().getNbIntegrationPoints(type);
   Vector<Real> Eth_on_quarature_points(nb_quadrature_points);
 
   Array<Real>::iterator<Real> T_it = this->temperature_on_qpoints(type).begin();
   T_it += index * nb_quadrature_points;
 
   Array<Real>::iterator<Real> T_end = T_it + nb_quadrature_points;
 
   getThermalEnergy(Eth_on_quarature_points.storage(), T_it, T_end);
 
   return getFEEngine().integrate(Eth_on_quarature_points, type, index);
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getThermalEnergy() {
   Real Eth = 0;
 
   Mesh & mesh = getFEEngine().getMesh();
   Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension);
   for (; it != last_type; ++it) {
     UInt nb_element = getFEEngine().getMesh().getNbElement(*it, _not_ghost);
     UInt nb_quadrature_points =
         getFEEngine().getNbIntegrationPoints(*it, _not_ghost);
     Array<Real> Eth_per_quad(nb_element * nb_quadrature_points, 1);
 
     Array<Real>::iterator<Real> T_it =
         this->temperature_on_qpoints(*it).begin();
     Array<Real>::iterator<Real> T_end = this->temperature_on_qpoints(*it).end();
     getThermalEnergy(Eth_per_quad.begin(), T_it, T_end);
 
     Eth += getFEEngine().integrate(Eth_per_quad, *it);
   }
 
   return Eth;
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getEnergy(const std::string & id) {
   AKANTU_DEBUG_IN();
   Real energy = 0;
 
   if (id == "thermal")
     energy = getThermalEnergy();
 
   // reduction sum over all processors
   StaticCommunicator::getStaticCommunicator().allReduce(&energy, 1, _so_sum);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getEnergy(const std::string & id,
                                   const ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
 
   Real energy = 0.;
 
   if (id == "thermal")
     energy = getThermalEnergy(type, index);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_USE_IOHELPER
 
 dumper::Field * HeatTransferModel::createNodalFieldBool(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs;
 
   dumper::Field * field = NULL;
   field = mesh.createNodalField(uint_nodal_fields[field_name], group_name);
   return field;
 }
 /* -------------------------------------------------------------------------- */
 
 dumper::Field * HeatTransferModel::createNodalFieldReal(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["temperature"] = temperature;
   real_nodal_fields["temperature_rate"] = temperature_rate;
   real_nodal_fields["external_heat_rate"] = external_heat_rate;
   real_nodal_fields["residual"] = residual;
   real_nodal_fields["capacity_lumped"] = capacity_lumped;
   real_nodal_fields["increment"] = increment;
 
   dumper::Field * field =
       mesh.createNodalField(real_nodal_fields[field_name], group_name);
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 
 dumper::Field * HeatTransferModel::createElementalField(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag,
     __attribute__((unused)) const UInt & spatial_dimension,
     const ElementKind & element_kind) {
 
   dumper::Field * field = NULL;
 
   if (field_name == "partitions")
     field = mesh.createElementalField<UInt, dumper::ElementPartitionField>(
         mesh.getConnectivities(), group_name, this->spatial_dimension,
         element_kind);
   else if (field_name == "temperature_gradient") {
     ElementTypeMap<UInt> nb_data_per_elem =
         this->mesh.getNbDataPerElem(temperature_gradient, element_kind);
 
     field = mesh.createElementalField<Real, dumper::InternalMaterialField>(
         temperature_gradient, group_name, this->spatial_dimension, element_kind,
         nb_data_per_elem);
   } else if (field_name == "conductivity") {
     ElementTypeMap<UInt> nb_data_per_elem =
         this->mesh.getNbDataPerElem(conductivity_on_qpoints, element_kind);
 
     field = mesh.createElementalField<Real, dumper::InternalMaterialField>(
         conductivity_on_qpoints, group_name, this->spatial_dimension,
         element_kind, nb_data_per_elem);
   }
 
   return field;
 }
 /* -------------------------------------------------------------------------- */
 #else
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createElementalField(
     __attribute__((unused)) const std::string & field_name,
     __attribute__((unused)) const std::string & group_name,
     __attribute__((unused)) bool padding_flag,
     __attribute__((unused)) const ElementKind & element_kind) {
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createNodalFieldBool(
     __attribute__((unused)) const std::string & field_name,
     __attribute__((unused)) const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 dumper::Field * HeatTransferModel::createNodalFieldReal(
     __attribute__((unused)) const std::string & field_name,
     __attribute__((unused)) const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
   return NULL;
 }
 
 #endif
 
 } // akantu
diff --git a/src/model/heat_transfer/heat_transfer_model_inline_impl.cc b/src/model/heat_transfer/heat_transfer_model_inline_impl.cc
index bdf636e3a..2df728fac 100644
--- a/src/model/heat_transfer/heat_transfer_model_inline_impl.cc
+++ b/src/model/heat_transfer/heat_transfer_model_inline_impl.cc
@@ -1,468 +1,468 @@
 /**
  * @file   heat_transfer_model_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Srinivasa Babu Ramisetti <srinivasa.ramisetti@epfl.ch>
  *
  * @date creation: Fri Aug 20 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Implementation of the inline functions of the HeatTransferModel class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 inline FEEngine & HeatTransferModel::getFEEngineBoundary(const std::string & name) {
   return dynamic_cast<FEEngine &>(getFEEngineClassBoundary<MyFEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt HeatTransferModel::getNbDataToPack(SynchronizationTag tag) const{
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes = getFEEngine().getMesh().getNbNodes();
 
   switch(tag) {
   case _gst_htm_temperature:
   case _gst_htm_capacity: {
     size += nb_nodes * sizeof(Real);
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt HeatTransferModel::getNbDataToUnpack(SynchronizationTag tag) const{
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes = getFEEngine().getMesh().getNbNodes();
 
   switch(tag) {
   case _gst_htm_capacity:
   case _gst_htm_temperature: {
     size += nb_nodes * sizeof(Real);
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::packData(CommunicationBuffer & buffer,
 					const UInt index,
 					SynchronizationTag tag) const{
   AKANTU_DEBUG_IN();
 
   switch(tag) {
   case _gst_htm_capacity:
     buffer << (*capacity_lumped)(index);
     break;
   case _gst_htm_temperature: {
     buffer << (*temperature)(index);
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::unpackData(CommunicationBuffer & buffer,
 					  const UInt index,
 					  SynchronizationTag tag) {
   AKANTU_DEBUG_IN();
 
   switch(tag) {
   case _gst_htm_capacity: {
     buffer >> (*capacity_lumped)(index);
     break;
   }
   case _gst_htm_temperature: {
     buffer >> (*temperature)(index);
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt HeatTransferModel::getNbDataForElements(const Array<Element> & elements,
                                                     SynchronizationTag tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes_per_element = 0;
   Array<Element>::const_iterator<Element> it  = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
   }
 
 #ifndef AKANTU_NDEBUG
-  size += elements.getSize() * spatial_dimension * sizeof(Real); /// position of the barycenter of the element (only for check)
+  size += elements.size() * spatial_dimension * sizeof(Real); /// position of the barycenter of the element (only for check)
   //  size += spatial_dimension * nb_nodes_per_element * sizeof(Real); /// position of the nodes of the element
 #endif
 
   switch(tag) {
   case _gst_htm_capacity: {
     size += nb_nodes_per_element * sizeof(Real); // capacity vector
     break;
   }
   case _gst_htm_temperature: {
     size += nb_nodes_per_element * sizeof(Real); // temperature
     break;
   }
   case _gst_htm_gradient_temperature: {
     size += getNbIntegrationPoints(elements) * spatial_dimension * sizeof(Real); // temperature gradient
     size += nb_nodes_per_element * sizeof(Real); // nodal temperatures
     //    size += spatial_dimension * nb_nodes_per_element * sizeof(Real); // shape derivatives
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::packElementData(CommunicationBuffer & buffer,
                                                const Array<Element> & elements,
                                                SynchronizationTag tag) const {
 #ifndef AKANTU_NDEBUG
   Array<Element>::const_iterator<Element> bit  = elements.begin();
   Array<Element>::const_iterator<Element> bend = elements.end();
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
     Vector<Real> barycenter(spatial_dimension);
     mesh.getBarycenter(element.element, element.type, barycenter.storage(), element.ghost_type);
     buffer << barycenter;
   }
   // packNodalDataHelper(mesh.getNodes(), buffer, elements);
 #endif
 
   switch (tag){
   case _gst_htm_capacity: {
     packNodalDataHelper(*capacity_lumped, buffer, elements, mesh);
     break;
   }
   case _gst_htm_temperature: {
     packNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   case _gst_htm_gradient_temperature: {
     packElementalDataHelper(temperature_gradient, buffer, elements, true, getFEEngine());
     packNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::unpackElementData(CommunicationBuffer & buffer,
                                                  const Array<Element> & elements,
                                                  SynchronizationTag tag) {
 #ifndef AKANTU_NDEBUG
   Array<Element>::const_iterator<Element> bit  = elements.begin();
   Array<Element>::const_iterator<Element> bend = elements.end();
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
 
     Vector<Real> barycenter_loc(spatial_dimension);
     mesh.getBarycenter(element.element, element.type, barycenter_loc.storage(), element.ghost_type);
 
     Vector<Real> barycenter(spatial_dimension);
     buffer >> barycenter;
     Real tolerance = 1e-15;
     for (UInt i = 0; i < spatial_dimension; ++i) {
       if(!(std::abs(barycenter(i) - barycenter_loc(i)) <= tolerance))
 	AKANTU_DEBUG_ERROR("Unpacking an unknown value for the element: "
 			   << element
 			   << "(barycenter[" << i << "] = " << barycenter_loc(i)
 			   << " and buffer[" << i << "] = " << barycenter(i) << ") - tag: " << tag);
     }
   }
 
   // Vector<Real> coords(spatial_dimension);
   // Real * nodes = getFEEngine().getMesh().getNodes().storage();
   // for (UInt n = 0; n < nb_nodes_per_element; ++n) {
   //   buffer >> coords;
   //   UInt offset_conn = conn[el_offset + n];
   //   Real * coords_local = nodes+spatial_dimension*offset_conn;
   //   for (UInt i = 0; i < spatial_dimension; ++i) {
   //     if(!(std::abs(coords(i) - coords_local[i]) <= tolerance))
   //       AKANTU_EXCEPTION("Unpacking to wrong node for the element : "
   //       		 << element
   //       		 << "(coords[" << i << "] = " << coords_local[i]
   //       		 << " and buffer[" << i << "] = " << coords(i) << ")");
   //   }
   // }
 #endif
 
   switch (tag){
   case _gst_htm_capacity: {
     unpackNodalDataHelper(*capacity_lumped, buffer, elements, mesh);
     break;
   }
   case _gst_htm_temperature: {
     unpackNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   case _gst_htm_gradient_temperature: {
     unpackElementalDataHelper(temperature_gradient, buffer, elements, true, getFEEngine());
     unpackNodalDataHelper(*temperature, buffer, elements, mesh);
 
     // //    Real tolerance = 1e-15;
     // if (!Math::are_vector_equal(spatial_dimension,gtemp.storage(),it_gtemp[element.element].storage())){
     //   Real dist = Math::distance_3d(gtemp.storage(), it_gtemp[element.element].storage());
     //   debug::debugger.getOutputStream().precision(20);
     //   std::stringstream temperatures_str;
     //   temperatures_str.precision(20);
     //   temperatures_str << std::scientific << "temperatures are ";
     //   for (UInt n = 0; n < nb_nodes_per_element; ++n) {
     //     UInt offset_conn = conn[el_offset + n];
     //     temperatures_str << (*temperature)(offset_conn) << " ";
     //   }
     //   Array<Real>::matrix_iterator it_shaped =
     //     const_cast<Array<Real> &>(getFEEngine().getShapesDerivatives(element.type, ghost_type))
     //     .begin(nb_nodes_per_element,spatial_dimension);
 
 
     //   AKANTU_EXCEPTION("packed gradient do not match for element " << element.element << std::endl
     //     	       << "buffer is " << gtemp << " local is " << it_gtemp[element.element]
     //     	       << " dist is " << dist << std::endl
     //     	       << temperatures_str.str() << std::endl
     //     	       << std::scientific << std::setprecision(20)
     //     	       << " distant temperatures " << temp_nodes
-    //     	       << "temperature gradient size " << temperature_gradient(element.type, ghost_type).getSize()
+    //     	       << "temperature gradient size " << temperature_gradient(element.type, ghost_type).size()
     //     	       << " number of ghost elements " << getFEEngine().getMesh().getNbElement(element.type,_ghost)
     //     	       << std::scientific << std::setprecision(20)
     //     	       << " shaped " << shaped
     //     	       << std::scientific << std::setprecision(20)
     //     	       << " local shaped " << it_shaped[element.element]);
     // }
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 template<SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 bool HeatTransferModel::solveStep(Real tolerance,
 				  UInt max_iteration) {
   Real error = 0.;
   return this->template solveStep<cmethod,criteria>(tolerance,
                                                     error,
                                                     max_iteration);
 }
 
 /* -------------------------------------------------------------------------- */
 template<SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 bool HeatTransferModel::solveStep(Real tolerance, Real & error,
 				  UInt max_iteration,
 				  bool do_not_factorize) {
   //EventManager::sendEvent(HeatTransferModelEvent::BeforeSolveStepEvent(method));
   this->implicitPred();
   this->updateResidual();
 
   AKANTU_DEBUG_ASSERT(conductivity_matrix != NULL,
                       "You should first initialize the implicit solver and assemble the conductivity matrix");
 
   bool need_factorize = !do_not_factorize;
 
   if (method == _implicit_dynamic) {
     AKANTU_DEBUG_ASSERT(capacity_matrix != NULL,
                         "You should first initialize the implicit solver and assemble the mass matrix");
   }
 
   switch (cmethod) {
   case _scm_newton_raphson_tangent:
   case _scm_newton_raphson_tangent_not_computed:
     break;
   case _scm_newton_raphson_tangent_modified:
     this->assembleConductivityMatrix();
     break;
   default:
     AKANTU_DEBUG_ERROR("The resolution method " << cmethod << " has not been implemented!");
   }
 
   this->n_iter = 0;
   bool converged = false;
   error = 0.;
   if(criteria == _scc_residual) {
     converged = this->testConvergence<criteria> (tolerance, error);
     if(converged) return converged;
   }
 
   do {
     if (cmethod == _scm_newton_raphson_tangent)
       this->assembleConductivityMatrix();
 
     solve<GeneralizedTrapezoidal::_temperature_corrector>(*increment, 1., need_factorize);
 
     this->implicitCorr();
 
     if(criteria == _scc_residual) this->updateResidual();
 
     converged = this->testConvergence<criteria> (tolerance, error);
 
     if(criteria == _scc_increment && !converged) this->updateResidual();
     //   this->dump();
 
     this->n_iter++;
     AKANTU_DEBUG_INFO("[" << criteria << "] Convergence iteration "
                       << std::setw(std::log10(max_iteration)) << this->n_iter
                       << ": error " << error << (converged ? " < " : " > ") << tolerance);
 
     switch (cmethod) {
     case _scm_newton_raphson_tangent:
       need_factorize = true;
       break;
     case _scm_newton_raphson_tangent_not_computed:
     case _scm_newton_raphson_tangent_modified:
       need_factorize = false;
       break;
     default:
       AKANTU_DEBUG_ERROR("The resolution method " << cmethod << " has not been implemented!");
     }
 
 
   } while (!converged && this->n_iter < max_iteration);
 
   // this makes sure that you have correct strains and stresses after the solveStep function (e.g., for dumping)
   if(criteria == _scc_increment) this->updateResidual();
 
   if (converged) {
     //EventManager::sendEvent(HeatTransferModelEvent::AfterSolveStepEvent(method));
   } else if(this->n_iter == max_iteration) {
     AKANTU_DEBUG_WARNING("[" << criteria << "] Convergence not reached after "
                          << std::setw(std::log10(max_iteration)) << this->n_iter <<
                          " iteration" << (this->n_iter == 1 ? "" : "s") << "!" << std::endl);
   }
 
   return converged;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <GeneralizedTrapezoidal::IntegrationSchemeCorrectorType type>
 void HeatTransferModel::solve(Array<Real> &increment, Real block_val,
 			      bool need_factorize, bool has_profile_changed){
 
   updateResidualInternal(); //doesn't do anything for static
 
   if(need_factorize) {
     Real c = 0.,e = 0.;
 
     if(method == _static) {
       AKANTU_DEBUG_INFO("Solving K inc = r");
       e = 1.;
     } else {
       AKANTU_DEBUG_INFO("Solving (c M + e K) inc = r");
 
       GeneralizedTrapezoidal * trap_int = dynamic_cast<GeneralizedTrapezoidal*>(integrator);
       c = trap_int->getTemperatureRateCoefficient<type>(time_step);
       e = trap_int->getTemperatureCoefficient<type>(time_step);
 
       //      std::cout << "c " << c << " e " << e << std::endl;
     }
 
 
     jacobian_matrix->clear();
     // J = c M + e K
     if(conductivity_matrix)
       jacobian_matrix->add(*conductivity_matrix, e);
 
     if(capacity_matrix)
       jacobian_matrix->add(*capacity_matrix, c);
 
 #if !defined(AKANTU_NDEBUG)
     //    if(capacity_matrix && AKANTU_DEBUG_TEST(dblDump))
       capacity_matrix->saveMatrix("M.mtx");
 #endif
 
     jacobian_matrix->applyBoundary(*blocked_dofs, block_val);
 
 #if !defined(AKANTU_NDEBUG)
     //if(AKANTU_DEBUG_TEST(dblDump))
       jacobian_matrix->saveMatrix("J.mtx");
 #endif
     solver->factorize();
   }
 
-  // if (rhs.getSize() != 0)
+  // if (rhs.size() != 0)
   //  solver->setRHS(rhs);
   // else
 
   solver->setOperators();
 
   solver->setRHS(*residual);
 
   // solve @f[ J \delta w = r @f]
   solver->solve(increment);
 
-  UInt nb_nodes = temperature->getSize();
+  UInt nb_nodes = temperature->size();
   UInt nb_degree_of_freedom = temperature->getNbComponent() * nb_nodes;
 
   bool * blocked_dofs_val = blocked_dofs->storage();
   Real * increment_val = increment.storage();
 
   for (UInt j = 0; j < nb_degree_of_freedom;
        ++j,++increment_val, ++blocked_dofs_val) {
     if ((*blocked_dofs_val))
       *increment_val = 0.0;
     }
 
 }
 
 /* -------------------------------------------------------------------------- */
 
diff --git a/src/model/integration_scheme/generalized_trapezoidal.cc b/src/model/integration_scheme/generalized_trapezoidal.cc
index 5ef035f12..6fa4eb236 100644
--- a/src/model/integration_scheme/generalized_trapezoidal.cc
+++ b/src/model/integration_scheme/generalized_trapezoidal.cc
@@ -1,192 +1,192 @@
 /**
  * @file   generalized_trapezoidal.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jul 04 2011
  * @date last modification: Thu Jun 05 2014
  *
  * @brief  implementation of inline functions
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * 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 "generalized_trapezoidal.hh"
 #include "mesh.hh"
 #include "aka_array.hh"
 #include "dof_manager.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 GeneralizedTrapezoidal::GeneralizedTrapezoidal(DOFManager & dof_manager,
                                                const ID & dof_id, Real alpha)
     : IntegrationScheme1stOrder(dof_manager, dof_id), alpha(alpha) {
 
   this->registerParam("alpha", this->alpha, alpha, _pat_parsmod, "The alpha parameter");
 }
 
 /* -------------------------------------------------------------------------- */
 void GeneralizedTrapezoidal::predictor(Real delta_t, Array<Real> & u,
                                        Array<Real> & u_dot,
                                        const Array<bool> & blocked_dofs) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = u.getSize();
+  UInt nb_nodes = u.size();
   UInt nb_degree_of_freedom = u.getNbComponent() * nb_nodes;
 
   Real * u_val = u.storage();
   Real * u_dot_val = u_dot.storage();
   bool * blocked_dofs_val = blocked_dofs.storage();
 
   for (UInt d = 0; d < nb_degree_of_freedom; d++) {
     if (!(*blocked_dofs_val)) {
       *u_val += (1. - alpha) * delta_t * *u_dot_val;
     }
     u_val++;
     u_dot_val++;
     blocked_dofs_val++;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GeneralizedTrapezoidal::corrector(const SolutionType & type, Real delta_t,
                                        Array<Real> & u, Array<Real> & u_dot,
                                        const Array<bool> & blocked_dofs,
                                        const Array<Real> & delta) const {
   AKANTU_DEBUG_IN();
 
   switch (type) {
   case _temperature:
     this->allCorrector<_temperature>(delta_t, u, u_dot, blocked_dofs, delta);
     break;
   case _temperature_rate:
     this->allCorrector<_temperature_rate>(delta_t, u, u_dot, blocked_dofs,
                                           delta);
     break;
   default:
     AKANTU_EXCEPTION("The corrector type : "
                      << type
                      << " is not supported by this type of integration scheme");
   }
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 Real GeneralizedTrapezoidal::getTemperatureCoefficient(
     const SolutionType & type, Real delta_t) const {
   switch (type) {
   case _temperature:
     return 1.;
   case _temperature_rate:
     return alpha * delta_t;
   default:
     AKANTU_EXCEPTION("The corrector type : "
                      << type
                      << " is not supported by this type of integration scheme");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Real GeneralizedTrapezoidal::getTemperatureRateCoefficient(
     const SolutionType & type, Real delta_t) const {
   switch (type) {
   case _temperature:
     return 1. / (alpha * delta_t);
   case _temperature_rate:
     return 1.;
   default:
     AKANTU_EXCEPTION("The corrector type : "
                      << type
                      << " is not supported by this type of integration scheme");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <IntegrationScheme::SolutionType type>
 void GeneralizedTrapezoidal::allCorrector(Real delta_t, Array<Real> & u,
                                           Array<Real> & u_dot,
                                           const Array<bool> & blocked_dofs,
                                           const Array<Real> & delta) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = u.getSize();
+  UInt nb_nodes = u.size();
   UInt nb_degree_of_freedom = u.getNbComponent() * nb_nodes;
 
   Real e = getTemperatureCoefficient(type, delta_t);
   Real d = getTemperatureRateCoefficient(type, delta_t);
 
   Real * u_val = u.storage();
   Real * u_dot_val = u_dot.storage();
   Real * delta_val = delta.storage();
   bool * blocked_dofs_val = blocked_dofs.storage();
 
   for (UInt dof = 0; dof < nb_degree_of_freedom; dof++) {
     if (!(*blocked_dofs_val)) {
       *u_val += e ** delta_val;
       *u_dot_val += d ** delta_val;
     }
     u_val++;
     u_dot_val++;
     delta_val++;
     blocked_dofs_val++;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void GeneralizedTrapezoidal::assembleJacobian(const SolutionType & type,
                                               Real delta_t) {
   AKANTU_DEBUG_IN();
 
   SparseMatrix & J = this->dof_manager.getMatrix("J");
 
   const SparseMatrix & M = this->dof_manager.getMatrix("M");
   const SparseMatrix & K = this->dof_manager.getMatrix("K");
 
   bool does_j_need_update = false;
   does_j_need_update |= M.getRelease() != m_release;
   does_j_need_update |= K.getRelease() != k_release;
   if (!does_j_need_update) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
   J.clear();
 
   Real c = this->getTemperatureRateCoefficient(type, delta_t);
   Real e = this->getTemperatureCoefficient(type, delta_t);
 
   J.add(M, e);
   J.add(K, c);
 
   m_release = M.getRelease();
   k_release = K.getRelease();
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
diff --git a/src/model/integration_scheme/newmark-beta.cc b/src/model/integration_scheme/newmark-beta.cc
index 44ba3091a..be0d3cdeb 100644
--- a/src/model/integration_scheme/newmark-beta.cc
+++ b/src/model/integration_scheme/newmark-beta.cc
@@ -1,260 +1,260 @@
 /**
  * @file   newmark-beta.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Oct 05 2010
  * @date last modification: Thu Jun 05 2014
  *
  * @brief  implementation of the  newmark-@f$\beta@f$ integration  scheme.  This
  * implementation is taken from Méthodes  numériques en mécanique des solides by
  * Alain Curnier \note{ISBN: 2-88074-247-1}
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * 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 "newmark-beta.hh"
 #include "dof_manager.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NewmarkBeta::NewmarkBeta(DOFManager & dof_manager, const ID & dof_id,
                          Real alpha, Real beta)
     : IntegrationScheme2ndOrder(dof_manager, dof_id), beta(beta), alpha(alpha),
       k(0.), h(0.), m_release(0), k_release(0), c_release(0) {
 
   this->registerParam("alpha", this->alpha, alpha, _pat_parsmod,
                       "The alpha parameter");
   this->registerParam("beta", this->beta, beta, _pat_parsmod,
                       "The beta parameter");
 }
 
 /* -------------------------------------------------------------------------- */
 /*
  * @f$ \tilde{u_{n+1}} = u_{n} +  \Delta t \dot{u}_n + \frac{\Delta t^2}{2}
  * \ddot{u}_n @f$
  * @f$ \tilde{\dot{u}_{n+1}} = \dot{u}_{n} +  \Delta t \ddot{u}_{n} @f$
  * @f$ \tilde{\ddot{u}_{n}} = \ddot{u}_{n} @f$
  */
 void NewmarkBeta::predictor(Real delta_t, Array<Real> & u, Array<Real> & u_dot,
                             Array<Real> & u_dot_dot,
                             const Array<bool> & blocked_dofs) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = u.getSize();
+  UInt nb_nodes = u.size();
   UInt nb_degree_of_freedom = u.getNbComponent() * nb_nodes;
 
   Real * u_val = u.storage();
   Real * u_dot_val = u_dot.storage();
   Real * u_dot_dot_val = u_dot_dot.storage();
   bool * blocked_dofs_val = blocked_dofs.storage();
 
   for (UInt d = 0; d < nb_degree_of_freedom; d++) {
     if (!(*blocked_dofs_val)) {
       Real dt_a_n = delta_t * *u_dot_dot_val;
 
       *u_val += (1 - k * alpha) * delta_t * *u_dot_val +
                 (.5 - h * alpha * beta) * delta_t * dt_a_n;
       *u_dot_val = (1 - k) * *u_dot_val + (1 - h * beta) * dt_a_n;
       *u_dot_dot_val = (1 - h) * *u_dot_dot_val;
     }
     u_val++;
     u_dot_val++;
     u_dot_dot_val++;
     blocked_dofs_val++;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NewmarkBeta::corrector(const SolutionType & type, Real delta_t,
                             Array<Real> & u, Array<Real> & u_dot,
                             Array<Real> & u_dot_dot,
                             const Array<bool> & blocked_dofs,
                             const Array<Real> & delta) const {
   AKANTU_DEBUG_IN();
 
   switch (type) {
   case _acceleration: {
     this->allCorrector<_acceleration>(delta_t, u, u_dot, u_dot_dot,
                                       blocked_dofs, delta);
     break;
   }
   case _velocity: {
     this->allCorrector<_velocity>(delta_t, u, u_dot, u_dot_dot, blocked_dofs,
                                   delta);
     break;
   }
   case _displacement: {
     this->allCorrector<_displacement>(delta_t, u, u_dot, u_dot_dot,
                                       blocked_dofs, delta);
     break;
   }
   default:
     AKANTU_EXCEPTION("The corrector type : "
                      << type
                      << " is not supported by this type of integration scheme");
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real NewmarkBeta::getAccelerationCoefficient(const SolutionType & type,
                                              Real delta_t) const {
   switch (type) {
   case _acceleration:
     return 1.;
   case _velocity:
     return 1. / (beta * delta_t);
   case _displacement:
     return 1. / (alpha * beta * delta_t * delta_t);
   default:
     AKANTU_EXCEPTION("The corrector type : "
                      << type
                      << " is not supported by this type of integration scheme");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Real NewmarkBeta::getVelocityCoefficient(const SolutionType & type,
                                          Real delta_t) const {
   switch (type) {
   case _acceleration:
     return beta * delta_t;
   case _velocity:
     return 1.;
   case _displacement:
     return 1. / (alpha * delta_t);
   default:
     AKANTU_EXCEPTION("The corrector type : "
                      << type
                      << " is not supported by this type of integration scheme");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Real NewmarkBeta::getDisplacementCoefficient(const SolutionType & type,
                                              Real delta_t) const {
   switch (type) {
   case _acceleration:
     return alpha * beta * delta_t * delta_t;
   case _velocity:
     return alpha * delta_t;
   case _displacement:
     return 1.;
   default:
     AKANTU_EXCEPTION("The corrector type : "
                      << type
                      << " is not supported by this type of integration scheme");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <IntegrationScheme::SolutionType type>
 void NewmarkBeta::allCorrector(Real delta_t, Array<Real> & u,
                                Array<Real> & u_dot, Array<Real> & u_dot_dot,
                                const Array<bool> & blocked_dofs,
                                const Array<Real> & delta) const {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = u.getSize();
+  UInt nb_nodes = u.size();
   UInt nb_degree_of_freedom = u.getNbComponent() * nb_nodes;
 
   Real c = getAccelerationCoefficient(type, delta_t);
   Real d = getVelocityCoefficient(type, delta_t);
   Real e = getDisplacementCoefficient(type, delta_t);
 
   Real * u_val = u.storage();
   Real * u_dot_val = u_dot.storage();
   Real * u_dot_dot_val = u_dot_dot.storage();
   Real * delta_val = delta.storage();
   bool * blocked_dofs_val = blocked_dofs.storage();
 
   for (UInt dof = 0; dof < nb_degree_of_freedom; dof++) {
     if (!(*blocked_dofs_val)) {
       *u_val += e * *delta_val;
       *u_dot_val += d * *delta_val;
       *u_dot_dot_val += c * *delta_val;
     }
     u_val++;
     u_dot_val++;
     u_dot_dot_val++;
     delta_val++;
     blocked_dofs_val++;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NewmarkBeta::assembleJacobian(const SolutionType & type, Real delta_t) {
   AKANTU_DEBUG_IN();
 
   SparseMatrix & J = this->dof_manager.getMatrix("J");
 
   const SparseMatrix & M = this->dof_manager.getMatrix("M");
   const SparseMatrix & K = this->dof_manager.getMatrix("K");
 
   bool does_j_need_update = false;
   does_j_need_update |= M.getRelease() != m_release;
   does_j_need_update |= K.getRelease() != k_release;
   if (this->dof_manager.hasMatrix("C")) {
     const SparseMatrix & C = this->dof_manager.getMatrix("C");
     does_j_need_update |= C.getRelease() != c_release;
   }
 
   if (!does_j_need_update) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
   J.clear();
 
   Real c = this->getAccelerationCoefficient(type, delta_t);
   Real e = this->getDisplacementCoefficient(type, delta_t);
 
   if (!(e == 0.)) { // in explicit this coefficient is exactly 0.
     J.add(K, e);
   }
 
   J.add(M, c);
 
   m_release = M.getRelease();
   k_release = K.getRelease();
 
   if (this->dof_manager.hasMatrix("C")) {
     Real d = this->getVelocityCoefficient(type, delta_t);
     const SparseMatrix & C = this->dof_manager.getMatrix("C");
     J.add(C, d);
     c_release = C.getRelease();
   }
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/integration_scheme/pseudo_time.cc b/src/model/integration_scheme/pseudo_time.cc
index c19ff6ffe..c0685336f 100644
--- a/src/model/integration_scheme/pseudo_time.cc
+++ b/src/model/integration_scheme/pseudo_time.cc
@@ -1,85 +1,85 @@
 /**
  * @file   pseudo_time.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Feb 17 09:49:10 2016
  *
  * @brief  Implementation of a really simple integration scheme
  *
  * @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 "pseudo_time.hh"
 #include "dof_manager.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 PseudoTime::PseudoTime(DOFManager & dof_manager, const ID & dof_id)
     : IntegrationScheme(dof_manager, dof_id, 0), k_release(0) {}
 
 /* -------------------------------------------------------------------------- */
 void PseudoTime::predictor(Real) {}
 
 /* -------------------------------------------------------------------------- */
 void PseudoTime::corrector(const SolutionType &, Real) {
   Array<Real> & us = this->dof_manager.getDOFs(this->dof_id);
   const Array<Real> & deltas = this->dof_manager.getSolution(this->dof_id);
   const Array<bool> & blocked_dofs =
       this->dof_manager.getBlockedDOFs(this->dof_id);
 
-  UInt nb_degree_of_freedom = deltas.getSize();
+  UInt nb_degree_of_freedom = deltas.size();
 
   auto u_it = us.begin_reinterpret(nb_degree_of_freedom);
   auto bld_it = blocked_dofs.begin_reinterpret(nb_degree_of_freedom);
 
   for (const auto & delta : deltas) {
     const auto & bld = *bld_it;
     auto & u = *u_it;
     if (! bld)  u += delta;
 
     ++u_it;
     ++bld_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void PseudoTime::assembleJacobian(const SolutionType &, Real) {
   SparseMatrix & J = this->dof_manager.getMatrix("J");
   const SparseMatrix & K = this->dof_manager.getMatrix("K");
 
   if (K.getRelease() == k_release)
     return;
 
   J.clear();
   J.add(K);
 
   k_release = K.getRelease();
 }
 
 /* -------------------------------------------------------------------------- */
 void PseudoTime::assembleResidual(bool) {}
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/model_inline_impl.cc b/src/model/model_inline_impl.cc
index 1970a4274..a82ed4714 100644
--- a/src/model/model_inline_impl.cc
+++ b/src/model/model_inline_impl.cc
@@ -1,210 +1,210 @@
 /**
  * @file   model_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 25 2010
  * @date last modification: Wed Nov 11 2015
  *
  * @brief  inline implementation of the model class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MODEL_INLINE_IMPL_CC__
 #define __AKANTU_MODEL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename FEEngineClass>
 inline FEEngineClass & Model::getFEEngineClassBoundary(std::string name) {
   AKANTU_DEBUG_IN();
 
   if (name == "")
     name = default_fem;
 
   FEEngineMap::const_iterator it_boun = fems_boundary.find(name);
 
   FEEngineClass * tmp_fem_boundary;
 
   if (it_boun == fems_boundary.end()) {
     AKANTU_DEBUG_INFO("Creating FEEngine boundary " << name);
 
     FEEngineMap::const_iterator it = fems.find(name);
     AKANTU_DEBUG_ASSERT(it != fems.end(), "The FEEngine "
                                               << name << " is not registered");
 
     UInt spatial_dimension = it->second->getElementDimension();
     std::stringstream sstr;
     sstr << id << ":fem_boundary:" << name;
 
     tmp_fem_boundary = new FEEngineClass(
         it->second->getMesh(), spatial_dimension - 1, sstr.str(), memory_id);
     fems_boundary[name] = tmp_fem_boundary;
   } else {
     tmp_fem_boundary = dynamic_cast<FEEngineClass *>(it_boun->second);
   }
 
   AKANTU_DEBUG_OUT();
   return *tmp_fem_boundary;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename FEEngineClass>
 inline FEEngineClass & Model::getFEEngineClass(std::string name) const {
   AKANTU_DEBUG_IN();
 
   if (name == "")
     name = default_fem;
 
   FEEngineMap::const_iterator it = fems.find(name);
   AKANTU_DEBUG_ASSERT(it != fems.end(), "The FEEngine "
                                             << name << " is not registered");
 
   AKANTU_DEBUG_OUT();
   return dynamic_cast<FEEngineClass &>(*(it->second));
 }
 
 /* -------------------------------------------------------------------------- */
 
 inline void Model::unRegisterFEEngineObject(const std::string & name) {
 
   FEEngineMap::iterator it = fems.find(name);
   AKANTU_DEBUG_ASSERT(it != fems.end(), "FEEngine object with name "
                                             << name << " was not found");
 
   delete ((*it).second);
   fems.erase(it);
   if (!fems.empty())
     default_fem = (*fems.begin()).first;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <typename FEEngineClass>
 inline void Model::registerFEEngineObject(const std::string & name, Mesh & mesh,
                                           UInt spatial_dimension) {
   if (fems.size() == 0)
     default_fem = name;
 
 #ifndef AKANTU_NDEBUG
   FEEngineMap::iterator it = fems.find(name);
   AKANTU_DEBUG_ASSERT(it == fems.end(), "FEEngine object with name "
                                             << name << " was already created");
 #endif
 
   std::stringstream sstr;
   sstr << id << ":fem:" << name << memory_id;
   fems[name] =
       new FEEngineClass(mesh, spatial_dimension, sstr.str(), memory_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline FEEngine & Model::getFEEngine(const ID & name) const {
   AKANTU_DEBUG_IN();
   ID tmp_name = name;
   if (name == "")
     tmp_name = default_fem;
 
   FEEngineMap::const_iterator it = fems.find(tmp_name);
 
   AKANTU_DEBUG_ASSERT(it != fems.end(),
                       "The FEEngine " << tmp_name << " is not registered");
 
   AKANTU_DEBUG_OUT();
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 inline FEEngine & Model::getFEEngineBoundary(const ID & name) {
   AKANTU_DEBUG_IN();
 
   ID tmp_name = name;
   if (name == "")
     tmp_name = default_fem;
 
   FEEngineMap::const_iterator it = fems_boundary.find(tmp_name);
   AKANTU_DEBUG_ASSERT(it != fems_boundary.end(), "The FEEngine boundary  "
                                                      << tmp_name
                                                      << " is not registered");
   AKANTU_DEBUG_ASSERT(it->second != NULL, "The FEEngine boundary "
                                               << tmp_name
                                               << " was not created");
 
   AKANTU_DEBUG_OUT();
   return *(it->second);
 }
 
 // /* --------------------------------------------------------------------------
 // */
 // /// @todo : should merge with a single function which handles local and
 // global
 // inline void Model::changeLocalEquationNumberForPBC(std::map<UInt,UInt> &
 // pbc_pair,
 // 					    UInt dimension){
 //   for (std::map<UInt,UInt>::iterator it = pbc_pair.begin();
 //        it != pbc_pair.end();++it) {
 //     Int node_master = (*it).second;
 //     Int node_slave = (*it).first;
 //     for (UInt i = 0; i < dimension; ++i) {
 //       (*dof_synchronizer->getLocalDOFEquationNumbersPointer())
 // 	(node_slave*dimension+i) = dimension*node_master+i;
 //       (*dof_synchronizer->getGlobalDOFEquationNumbersPointer())
 // 	(node_slave*dimension+i) = dimension*node_master+i;
 //     }
 //   }
 // }
 // /* --------------------------------------------------------------------------
 // */
 // inline bool Model::isPBCSlaveNode(const UInt node) const {
 //   // if no pbc is defined, is_pbc_slave_node is of size zero
-//   if (is_pbc_slave_node.getSize() == 0)
+//   if (is_pbc_slave_node.size() == 0)
 //     return false;
 //   else
 //     return is_pbc_slave_node(node);
 // }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Model::getNbIntegrationPoints(const Array<Element> & elements,
                                           const ID & fem_id) const {
   UInt nb_quad = 0;
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     nb_quad +=
         getFEEngine(fem_id).getNbIntegrationPoints(el.type, el.ghost_type);
   }
   return nb_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_MODEL_INLINE_IMPL_CC__ */
diff --git a/src/model/model_solver.cc b/src/model/model_solver.cc
index 6fafb2844..91b8f39cf 100644
--- a/src/model/model_solver.cc
+++ b/src/model/model_solver.cc
@@ -1,673 +1,673 @@
 /**
  * @file   model_solver.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 12 13:31:56 2015
  *
  * @brief  Implementation of ModelSolver
  *
  * @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 "model_solver.hh"
 #include "dof_manager.hh"
 #include "non_linear_solver.hh"
 #include "time_step_solver.hh"
 
 #include "mesh.hh"
 
 #if defined(AKANTU_USE_MPI)
 #include "mpi_type_wrapper.hh"
 #endif
 
 #include "dof_manager_default.hh"
 
 #if defined(AKANTU_USE_PETSC)
 #include "dof_manager_petsc.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ModelSolver::ModelSolver(Mesh & mesh, const ID & id, UInt memory_id)
     : Parsable(_st_model_solver, id), SolverCallback(), parent_id(id),
       parent_memory_id(memory_id), mesh(mesh), dof_manager(NULL),
       default_solver_id("") {}
 
 /* -------------------------------------------------------------------------- */
 ModelSolver::~ModelSolver() { delete this->dof_manager; }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::initDOFManager() {
   std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
     sub_sect = getStaticParser().getSubSections(_st_model_solver);
 
   // default without external solver activated at compilation same as mumps that
   // is the historical solver but with only the lumped solver
   ID solver_type = "explicit";
 
 #if defined(AKANTU_USE_MUMPS)
   solver_type = "mumps";
 #elif defined(AKANTU_USE_PETSC)
   solver_type = "petsc";
 #endif
 
   const ParserSection * section = NULL;
   Parser::const_section_iterator it;
   for (it = sub_sect.first; it != sub_sect.second && section == NULL; ++it) {
     if (it->getName() == this->parent_id) {
       section = &(*it);
       solver_type = section->getOption(solver_type);
     }
   }
 
   if (section) {
     this->initDOFManager(*section, solver_type);
   } else {
     this->initDOFManager(solver_type);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::initDOFManager(const ID & solver_type) {
   if (solver_type == "explicit") {
     ID id = this->parent_id + ":dof_manager_default";
     this->dof_manager = new DOFManagerDefault(mesh, id, this->parent_memory_id);
   } else if (solver_type == "petsc") {
 #if defined(AKANTU_USE_PETSC)
     ID id = this->parent_id + ":dof_manager_petsc";
     this->dof_manager = new DOFManagerPETSc(mesh, id, this->parent_memory_id);
 #else
     AKANTU_EXCEPTION(
         "To use PETSc you have to activate it in the compilations options");
 #endif
   } else if (solver_type == "mumps") {
 #if defined(AKANTU_USE_MUMPS)
     ID id = this->parent_id + ":dof_manager_default";
     this->dof_manager = new DOFManagerDefault(mesh, id, this->parent_memory_id);
 #else
     AKANTU_EXCEPTION(
         "To use MUMPS you have to activate it in the compilations options");
 #endif
   } else {
     AKANTU_EXCEPTION(
         "To use the solver "
         << solver_type
         << " you will have to code it. This is an unknown solver type.");
   }
 
     this->setDOFManager(*this->dof_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> static T getOptionToType(const std::string & opt_str) {
   std::stringstream sstr(opt_str);
   T opt;
   sstr >> opt;
 
   return opt;
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::initDOFManager(const ParserSection & section,
                                  const ID & solver_type) {
   this->initDOFManager(solver_type);
   std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
     sub_sect = section.getSubSections(_st_time_step_solver);
 
   Parser::const_section_iterator it;
   for (it = sub_sect.first; it != sub_sect.second; ++it) {
     ID solver_id = it->getName();
 
     std::string str = it->getOption();
     TimeStepSolverType tss_type =
       it->getParameter("type", this->getDefaultSolverType());
     ModelSolverOptions tss_options = this->getDefaultSolverOptions(tss_type);
 
     std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
       sub_solvers_sect = it->getSubSections(_st_non_linear_solver);
     Parser::const_section_iterator sub_it;
     UInt nb_non_linear_solver_section =
       it->getNbSubSections(_st_non_linear_solver);
 
     NonLinearSolverType nls_type = tss_options.non_linear_solver_type;
 
     if (nb_non_linear_solver_section == 1) {
       const ParserSection & nls_section = *(sub_solvers_sect.first);
       nls_type = getOptionToType<NonLinearSolverType>(nls_section.getName());
     } else if (nb_non_linear_solver_section > 0) {
       AKANTU_EXCEPTION("More than one non linear solver are provided for the "
                        "time step solver "
                        << solver_id);
     }
 
     this->getNewSolver(solver_id, tss_type, nls_type);
     if (nb_non_linear_solver_section == 1) {
       const ParserSection & nls_section = *(sub_solvers_sect.first);
       this->dof_manager->getNonLinearSolver(solver_id).parseSection(
           nls_section);
     }
 
     std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
       sub_integrator_sect = it->getSubSections(_st_integration_scheme);
 
     for (sub_it = sub_integrator_sect.first;
          sub_it != sub_integrator_sect.second; ++sub_it) {
       const ParserSection & is_section = *sub_it;
       const ID & dof_id = is_section.getName();
 
       IntegrationSchemeType it_type = is_section.getParameter(
           "type", tss_options.integration_scheme_type[dof_id]);
 
       IntegrationScheme::SolutionType s_type = is_section.getParameter(
           "solution_type", tss_options.solution_type[dof_id]);
       this->setIntegrationScheme(solver_id, dof_id, it_type, s_type);
     }
 
     std::map<ID, IntegrationSchemeType>::const_iterator it =
       tss_options.integration_scheme_type.begin();
     std::map<ID, IntegrationSchemeType>::const_iterator end =
       tss_options.integration_scheme_type.end();
     for (; it != end; ++it) {
       if (!this->hasIntegrationScheme(solver_id, it->first)) {
         this->setIntegrationScheme(solver_id, it->first, it->second,
                                    tss_options.solution_type[it->first]);
       }
     }
   }
 
   if (section.hasParameter("default_solver")) {
     ID default_solver = section.getParameter("default_solver");
     this->setDefaultSolver(default_solver);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & ModelSolver::getSolver(const ID & solver_id) {
   ID tmp_solver_id = solver_id;
   if (tmp_solver_id == "")
     tmp_solver_id = this->default_solver_id;
 
   TimeStepSolver & tss = this->dof_manager->getTimeStepSolver(tmp_solver_id);
   return tss;
 }
 
 /* -------------------------------------------------------------------------- */
 const TimeStepSolver & ModelSolver::getSolver(const ID & solver_id) const {
   ID tmp_solver_id = solver_id;
   if (solver_id == "")
     tmp_solver_id = this->default_solver_id;
 
   const TimeStepSolver & tss =
       this->dof_manager->getTimeStepSolver(tmp_solver_id);
   return tss;
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & ModelSolver::getTimeStepSolver(const ID & solver_id) {
   return this->getSolver(solver_id);
 }
 
 /* -------------------------------------------------------------------------- */
 const TimeStepSolver &
 ModelSolver::getTimeStepSolver(const ID & solver_id) const {
   return this->getSolver(solver_id);
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver & ModelSolver::getNonLinearSolver(const ID & solver_id) {
   return this->getSolver(solver_id).getNonLinearSolver();
 }
 /* -------------------------------------------------------------------------- */
 const NonLinearSolver &
 ModelSolver::getNonLinearSolver(const ID & solver_id) const {
   return this->getSolver(solver_id).getNonLinearSolver();
 }
 
 /* -------------------------------------------------------------------------- */
 bool ModelSolver::hasSolver(const ID & solver_id) const {
   ID tmp_solver_id = solver_id;
   if (solver_id == "")
     tmp_solver_id = this->default_solver_id;
 
   return this->dof_manager->hasTimeStepSolver(tmp_solver_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::setDefaultSolver(const ID & solver_id) {
   AKANTU_DEBUG_ASSERT(
       this->hasSolver(solver_id),
       "Cannot set the default solver to a solver that does not exists");
   this->default_solver_id = solver_id;
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::solveStep(const ID & solver_id) {
   AKANTU_DEBUG_IN();
 
   TimeStepSolver & tss = this->getSolver(solver_id);
   // make one non linear solve
   tss.solveStep(*this);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::getNewSolver(const ID & solver_id,
                                TimeStepSolverType time_step_solver_type,
                                NonLinearSolverType non_linear_solver_type) {
   if (this->default_solver_id == "") {
     this->default_solver_id = solver_id;
   }
 
   if (non_linear_solver_type == _nls_auto) {
     switch (time_step_solver_type) {
     case _tsst_dynamic:
     case _tsst_static:
       non_linear_solver_type = _nls_newton_raphson;
       break;
     case _tsst_dynamic_lumped:
       non_linear_solver_type = _nls_lumped;
       break;
     }
   }
 
   this->initSolver(time_step_solver_type, non_linear_solver_type);
 
   NonLinearSolver & nls = this->dof_manager->getNewNonLinearSolver(
       solver_id, non_linear_solver_type);
 
   this->dof_manager->getNewTimeStepSolver(solver_id, time_step_solver_type,
                                           nls);
 }
 
 /* -------------------------------------------------------------------------- */
 Real ModelSolver::getTimeStep(const ID & solver_id) const {
   const TimeStepSolver & tss = this->getSolver(solver_id);
 
   return tss.getTimeStep();
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::setTimeStep(Real time_step, const ID & solver_id) {
   TimeStepSolver & tss = this->getSolver(solver_id);
 
   return tss.setTimeStep(time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::setIntegrationScheme(
     const ID & solver_id, const ID & dof_id,
     const IntegrationSchemeType & integration_scheme_type,
     IntegrationScheme::SolutionType solution_type) {
   TimeStepSolver & tss = this->dof_manager->getTimeStepSolver(solver_id);
 
   tss.setIntegrationScheme(dof_id, integration_scheme_type, solution_type);
 }
 
 /* -------------------------------------------------------------------------- */
 bool ModelSolver::hasDefaultSolver() const {
   return (this->default_solver_id != "");
 }
 
 /* -------------------------------------------------------------------------- */
 bool ModelSolver::hasIntegrationScheme(const ID & solver_id,
                                        const ID & dof_id) const {
   TimeStepSolver & tss = this->dof_manager->getTimeStepSolver(solver_id);
   return tss.hasIntegrationScheme(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::predictor() {}
 
 /* -------------------------------------------------------------------------- */
 void ModelSolver::corrector() {}
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverType ModelSolver::getDefaultSolverType() const {
   return _tsst_dynamic_lumped;
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions
 ModelSolver::getDefaultSolverOptions(__attribute__((unused))
                                      const TimeStepSolverType & type) const {
   ModelSolverOptions options;
   options.non_linear_solver_type = _nls_auto;
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 // void ModelSolver::setIntegrationScheme(
 //     const ID & solver_id, const ID & dof_id,
 //     const IntegrationSchemeType & integration_scheme_type) {}
 
 /* -------------------------------------------------------------------------- */
 
 // /* --------------------------------------------------------------------------
 // */
 // template <NewmarkBeta::IntegrationSchemeCorrectorType type>
 // void SolidMechanicsModel::solve(Array<Real> &increment, Real block_val,
 //                                 bool need_factorize, bool
 //                                 has_profile_changed) {
 
 //   if(has_profile_changed) {
 //     this->initJacobianMatrix();
 //     need_factorize = true;
 //   }
 
 //   updateResidualInternal(); //doesn't do anything for static
 
 //   if(need_factorize) {
 //     Real c = 0.,d = 0.,e = 0.;
 
 //     if(method == _static) {
 //       AKANTU_DEBUG_INFO("Solving K inc = r");
 //       e = 1.;
 //     } else {
 //       AKANTU_DEBUG_INFO("Solving (c M + d C + e K) inc = r");
 
 //       NewmarkBeta * nmb_int = dynamic_cast<NewmarkBeta *>(integrator);
 //       c = nmb_int->getAccelerationCoefficient<type>(time_step);
 //       d = nmb_int->getVelocityCoefficient<type>(time_step);
 //       e = nmb_int->getDisplacementCoefficient<type>(time_step);
 //     }
 
 //     jacobian_matrix->clear();
 //     // J = c M + d C + e K
 //     if(stiffness_matrix)
 //       jacobian_matrix->add(*stiffness_matrix, e);
 
 //     if(mass_matrix)
 //       jacobian_matrix->add(*mass_matrix, c);
 
 // #if !defined(AKANTU_NDEBUG)
 //     if(mass_matrix && AKANTU_DEBUG_TEST(dblDump))
 //       mass_matrix->saveMatrix("M.mtx");
 // #endif
 
 //     if(velocity_damping_matrix)
 //       jacobian_matrix->add(*velocity_damping_matrix, d);
 
 //     jacobian_matrix->applyBoundary(*blocked_dofs, block_val);
 
 // #if !defined(AKANTU_NDEBUG)
 //     if(AKANTU_DEBUG_TEST(dblDump))
 //       jacobian_matrix->saveMatrix("J.mtx");
 // #endif
 //     solver->factorize();
 //   }
 
-//   // if (rhs.getSize() != 0)
+//   // if (rhs.size() != 0)
 //   //  solver->setRHS(rhs);
 //   // else
 
 //   solver->setOperators();
 
 //   solver->setRHS(*residual);
 
 //   // solve @f[ J \delta w = r @f]
 //   solver->solve(increment);
 
-//   UInt nb_nodes = displacement-> getSize();
+//   UInt nb_nodes = displacement-> size();
 //   UInt nb_degree_of_freedom = displacement->getNbComponent() * nb_nodes;
 
 //   bool * blocked_dofs_val = blocked_dofs->storage();
 //   Real * increment_val = increment.storage();
 
 //   for (UInt j = 0; j < nb_degree_of_freedom;
 //        ++j,++increment_val, ++blocked_dofs_val) {
 //     if ((*blocked_dofs_val))
 //       *increment_val = 0.0;
 //     }
 
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // template<SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 // bool SolidMechanicsModel::solveStatic(Real tolerance, UInt max_iteration,
 //                                       bool do_not_factorize) {
 
 //   AKANTU_DEBUG_INFO("Solving Ku = f");
 //   AKANTU_DEBUG_ASSERT(stiffness_matrix != NULL,
 //                       "You should first initialize the implicit solver and
 //                       assemble the stiffness matrix by calling
 //                       initImplicit");
 
 //   AnalysisMethod analysis_method=method;
 //   Real error = 0.;
 //   method=_static;
 //   bool converged = this->template solveStep<cmethod, criteria>(tolerance,
 //   error, max_iteration, do_not_factorize);
 //   method=analysis_method;
 //   return converged;
 
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // template<SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 // bool SolidMechanicsModel::solveStep(Real tolerance,
 //                                     UInt max_iteration) {
 //   Real error = 0.;
 //   return this->template solveStep<cmethod,criteria>(tolerance,
 //                                                     error,
 //                                                     max_iteration);
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // template<SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 // bool SolidMechanicsModel::solveStep(Real tolerance, Real & error, UInt
 // max_iteration,
 //                                     bool do_not_factorize) {
 //   EventManager::sendEvent(SolidMechanicsModelEvent::BeforeSolveStepEvent(method));
 //   this->implicitPred();
 //   this->updateResidual();
 
 //   AKANTU_DEBUG_ASSERT(stiffness_matrix != NULL,
 //                       "You should first initialize the implicit solver and
 //                       assemble the stiffness matrix");
 
 //   bool need_factorize = !do_not_factorize;
 
 //   if (method==_implicit_dynamic) {
 //     AKANTU_DEBUG_ASSERT(mass_matrix != NULL,
 //                         "You should first initialize the implicit solver and
 //                         assemble the mass matrix");
 //   }
 
 //   switch (cmethod) {
 //   case _scm_newton_raphson_tangent:
 //   case _scm_newton_raphson_tangent_not_computed:
 //     break;
 //   case _scm_newton_raphson_tangent_modified:
 //     this->assembleStiffnessMatrix();
 //     break;
 //   default:
 //     AKANTU_DEBUG_ERROR("The resolution method " << cmethod << " has not been
 //     implemented!");
 //   }
 
 //   this->n_iter = 0;
 //   bool converged = false;
 //   error = 0.;
 //   if(criteria == _scc_residual) {
 //     converged = this->testConvergence<criteria> (tolerance, error);
 //     if(converged) return converged;
 //   }
 
 //   do {
 //     if (cmethod == _scm_newton_raphson_tangent)
 //       this->assembleStiffnessMatrix();
 
 //     solve<NewmarkBeta::_displacement_corrector> (*increment, 1.,
 //     need_factorize);
 
 //     this->implicitCorr();
 
 //     if(criteria == _scc_residual) this->updateResidual();
 
 //     converged = this->testConvergence<criteria> (tolerance, error);
 
 //     if(criteria == _scc_increment && !converged) this->updateResidual();
 //     //this->dump();
 
 //     this->n_iter++;
 //     AKANTU_DEBUG_INFO("[" << criteria << "] Convergence iteration "
 //                       << std::setw(std::log10(max_iteration)) << this->n_iter
 //                       << ": error " << error << (converged ? " < " : " > ")
 //                       << tolerance);
 
 //     switch (cmethod) {
 //     case _scm_newton_raphson_tangent:
 //       need_factorize = true;
 //       break;
 //     case _scm_newton_raphson_tangent_not_computed:
 //     case _scm_newton_raphson_tangent_modified:
 //       need_factorize = false;
 //       break;
 //     default:
 //       AKANTU_DEBUG_ERROR("The resolution method " << cmethod << " has not
 //       been implemented!");
 //     }
 
 //   } while (!converged && this->n_iter < max_iteration);
 
 //   // this makes sure that you have correct strains and stresses after the
 //   solveStep function (e.g., for dumping)
 //   if(criteria == _scc_increment) this->updateResidual();
 
 //   if (converged) {
 //     EventManager::sendEvent(SolidMechanicsModelEvent::AfterSolveStepEvent(method));
 //   } else if(this->n_iter == max_iteration) {
 //     AKANTU_DEBUG_WARNING("[" << criteria << "] Convergence not reached after
 //     "
 //                          << std::setw(std::log10(max_iteration)) <<
 //                          this->n_iter <<
 //                          " iteration" << (this->n_iter == 1 ? "" : "s") <<
 //                          "!" << std::endl);
 //   }
 
 //   return converged;
 // }
 
 // void SolidMechanicsModel::updateResidualInternal() {
 //   AKANTU_DEBUG_IN();
 
 //   AKANTU_DEBUG_INFO("Update the residual");
 //   // f = f_ext - f_int - Ma - Cv = r - Ma - Cv;
 
 //   if(method != _static) {
 //     // f -= Ma
 //     if(mass_matrix) {
 //       // if full mass_matrix
 //       Array<Real> * Ma = new Array<Real>(*acceleration, true, "Ma");
 //       *Ma *= *mass_matrix;
 //       /// \todo check unit conversion for implicit dynamics
 //       //      *Ma /= f_m2a
 //       *residual -= *Ma;
 //       delete Ma;
 //     } else if (mass) {
 
 //       // else lumped mass
-//       UInt nb_nodes = acceleration->getSize();
+//       UInt nb_nodes = acceleration->size();
 //       UInt nb_degree_of_freedom = acceleration->getNbComponent();
 
 //       Real * mass_val     = mass->storage();
 //       Real * accel_val    = acceleration->storage();
 //       Real * res_val      = residual->storage();
 //       bool * blocked_dofs_val = blocked_dofs->storage();
 
 //       for (UInt n = 0; n < nb_nodes * nb_degree_of_freedom; ++n) {
 // 	if(!(*blocked_dofs_val)) {
 // 	  *res_val -= *accel_val * *mass_val /f_m2a;
 // 	}
 // 	blocked_dofs_val++;
 // 	res_val++;
 // 	mass_val++;
 // 	accel_val++;
 //       }
 //     } else {
 //       AKANTU_DEBUG_ERROR("No function called to assemble the mass matrix.");
 //     }
 
 //     // f -= Cv
 //     if(velocity_damping_matrix) {
 //       Array<Real> * Cv = new Array<Real>(*velocity);
 //       *Cv *= *velocity_damping_matrix;
 //       *residual -= *Cv;
 //       delete Cv;
 //     }
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void SolidMechanicsModel::solveLumped(Array<Real> & x,
 // 				      const Array<Real> & A,
 // 				      const Array<Real> & b,
 // 				      const Array<bool> & blocked_dofs,
 // 				      Real alpha) {
 
 //   Real * A_val = A.storage();
 //   Real * b_val = b.storage();
 //   Real * x_val = x.storage();
 //   bool * blocked_dofs_val = blocked_dofs.storage();
 
-//   UInt nb_degrees_of_freedom = x.getSize() * x.getNbComponent();
+//   UInt nb_degrees_of_freedom = x.size() * x.getNbComponent();
 
 //   for (UInt n = 0; n < nb_degrees_of_freedom; ++n) {
 //     if(!(*blocked_dofs_val)) {
 //       *x_val = alpha * (*b_val / *A_val);
 //     }
 //     x_val++;
 //     A_val++;
 //     b_val++;
 //     blocked_dofs_val++;
 //   }
 // }
 
 /* -------------------------------------------------------------------------- */
 // void TimeStepSolverDefault::updateAcceleration() {
 //   AKANTU_DEBUG_IN();
 
 //   updateResidualInternal();
 
 //   if (method == _explicit_lumped_mass) {
 //     /* residual = residual_{n+1} - M * acceleration_n therefore
 //        solution = increment acceleration not acceleration */
 //     solveLumped(*increment_acceleration, *mass, *residual, *blocked_dofs,
 //                 f_m2a);
 //   } else if (method == _explicit_consistent_mass) {
 //     solve<NewmarkBeta::_acceleration_corrector>(*increment_acceleration);
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 } // akantu
diff --git a/src/model/non_linear_solver_lumped.cc b/src/model/non_linear_solver_lumped.cc
index 5b3a89f80..0ff0ae920 100644
--- a/src/model/non_linear_solver_lumped.cc
+++ b/src/model/non_linear_solver_lumped.cc
@@ -1,103 +1,103 @@
 /**
  * @file   non_linear_solver_lumped.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 25 00:57:00 2015
  *
  * @brief  Implementation of the default NonLinearSolver
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_linear_solver_lumped.hh"
 #include "dof_manager_default.hh"
 #include "solver_callback.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolverLumped::NonLinearSolverLumped(
     DOFManagerDefault & dof_manager,
     const NonLinearSolverType & non_linear_solver_type, const ID & id,
     UInt memory_id)
     : NonLinearSolver(dof_manager, non_linear_solver_type, id, memory_id),
       dof_manager(dof_manager) {
   this->supported_type.insert(_nls_lumped);
   this->checkIfTypeIsSupported();
 
   this->registerParam("b_a2x", this->alpha, 1., _pat_parsmod,
                       "Conversion coefficient between x and A^{-1} b");
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolverLumped::~NonLinearSolverLumped() {}
 
 /* ------------------------------------------------------------------------ */
 void NonLinearSolverLumped::solve(SolverCallback & solver_callback) {
   this->dof_manager.updateGlobalBlockedDofs();
   solver_callback.predictor();
 
   const Array<Real> & A = this->dof_manager.getLumpedMatrix("M");
   Array<Real> & x = this->dof_manager.getGlobalSolution();
   const Array<Real> & b = this->dof_manager.getResidual();
 
-  x.resize(b.getSize());
+  x.resize(b.size());
 
   this->dof_manager.updateGlobalBlockedDofs();
   const Array<bool> & blocked_dofs = this->dof_manager.getGlobalBlockedDOFs();
 
   solver_callback.assembleResidual();
 
   // alpha is the conversion factor from from force/mass to acceleration needed
   // in model coupled with atomistic \todo find a way to define alpha per dof
   // type
 
   this->solveLumped(A, x, b, blocked_dofs, alpha);
   this->dof_manager.splitSolutionPerDOFs();
 
   solver_callback.corrector();
 }
 
 /* -------------------------------------------------------------------------- */
 void NonLinearSolverLumped::solveLumped(const Array<Real> & A, Array<Real> & x,
                                         const Array<Real> & b,
                                         const Array<bool> & blocked_dofs,
                                         Real alpha) {
   Array<Real>::const_scalar_iterator A_it = A.begin();
   Array<Real>::scalar_iterator x_it = x.begin();
   Array<Real>::scalar_iterator x_end = x.end();
   Array<Real>::const_scalar_iterator b_it = b.begin();
 
   Array<bool>::const_scalar_iterator blocked_it = blocked_dofs.begin();
 
   for (; x_it != x_end; ++x_it, ++b_it, ++A_it, ++blocked_it) {
     if (!(*blocked_it)) {
       *x_it = alpha *(*b_it / *A_it);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/non_linear_solver_newton_raphson.cc b/src/model/non_linear_solver_newton_raphson.cc
index c2fb7ba4a..8fd996a9c 100644
--- a/src/model/non_linear_solver_newton_raphson.cc
+++ b/src/model/non_linear_solver_newton_raphson.cc
@@ -1,186 +1,186 @@
 /**
  * @file   non_linear_solver_newton_raphson.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 25 00:57:00 2015
  *
  * @brief  Implementation of the default NonLinearSolver
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "non_linear_solver_newton_raphson.hh"
 #include "dof_manager_default.hh"
 #include "solver_callback.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolverNewtonRaphson::NonLinearSolverNewtonRaphson(
     DOFManagerDefault & dof_manager,
     const NonLinearSolverType & non_linear_solver_type, const ID & id,
     UInt memory_id)
     : NonLinearSolver(dof_manager, non_linear_solver_type, id, memory_id),
       dof_manager(dof_manager),
       solver(dof_manager, "J", id + ":sparse_solver", memory_id), n_iter(0),
       error(0.), converged(false) {
 
   this->supported_type.insert(_nls_newton_raphson_modified);
   this->supported_type.insert(_nls_newton_raphson);
   this->supported_type.insert(_nls_linear);
 
   this->checkIfTypeIsSupported();
 
   this->registerParam("threshold", convergence_criteria, 1e-10, _pat_parsmod,
                       "Threshold to consider results as converged");
   this->registerParam("convergence_type", convergence_criteria_type,
                       _scc_solution, _pat_parsmod,
                       "Type of convergence criteria");
   this->registerParam("max_iterations", max_iterations, 10, _pat_parsmod,
                       "Max number of iterations");
   this->registerParam("error", error, _pat_readable, "Last reached error");
   this->registerParam("nb_iterations", n_iter, _pat_readable,
                       "Last reached number of iterations");
   this->registerParam("converged", converged, _pat_readable,
                       "Did last solve converged");
   this->registerParam("force_linear_recompute", force_linear_recompute, true,
                       _pat_modifiable,
                       "Force reassembly of the jacobian matrix");
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolverNewtonRaphson::~NonLinearSolverNewtonRaphson() {}
 
 /* ------------------------------------------------------------------------ */
 void NonLinearSolverNewtonRaphson::solve(SolverCallback & solver_callback) {
   this->dof_manager.updateGlobalBlockedDofs();
 
   solver_callback.predictor();
 
   solver_callback.assembleResidual();
 
   if (this->non_linear_solver_type == _nls_newton_raphson_modified ||
       (this->non_linear_solver_type == _nls_linear &&
        this->force_linear_recompute)) {
     solver_callback.assembleJacobian();
     this->force_linear_recompute = false;
   }
 
   this->n_iter = 0;
   this->converged = false;
 
   if (this->convergence_criteria_type == _scc_residual) {
     this->converged = this->testConvergence(this->dof_manager.getResidual());
 
     if (this->converged)
       return;
   }
 
   do {
     if (this->non_linear_solver_type == _nls_newton_raphson)
       solver_callback.assembleJacobian();
 
     this->solver.solve();
 
     solver_callback.corrector();
 
     // EventManager::sendEvent(NonLinearSolver::AfterSparseSolve(method));
 
     if (this->convergence_criteria_type == _scc_residual) {
       solver_callback.assembleResidual();
       this->converged = this->testConvergence(this->dof_manager.getResidual());
     } else {
       this->converged =
           this->testConvergence(this->dof_manager.getGlobalSolution());
     }
 
     if (this->convergence_criteria_type == _scc_solution && !this->converged)
       solver_callback.assembleResidual();
     // this->dump();
 
     this->n_iter++;
     AKANTU_DEBUG_INFO(
         "[" << this->convergence_criteria_type << "] Convergence iteration "
             << std::setw(std::log10(this->max_iterations)) << this->n_iter
             << ": error " << this->error << (this->converged ? " < " : " > ")
             << this->convergence_criteria);
 
   } while (!this->converged && this->n_iter < this->max_iterations);
 
   // this makes sure that you have correct strains and stresses after the
   // solveStep function (e.g., for dumping)
   if (this->convergence_criteria_type == _scc_solution)
     solver_callback.assembleResidual();
 
   if (this->converged) {
     //    EventManager::sendEvent(
     //   SolidMechanicsModelEvent::AfterNonLinearSolverSolves(method));
   } else if (this->n_iter == this->max_iterations) {
     AKANTU_CUSTOM_EXCEPTION(debug::NLSNotConvergedException(
                                 this->convergence_criteria, this->n_iter, this->error));
 
     AKANTU_DEBUG_WARNING("[" << this->convergence_criteria_type
                              << "] Convergence not reached after "
                              << std::setw(std::log10(this->max_iterations))
                              << this->n_iter << " iteration"
                              << (this->n_iter == 1 ? "" : "s") << "!");
   }
 
   return;
 }
 
 /* -------------------------------------------------------------------------- */
 bool NonLinearSolverNewtonRaphson::testConvergence(const Array<Real> & array) {
   AKANTU_DEBUG_IN();
 
   const Array<bool> & blocked_dofs = this->dof_manager.getGlobalBlockedDOFs();
 
-  UInt nb_degree_of_freedoms = array.getSize();
+  UInt nb_degree_of_freedoms = array.size();
 
   auto arr_it = array.begin();
   auto bld_it = blocked_dofs.begin();
 
   Real norm = 0.;
   for (UInt n = 0; n < nb_degree_of_freedoms; ++n, ++arr_it, ++bld_it) {
     bool is_local_node = this->dof_manager.isLocalOrMasterDOF(n);
     if ((! *bld_it) && is_local_node) {
       norm += *arr_it * *arr_it;
     }
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(norm, _so_sum);
 
   norm = std::sqrt(norm);
 
   AKANTU_DEBUG_ASSERT(!Math::isnan(norm),
                       "Something went wrong in the solve phase");
 
   this->error = norm;
 
   return (error < this->convergence_criteria);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/solid_mechanics/material.cc b/src/model/solid_mechanics/material.cc
index 62d7ae8be..66857a41d 100644
--- a/src/model/solid_mechanics/material.cc
+++ b/src/model/solid_mechanics/material.cc
@@ -1,1630 +1,1630 @@
 /**
  * @file   material.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Tue Nov 24 2015
  *
  * @brief  Implementation of the common part of the material class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Material::Material(SolidMechanicsModel & model, const ID & id)
     : Memory(id, model.getMemoryID()), Parsable(_st_material, id),
       is_init(false), fem(model.getFEEngine()), finite_deformation(false),
       name(""), model(model),
       spatial_dimension(this->model.getSpatialDimension()),
       element_filter("element_filter", id, this->memory_id),
       stress("stress", *this), eigengradu("eigen_grad_u", *this),
       gradu("grad_u", *this), green_strain("green_strain", *this),
       piola_kirchhoff_2("piola_kirchhoff_2", *this),
       potential_energy("potential_energy", *this), is_non_local(false),
       use_previous_stress(false), use_previous_gradu(false),
       interpolation_inverse_coordinates("interpolation inverse coordinates",
                                         *this),
       interpolation_points_matrices("interpolation points matrices", *this) {
   AKANTU_DEBUG_IN();
 
   /// for each connectivity types allocate the element filer array of the
   /// material
   element_filter.initialize(model.getMesh(),
                             _spatial_dimension = spatial_dimension);
   // model.getMesh().initElementTypeMapArray(element_filter, 1,
   // spatial_dimension,
   //                                         false, _ek_regular);
 
   this->initialize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Material::Material(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
                    FEEngine & fe_engine, const ID & id)
     : Memory(id, model.getMemoryID()), Parsable(_st_material, id),
       is_init(false), fem(model.getFEEngine()), finite_deformation(false),
       name(""), model(model), spatial_dimension(dim),
       element_filter("element_filter", id, this->memory_id),
       stress("stress", *this, dim, fe_engine, this->element_filter),
       eigengradu("eigen_grad_u", *this, dim, fe_engine, this->element_filter),
       gradu("gradu", *this, dim, fe_engine, this->element_filter),
       green_strain("green_strain", *this, dim, fe_engine, this->element_filter),
       piola_kirchhoff_2("poila_kirchhoff_2", *this, dim, fe_engine,
                         this->element_filter),
       potential_energy("potential_energy", *this, dim, fe_engine,
                        this->element_filter),
       is_non_local(false), use_previous_stress(false),
       use_previous_gradu(false),
       interpolation_inverse_coordinates("interpolation inverse_coordinates",
                                         *this, dim, fe_engine,
                                         this->element_filter),
       interpolation_points_matrices("interpolation points matrices", *this, dim,
                                     fe_engine, this->element_filter) {
 
   AKANTU_DEBUG_IN();
   element_filter.initialize(mesh, _spatial_dimension = spatial_dimension);
   // mesh.initElementTypeMapArray(element_filter, 1, spatial_dimension, false,
   //                              _ek_regular);
 
   this->initialize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Material::~Material() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::initialize() {
   registerParam("rho", rho, Real(0.), _pat_parsable | _pat_modifiable,
                 "Density");
   registerParam("name", name, std::string(), _pat_parsable | _pat_readable);
   registerParam("finite_deformation", finite_deformation, false,
                 _pat_parsable | _pat_readable, "Is finite deformation");
   registerParam("inelastic_deformation", inelastic_deformation, false,
                 _pat_internal, "Is inelastic deformation");
 
   /// allocate gradu stress for local elements
   eigengradu.initialize(spatial_dimension * spatial_dimension);
   gradu.initialize(spatial_dimension * spatial_dimension);
   stress.initialize(spatial_dimension * spatial_dimension);
 
   potential_energy.initialize(1);
 
   this->model.registerEventHandler(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::initMaterial() {
   AKANTU_DEBUG_IN();
 
   if (finite_deformation) {
     this->piola_kirchhoff_2.initialize(spatial_dimension * spatial_dimension);
     if (use_previous_stress)
       this->piola_kirchhoff_2.initializeHistory();
     this->green_strain.initialize(spatial_dimension * spatial_dimension);
   }
 
   if (use_previous_stress)
     this->stress.initializeHistory();
   if (use_previous_gradu)
     this->gradu.initializeHistory();
 
   for (std::map<ID, InternalField<Real> *>::iterator it =
            internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->resize();
 
   for (std::map<ID, InternalField<UInt> *>::iterator it =
            internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->resize();
 
   for (std::map<ID, InternalField<bool> *>::iterator it =
            internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->resize();
 
   is_init = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::savePreviousState() {
   AKANTU_DEBUG_IN();
 
   for (std::map<ID, InternalField<Real> *>::iterator it =
            internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it) {
     if (it->second->hasHistory())
       it->second->saveCurrentValues();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the  residual  by  assembling  @f$\int_{e}  \sigma_e  \frac{\partial
  * \varphi}{\partial X} dX @f$
  *
  * @param[in] displacements nodes displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 // void Material::updateResidual(GhostType ghost_type) {
 //   AKANTU_DEBUG_IN();
 
 //   computeAllStresses(ghost_type);
 //   assembleResidual(ghost_type);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void Material::assembleInternalForces(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   if (!finite_deformation) {
 
     Array<Real> & internal_force =
         const_cast<Array<Real> &>(model.getInternalForce());
 
     Mesh & mesh = fem.getMesh();
     Mesh::type_iterator it =
         element_filter.firstType(spatial_dimension, ghost_type);
     Mesh::type_iterator last_type =
         element_filter.lastType(spatial_dimension, ghost_type);
     for (; it != last_type; ++it) {
       Array<UInt> & elem_filter = element_filter(*it, ghost_type);
-      UInt nb_element = elem_filter.getSize();
+      UInt nb_element = elem_filter.size();
       if (nb_element) {
         const Array<Real> & shapes_derivatives =
             fem.getShapesDerivatives(*it, ghost_type);
 
         UInt size_of_shapes_derivatives = shapes_derivatives.getNbComponent();
         UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(*it);
         UInt nb_quadrature_points = fem.getNbIntegrationPoints(*it, ghost_type);
 
         /// compute @f$\sigma \frac{\partial \varphi}{\partial X}@f$ by
         /// @f$\mathbf{B}^t \mathbf{\sigma}_q@f$
         Array<Real> * sigma_dphi_dx =
             new Array<Real>(nb_element * nb_quadrature_points,
                             size_of_shapes_derivatives, "sigma_x_dphi_/_dX");
 
         Array<Real> * shapesd_filtered =
             new Array<Real>(0, size_of_shapes_derivatives, "filtered shapesd");
 
         FEEngine::filterElementalData(mesh, shapes_derivatives,
                                       *shapesd_filtered, *it, ghost_type,
                                       elem_filter);
 
         Array<Real> & stress_vect = this->stress(*it, ghost_type);
 
         Array<Real>::matrix_iterator sigma =
             stress_vect.begin(spatial_dimension, spatial_dimension);
         Array<Real>::matrix_iterator B =
             shapesd_filtered->begin(spatial_dimension, nb_nodes_per_element);
         Array<Real>::matrix_iterator Bt_sigma_it =
             sigma_dphi_dx->begin(spatial_dimension, nb_nodes_per_element);
 
         for (UInt q = 0; q < nb_element * nb_quadrature_points;
              ++q, ++sigma, ++B, ++Bt_sigma_it)
           Bt_sigma_it->mul<false, false>(*sigma, *B);
 
         delete shapesd_filtered;
 
         /**
          * compute @f$\int \sigma  * \frac{\partial \varphi}{\partial X}dX@f$ by
          * @f$ \sum_q \mathbf{B}^t
          * \mathbf{\sigma}_q \overline w_q J_q@f$
          */
         Array<Real> * int_sigma_dphi_dx = new Array<Real>(
             nb_element, nb_nodes_per_element * spatial_dimension,
             "int_sigma_x_dphi_/_dX");
 
         fem.integrate(*sigma_dphi_dx, *int_sigma_dphi_dx,
                       size_of_shapes_derivatives, *it, ghost_type, elem_filter);
         delete sigma_dphi_dx;
 
         /// assemble
         model.getDOFManager().assembleElementalArrayLocalArray(
             *int_sigma_dphi_dx, internal_force, *it, ghost_type, -1,
             elem_filter);
         delete int_sigma_dphi_dx;
       }
     }
   } else {
     switch (spatial_dimension) {
     case 1:
       this->assembleInternalForces<1>(ghost_type);
       break;
     case 2:
       this->assembleInternalForces<2>(ghost_type);
       break;
     case 3:
       this->assembleInternalForces<3>(ghost_type);
       break;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the  stress from the gradu
  *
  * @param[in] current_position nodes postition + displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 void Material::computeAllStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (const auto & type :
        element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
 
-    if (elem_filter.getSize() == 0)
+    if (elem_filter.size() == 0)
       continue;
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
     /// compute @f$\nabla u@f$
     fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect,
                                     spatial_dimension, type, ghost_type,
                                     elem_filter);
 
     gradu_vect -= eigengradu(type, ghost_type);
 
     /// compute @f$\mathbf{\sigma}_q@f$ from @f$\nabla u@f$
     computeStress(type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computeAllCauchyStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(finite_deformation, "The Cauchy stress can only be "
                                           "computed if you are working in "
                                           "finite deformation.");
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     switch (spatial_dimension) {
     case 1:
       this->computeCauchyStress<1>(type, ghost_type);
       break;
     case 2:
       this->computeCauchyStress<2>(type, ghost_type);
       break;
     case 3:
       this->computeCauchyStress<3>(type, ghost_type);
       break;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::computeCauchyStress(ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<Real>::matrix_iterator gradu_it =
       this->gradu(el_type, ghost_type).begin(dim, dim);
 
   Array<Real>::matrix_iterator gradu_end =
       this->gradu(el_type, ghost_type).end(dim, dim);
 
   Array<Real>::matrix_iterator piola_it =
       this->piola_kirchhoff_2(el_type, ghost_type).begin(dim, dim);
 
   Array<Real>::matrix_iterator stress_it =
       this->stress(el_type, ghost_type).begin(dim, dim);
 
   Matrix<Real> F_tensor(dim, dim);
 
   for (; gradu_it != gradu_end; ++gradu_it, ++piola_it, ++stress_it) {
     Matrix<Real> & grad_u = *gradu_it;
     Matrix<Real> & piola = *piola_it;
     Matrix<Real> & sigma = *stress_it;
 
     gradUToF<dim>(grad_u, F_tensor);
     this->computeCauchyStressOnQuad<dim>(F_tensor, piola, sigma);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::setToSteadyState(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & displacement = model.getDisplacement();
 
   // resizeInternalArray(gradu);
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
     /// compute @f$\nabla u@f$
     fem.gradientOnIntegrationPoints(displacement, gradu_vect, spatial_dimension,
                                     type, ghost_type, elem_filter);
 
     setToSteadyState(type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compute  the stiffness  matrix by  assembling @f$\int_{\omega}  B^t  \times D
  * \times B d\omega @f$
  *
  * @param[in] current_position nodes postition + displacements
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 void Material::assembleStiffnessMatrix(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     if (finite_deformation) {
       switch (spatial_dimension) {
       case 1: {
         assembleStiffnessMatrixNL<1>(type, ghost_type);
         assembleStiffnessMatrixL2<1>(type, ghost_type);
         break;
       }
       case 2: {
         assembleStiffnessMatrixNL<2>(type, ghost_type);
         assembleStiffnessMatrixL2<2>(type, ghost_type);
         break;
       }
       case 3: {
         assembleStiffnessMatrixNL<3>(type, ghost_type);
         assembleStiffnessMatrixL2<3>(type, ghost_type);
         break;
       }
       }
     } else {
       switch (spatial_dimension) {
       case 1: {
         assembleStiffnessMatrix<1>(type, ghost_type);
         break;
       }
       case 2: {
         assembleStiffnessMatrix<2>(type, ghost_type);
         break;
       }
       case 3: {
         assembleStiffnessMatrix<3>(type, ghost_type);
         break;
       }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrix(const ElementType & type,
                                        GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
-  if (elem_filter.getSize()) {
+  if (elem_filter.size()) {
 
     const Array<Real> & shapes_derivatives =
         fem.getShapesDerivatives(type, ghost_type);
 
     Array<Real> & gradu_vect = gradu(type, ghost_type);
 
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     gradu_vect.resize(nb_quadrature_points * nb_element);
 
     fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect, dim,
                                     type, ghost_type, elem_filter);
 
     UInt tangent_size = getTangentStiffnessVoigtSize(dim);
 
     Array<Real> * tangent_stiffness_matrix = new Array<Real>(
         nb_element * nb_quadrature_points, tangent_size * tangent_size,
         "tangent_stiffness_matrix");
 
     tangent_stiffness_matrix->clear();
 
     computeTangentModuli(type, *tangent_stiffness_matrix, ghost_type);
 
     Array<Real> * shapesd_filtered = new Array<Real>(
         nb_element, dim * nb_nodes_per_element, "filtered shapesd");
 
     FEEngine::filterElementalData(fem.getMesh(), shapes_derivatives,
                                   *shapesd_filtered, type, ghost_type,
                                   elem_filter);
 
     /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     UInt bt_d_b_size = dim * nb_nodes_per_element;
 
     Array<Real> * bt_d_b =
         new Array<Real>(nb_element * nb_quadrature_points,
                         bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
     Matrix<Real> B(tangent_size, dim * nb_nodes_per_element);
     Matrix<Real> Bt_D(dim * nb_nodes_per_element, tangent_size);
 
     Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     Array<Real>::matrix_iterator Bt_D_B_it =
         bt_d_b->begin(dim * nb_nodes_per_element, dim * nb_nodes_per_element);
 
     Array<Real>::matrix_iterator D_it =
         tangent_stiffness_matrix->begin(tangent_size, tangent_size);
 
     Array<Real>::matrix_iterator D_end =
         tangent_stiffness_matrix->end(tangent_size, tangent_size);
 
     for (; D_it != D_end;
          ++D_it, ++Bt_D_B_it, ++shapes_derivatives_filtered_it) {
       Matrix<Real> & D = *D_it;
       Matrix<Real> & Bt_D_B = *Bt_D_B_it;
 
       VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
           *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
       Bt_D.mul<true, false>(B, D);
       Bt_D_B.mul<false, false>(Bt_D, B);
     }
 
     delete tangent_stiffness_matrix;
     delete shapesd_filtered;
 
     /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     Array<Real> * K_e =
         new Array<Real>(nb_element, bt_d_b_size * bt_d_b_size, "K_e");
 
     fem.integrate(*bt_d_b, *K_e, bt_d_b_size * bt_d_b_size, type, ghost_type,
                   elem_filter);
 
     delete bt_d_b;
 
     model.getDOFManager().assembleElementalMatricesToMatrix(
         "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
     delete K_e;
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrixNL(const ElementType & type,
                                          GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   // Array<Real> & gradu_vect = delta_gradu(type, ghost_type);
 
-  UInt nb_element = elem_filter.getSize();
+  UInt nb_element = elem_filter.size();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   // gradu_vect.resize(nb_quadrature_points * nb_element);
 
   // fem.gradientOnIntegrationPoints(model.getIncrement(), gradu_vect,
   //        dim, type, ghost_type, &elem_filter);
 
   Array<Real> * shapes_derivatives_filtered = new Array<Real>(
       nb_element * nb_quadrature_points, dim * nb_nodes_per_element,
       "shapes derivatives filtered");
 
   Array<Real>::const_matrix_iterator shapes_derivatives_it =
       shapes_derivatives.begin(spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
       shapes_derivatives_filtered->begin(spatial_dimension,
                                          nb_nodes_per_element);
   UInt * elem_filter_val = elem_filter.storage();
   for (UInt e = 0; e < nb_element; ++e, ++elem_filter_val)
     for (UInt q = 0; q < nb_quadrature_points;
          ++q, ++shapes_derivatives_filtered_it)
       *shapes_derivatives_filtered_it =
           shapes_derivatives_it[*elem_filter_val * nb_quadrature_points + q];
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_s_b_size = dim * nb_nodes_per_element;
 
   Array<Real> * bt_s_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_s_b_size * bt_s_b_size, "B^t*D*B");
 
   UInt piola_matrix_size = getCauchyStressMatrixSize(dim);
 
   Matrix<Real> B(piola_matrix_size, bt_s_b_size);
   Matrix<Real> Bt_S(bt_s_b_size, piola_matrix_size);
   Matrix<Real> S(piola_matrix_size, piola_matrix_size);
 
   shapes_derivatives_filtered_it = shapes_derivatives_filtered->begin(
       spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator Bt_S_B_it =
       bt_s_b->begin(bt_s_b_size, bt_s_b_size);
   Array<Real>::matrix_iterator Bt_S_B_end =
       bt_s_b->end(bt_s_b_size, bt_s_b_size);
 
   Array<Real>::matrix_iterator piola_it =
       piola_kirchhoff_2(type, ghost_type).begin(dim, dim);
 
   for (; Bt_S_B_it != Bt_S_B_end;
        ++Bt_S_B_it, ++shapes_derivatives_filtered_it, ++piola_it) {
     Matrix<Real> & Bt_S_B = *Bt_S_B_it;
     Matrix<Real> & Piola_kirchhoff_matrix = *piola_it;
 
     setCauchyStressMatrix<dim>(Piola_kirchhoff_matrix, S);
     VoigtHelper<dim>::transferBMatrixToBNL(*shapes_derivatives_filtered_it, B,
                                            nb_nodes_per_element);
     Bt_S.mul<true, false>(B, S);
     Bt_S_B.mul<false, false>(Bt_S, B);
   }
 
   delete shapes_derivatives_filtered;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_s_b_size * bt_s_b_size, "K_e");
 
   fem.integrate(*bt_s_b, *K_e, bt_s_b_size * bt_s_b_size, type, ghost_type,
                 elem_filter);
 
   delete bt_s_b;
 
   model.getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
 
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleStiffnessMatrixL2(const ElementType & type,
                                          GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   Array<Real> & gradu_vect = gradu(type, ghost_type);
 
-  UInt nb_element = elem_filter.getSize();
+  UInt nb_element = elem_filter.size();
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   gradu_vect.resize(nb_quadrature_points * nb_element);
 
   fem.gradientOnIntegrationPoints(model.getDisplacement(), gradu_vect, dim,
                                   type, ghost_type, elem_filter);
 
   UInt tangent_size = getTangentStiffnessVoigtSize(dim);
 
   Array<Real> * tangent_stiffness_matrix =
       new Array<Real>(nb_element * nb_quadrature_points,
                       tangent_size * tangent_size, "tangent_stiffness_matrix");
 
   tangent_stiffness_matrix->clear();
 
   computeTangentModuli(type, *tangent_stiffness_matrix, ghost_type);
 
   Array<Real> * shapes_derivatives_filtered = new Array<Real>(
       nb_element * nb_quadrature_points, dim * nb_nodes_per_element,
       "shapes derivatives filtered");
 
   Array<Real>::const_matrix_iterator shapes_derivatives_it =
       shapes_derivatives.begin(spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
       shapes_derivatives_filtered->begin(spatial_dimension,
                                          nb_nodes_per_element);
   UInt * elem_filter_val = elem_filter.storage();
   for (UInt e = 0; e < nb_element; ++e, ++elem_filter_val)
     for (UInt q = 0; q < nb_quadrature_points;
          ++q, ++shapes_derivatives_filtered_it)
       *shapes_derivatives_filtered_it =
           shapes_derivatives_it[*elem_filter_val * nb_quadrature_points + q];
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_d_b_size = dim * nb_nodes_per_element;
 
   Array<Real> * bt_d_b = new Array<Real>(nb_element * nb_quadrature_points,
                                          bt_d_b_size * bt_d_b_size, "B^t*D*B");
 
   Matrix<Real> B(tangent_size, dim * nb_nodes_per_element);
   Matrix<Real> B2(tangent_size, dim * nb_nodes_per_element);
   Matrix<Real> Bt_D(dim * nb_nodes_per_element, tangent_size);
 
   shapes_derivatives_filtered_it = shapes_derivatives_filtered->begin(
       spatial_dimension, nb_nodes_per_element);
 
   Array<Real>::matrix_iterator Bt_D_B_it =
       bt_d_b->begin(dim * nb_nodes_per_element, dim * nb_nodes_per_element);
 
   Array<Real>::matrix_iterator grad_u_it = gradu_vect.begin(dim, dim);
 
   Array<Real>::matrix_iterator D_it =
       tangent_stiffness_matrix->begin(tangent_size, tangent_size);
   Array<Real>::matrix_iterator D_end =
       tangent_stiffness_matrix->end(tangent_size, tangent_size);
 
   for (; D_it != D_end;
        ++D_it, ++Bt_D_B_it, ++shapes_derivatives_filtered_it, ++grad_u_it) {
     Matrix<Real> & grad_u = *grad_u_it;
     Matrix<Real> & D = *D_it;
     Matrix<Real> & Bt_D_B = *Bt_D_B_it;
 
     // transferBMatrixToBL1<dim > (*shapes_derivatives_filtered_it, B,
     // nb_nodes_per_element);
     VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
         *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
     VoigtHelper<dim>::transferBMatrixToBL2(*shapes_derivatives_filtered_it,
                                            grad_u, B2, nb_nodes_per_element);
     B += B2;
     Bt_D.mul<true, false>(B, D);
     Bt_D_B.mul<false, false>(Bt_D, B);
   }
 
   delete tangent_stiffness_matrix;
   delete shapes_derivatives_filtered;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * K_e =
       new Array<Real>(nb_element, bt_d_b_size * bt_d_b_size, "K_e");
 
   fem.integrate(*bt_d_b, *K_e, bt_d_b_size * bt_d_b_size, type, ghost_type,
                 elem_filter);
 
   delete bt_d_b;
 
   model.getDOFManager().assembleElementalMatricesToMatrix(
       "K", "displacement", *K_e, type, ghost_type, _symmetric, elem_filter);
   delete K_e;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::assembleInternalForces(GhostType ghost_type) {
 
   AKANTU_DEBUG_IN();
 
   Array<Real> & internal_force = model.getInternalForce();
 
   Mesh & mesh = fem.getMesh();
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     const Array<Real> & shapes_derivatives =
         fem.getShapesDerivatives(type, ghost_type);
 
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
-    if (elem_filter.getSize() == 0)
+    if (elem_filter.size() == 0)
       continue;
     UInt size_of_shapes_derivatives = shapes_derivatives.getNbComponent();
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     Array<Real> * shapesd_filtered = new Array<Real>(
         nb_element, size_of_shapes_derivatives, "filtered shapesd");
 
     FEEngine::filterElementalData(mesh, shapes_derivatives, *shapesd_filtered,
                                   type, ghost_type, elem_filter);
 
     Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     // Set stress vectors
 
     UInt stress_size = getTangentStiffnessVoigtSize(dim);
 
     // Set matrices B and BNL*
     UInt bt_s_size = dim * nb_nodes_per_element;
 
     Array<Real> * bt_s =
         new Array<Real>(nb_element * nb_quadrature_points, bt_s_size, "B^t*S");
 
     Array<Real>::matrix_iterator grad_u_it =
         this->gradu(type, ghost_type).begin(dim, dim);
 
     Array<Real>::matrix_iterator grad_u_end =
         this->gradu(type, ghost_type).end(dim, dim);
 
     Array<Real>::matrix_iterator stress_it =
         this->piola_kirchhoff_2(type, ghost_type).begin(dim, dim);
 
     shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     Array<Real>::matrix_iterator bt_s_it = bt_s->begin(bt_s_size, 1);
 
     Matrix<Real> S_vect(stress_size, 1);
     Matrix<Real> B_tensor(stress_size, bt_s_size);
     Matrix<Real> B2_tensor(stress_size, bt_s_size);
 
     for (; grad_u_it != grad_u_end; ++grad_u_it, ++stress_it,
                                     ++shapes_derivatives_filtered_it,
                                     ++bt_s_it) {
       Matrix<Real> & grad_u = *grad_u_it;
       Matrix<Real> & r_it = *bt_s_it;
       Matrix<Real> & S_it = *stress_it;
 
       setCauchyStressArray<dim>(S_it, S_vect);
       VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
           *shapes_derivatives_filtered_it, B_tensor, nb_nodes_per_element);
       VoigtHelper<dim>::transferBMatrixToBL2(*shapes_derivatives_filtered_it,
                                              grad_u, B2_tensor,
                                              nb_nodes_per_element);
 
       B_tensor += B2_tensor;
 
       r_it.mul<true, false>(B_tensor, S_vect);
     }
 
     delete shapesd_filtered;
 
     /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     Array<Real> * r_e = new Array<Real>(nb_element, bt_s_size, "r_e");
 
     fem.integrate(*bt_s, *r_e, bt_s_size, type, ghost_type, elem_filter);
 
     delete bt_s;
 
     model.getDOFManager().assembleElementalArrayLocalArray(
         *r_e, internal_force, type, ghost_type, -1., elem_filter);
     delete r_e;
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computeAllStressesFromTangentModuli(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     switch (spatial_dimension) {
     case 1: {
       computeAllStressesFromTangentModuli<1>(type, ghost_type);
       break;
     }
     case 2: {
       computeAllStressesFromTangentModuli<2>(type, ghost_type);
       break;
     }
     case 3: {
       computeAllStressesFromTangentModuli<3>(type, ghost_type);
       break;
     }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void Material::computeAllStressesFromTangentModuli(const ElementType & type,
                                                    GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const Array<Real> & shapes_derivatives =
       fem.getShapesDerivatives(type, ghost_type);
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
   Array<Real> & gradu_vect = gradu(type, ghost_type);
 
-  UInt nb_element = elem_filter.getSize();
+  UInt nb_element = elem_filter.size();
   if (nb_element) {
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
     gradu_vect.resize(nb_quadrature_points * nb_element);
 
     Array<Real> & disp = model.getDisplacement();
 
     fem.gradientOnIntegrationPoints(disp, gradu_vect, dim, type, ghost_type,
                                     elem_filter);
 
     UInt tangent_moduli_size = getTangentStiffnessVoigtSize(dim);
 
     Array<Real> * tangent_moduli_tensors = new Array<Real>(
         nb_element * nb_quadrature_points,
         tangent_moduli_size * tangent_moduli_size, "tangent_moduli_tensors");
 
     tangent_moduli_tensors->clear();
     computeTangentModuli(type, *tangent_moduli_tensors, ghost_type);
 
     Array<Real> * shapesd_filtered = new Array<Real>(
         nb_element, dim * nb_nodes_per_element, "filtered shapesd");
 
     FEEngine::filterElementalData(fem.getMesh(), shapes_derivatives,
                                   *shapesd_filtered, type, ghost_type,
                                   elem_filter);
 
     Array<Real> filtered_u(nb_element,
                            nb_nodes_per_element * spatial_dimension);
 
     FEEngine::extractNodalToElementField(fem.getMesh(), disp, filtered_u, type,
                                          ghost_type, elem_filter);
 
     /// compute @f$\mathbf{D} \mathbf{B} \mathbf{u}@f$
     Array<Real>::matrix_iterator shapes_derivatives_filtered_it =
         shapesd_filtered->begin(dim, nb_nodes_per_element);
 
     Array<Real>::matrix_iterator D_it =
         tangent_moduli_tensors->begin(tangent_moduli_size, tangent_moduli_size);
     Array<Real>::matrix_iterator sigma_it =
         stress(type, ghost_type).begin(spatial_dimension, spatial_dimension);
     Array<Real>::vector_iterator u_it =
         filtered_u.begin(spatial_dimension * nb_nodes_per_element);
 
     Matrix<Real> B(tangent_moduli_size,
                    spatial_dimension * nb_nodes_per_element);
     Vector<Real> Bu(tangent_moduli_size);
     Vector<Real> DBu(tangent_moduli_size);
 
     for (UInt e = 0; e < nb_element; ++e, ++u_it) {
       for (UInt q = 0; q < nb_quadrature_points;
            ++q, ++D_it, ++shapes_derivatives_filtered_it, ++sigma_it) {
         Vector<Real> & u = *u_it;
         Matrix<Real> & sigma = *sigma_it;
         Matrix<Real> & D = *D_it;
 
         VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(
             *shapes_derivatives_filtered_it, B, nb_nodes_per_element);
 
         Bu.mul<false>(B, u);
         DBu.mul<false>(D, Bu);
 
         // Voigt notation to full symmetric tensor
         for (UInt i = 0; i < dim; ++i)
           sigma(i, i) = DBu(i);
         if (dim == 2) {
           sigma(0, 1) = sigma(1, 0) = DBu(2);
         } else if (dim == 3) {
           sigma(1, 2) = sigma(2, 1) = DBu(3);
           sigma(0, 2) = sigma(2, 0) = DBu(4);
           sigma(0, 1) = sigma(1, 0) = DBu(5);
         }
       }
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computePotentialEnergyByElements() {
   AKANTU_DEBUG_IN();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, _not_ghost)) {
     computePotentialEnergy(type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::computePotentialEnergy(ElementType, GhostType) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getPotentialEnergy() {
   AKANTU_DEBUG_IN();
   Real epot = 0.;
 
   computePotentialEnergyByElements();
 
   /// integrate the potential energy for each type of elements
   for (auto type : element_filter.elementTypes(spatial_dimension, _not_ghost)) {
     epot += fem.integrate(potential_energy(type, _not_ghost), type, _not_ghost,
                           element_filter(type, _not_ghost));
   }
 
   AKANTU_DEBUG_OUT();
   return epot;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getPotentialEnergy(ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
   Real epot = 0.;
 
   Vector<Real> epot_on_quad_points(fem.getNbIntegrationPoints(type));
 
   computePotentialEnergyByElement(type, index, epot_on_quad_points);
 
   epot = fem.integrate(epot_on_quad_points, type, element_filter(type)(index));
 
   AKANTU_DEBUG_OUT();
   return epot;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getEnergy(std::string type) {
   AKANTU_DEBUG_IN();
   if (type == "potential")
     return getPotentialEnergy();
   AKANTU_DEBUG_OUT();
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 Real Material::getEnergy(std::string energy_id, ElementType type, UInt index) {
   AKANTU_DEBUG_IN();
   if (energy_id == "potential")
     return getPotentialEnergy(type, index);
   AKANTU_DEBUG_OUT();
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::initElementalFieldInterpolation(
     const ElementTypeMapArray<Real> & interpolation_points_coordinates) {
   AKANTU_DEBUG_IN();
 
   this->fem.initElementalFieldInterpolationFromIntegrationPoints(
       interpolation_points_coordinates, this->interpolation_points_matrices,
       this->interpolation_inverse_coordinates, &(this->element_filter));
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::interpolateStress(ElementTypeMapArray<Real> & result,
                                  const GhostType ghost_type) {
 
   this->fem.interpolateElementalFieldFromIntegrationPoints(
       this->stress, this->interpolation_points_matrices,
       this->interpolation_inverse_coordinates, result, ghost_type,
       &(this->element_filter));
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::interpolateStressOnFacets(
     ElementTypeMapArray<Real> & result,
     ElementTypeMapArray<Real> & by_elem_result, const GhostType ghost_type) {
 
   interpolateStress(by_elem_result, ghost_type);
 
   UInt stress_size = this->stress.getNbComponent();
 
   const Mesh & mesh = this->model.getMesh();
   const Mesh & mesh_facets = mesh.getMeshFacets();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type)) {
     Array<UInt> & elem_fil = element_filter(type, ghost_type);
     Array<Real> & by_elem_res = by_elem_result(type, ghost_type);
-    UInt nb_element = elem_fil.getSize();
+    UInt nb_element = elem_fil.size();
     UInt nb_element_full = this->model.getMesh().getNbElement(type, ghost_type);
     UInt nb_interpolation_points_per_elem =
-        by_elem_res.getSize() / nb_element_full;
+        by_elem_res.size() / nb_element_full;
 
     const Array<Element> & facet_to_element =
         mesh_facets.getSubelementToElement(type, ghost_type);
     ElementType type_facet = Mesh::getFacetType(type);
     UInt nb_facet_per_elem = facet_to_element.getNbComponent();
     UInt nb_quad_per_facet =
         nb_interpolation_points_per_elem / nb_facet_per_elem;
     Element element_for_comparison(type, 0, ghost_type);
     const Array<std::vector<Element>> * element_to_facet = NULL;
     GhostType current_ghost_type = _casper;
     Array<Real> * result_vec = NULL;
 
     Array<Real>::const_matrix_iterator result_it =
         by_elem_res.begin_reinterpret(
             stress_size, nb_interpolation_points_per_elem, nb_element_full);
 
     for (UInt el = 0; el < nb_element; ++el) {
       UInt global_el = elem_fil(el);
       element_for_comparison.element = global_el;
       for (UInt f = 0; f < nb_facet_per_elem; ++f) {
 
         Element facet_elem = facet_to_element(global_el, f);
         UInt global_facet = facet_elem.element;
         if (facet_elem.ghost_type != current_ghost_type) {
           current_ghost_type = facet_elem.ghost_type;
           element_to_facet = &mesh_facets.getElementToSubelement(
               type_facet, current_ghost_type);
           result_vec = &result(type_facet, current_ghost_type);
         }
 
         bool is_second_element =
             (*element_to_facet)(global_facet)[0] != element_for_comparison;
 
         for (UInt q = 0; q < nb_quad_per_facet; ++q) {
           Vector<Real> result_local(result_vec->storage() +
                                         (global_facet * nb_quad_per_facet + q) *
                                             result_vec->getNbComponent() +
                                         is_second_element * stress_size,
                                     stress_size);
 
           const Matrix<Real> & result_tmp(result_it[global_el]);
           result_local = result_tmp(f * nb_quad_per_facet + q);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const Array<T> &
 Material::getArray(__attribute__((unused)) const ID & vect_id,
                    __attribute__((unused)) const ElementType & type,
                    __attribute__((unused)) const GhostType & ghost_type) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 Array<T> & Material::getArray(__attribute__((unused)) const ID & vect_id,
                               __attribute__((unused)) const ElementType & type,
                               __attribute__((unused))
                               const GhostType & ghost_type) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const Array<Real> & Material::getArray(const ID & vect_id,
                                        const ElementType & type,
                                        const GhostType & ghost_type) const {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<Real>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<Real> & Material::getArray(const ID & vect_id, const ElementType & type,
                                  const GhostType & ghost_type) {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<Real>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const Array<UInt> & Material::getArray(const ID & vect_id,
                                        const ElementType & type,
                                        const GhostType & ghost_type) const {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<UInt>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 Array<UInt> & Material::getArray(const ID & vect_id, const ElementType & type,
                                  const GhostType & ghost_type) {
   std::stringstream sstr;
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
   sstr << getID() << ":" << vect_id << ":" << type << ghost_id;
 
   ID fvect_id = sstr.str();
   try {
     return Memory::getArray<UInt>(fvect_id);
   } catch (debug::Exception & e) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain a vector "
                                             << vect_id << "(" << fvect_id
                                             << ") [" << e << "]");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const InternalField<T> & Material::getInternal(__attribute__((unused))
                                                const ID & int_id) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 InternalField<T> & Material::getInternal(__attribute__((unused))
                                          const ID & int_id) {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const InternalField<Real> & Material::getInternal(const ID & int_id) const {
   std::map<ID, InternalField<Real> *>::const_iterator it =
       internal_vectors_real.find(getID() + ":" + int_id);
   if (it == internal_vectors_real.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> InternalField<Real> & Material::getInternal(const ID & int_id) {
   std::map<ID, InternalField<Real> *>::iterator it =
       internal_vectors_real.find(getID() + ":" + int_id);
   if (it == internal_vectors_real.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 const InternalField<UInt> & Material::getInternal(const ID & int_id) const {
   std::map<ID, InternalField<UInt> *>::const_iterator it =
       internal_vectors_uint.find(getID() + ":" + int_id);
   if (it == internal_vectors_uint.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> InternalField<UInt> & Material::getInternal(const ID & int_id) {
   std::map<ID, InternalField<UInt> *>::iterator it =
       internal_vectors_uint.find(getID() + ":" + int_id);
   if (it == internal_vectors_uint.end()) {
     AKANTU_SILENT_EXCEPTION("The material " << name << "(" << getID()
                                             << ") does not contain an internal "
                                             << int_id << " ("
                                             << (getID() + ":" + int_id) << ")");
   }
   return *it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::addElements(const Array<Element> & elements_to_add) {
   AKANTU_DEBUG_IN();
   UInt mat_id = model.getInternalIndexFromID(getID());
   Array<Element>::const_iterator<Element> el_begin = elements_to_add.begin();
   Array<Element>::const_iterator<Element> el_end = elements_to_add.end();
   for (; el_begin != el_end; ++el_begin) {
     const Element & element = *el_begin;
     Array<UInt> & mat_indexes =
         model.getMaterialByElement(element.type, element.ghost_type);
     Array<UInt> & mat_loc_num =
         model.getMaterialLocalNumbering(element.type, element.ghost_type);
 
     UInt index =
         this->addElement(element.type, element.element, element.ghost_type);
     mat_indexes(element.element) = mat_id;
     mat_loc_num(element.element) = index;
   }
 
   this->resizeInternals();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::removeElements(const Array<Element> & elements_to_remove) {
   AKANTU_DEBUG_IN();
 
   Array<Element>::const_iterator<Element> el_begin = elements_to_remove.begin();
   Array<Element>::const_iterator<Element> el_end = elements_to_remove.end();
 
   if (el_begin == el_end)
     return;
 
   ElementTypeMapArray<UInt> material_local_new_numbering(
       "remove mat filter elem", getID(), getMemoryID());
 
   Element element;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     element.ghost_type = ghost_type;
 
     ElementTypeMapArray<UInt>::type_iterator it =
         element_filter.firstType(_all_dimensions, ghost_type, _ek_not_defined);
     ElementTypeMapArray<UInt>::type_iterator end =
         element_filter.lastType(_all_dimensions, ghost_type, _ek_not_defined);
 
     for (; it != end; ++it) {
       ElementType type = *it;
       element.type = type;
 
       Array<UInt> & elem_filter = this->element_filter(type, ghost_type);
       Array<UInt> & mat_loc_num =
           this->model.getMaterialLocalNumbering(type, ghost_type);
 
       if (!material_local_new_numbering.exists(type, ghost_type))
-        material_local_new_numbering.alloc(elem_filter.getSize(), 1, type,
+        material_local_new_numbering.alloc(elem_filter.size(), 1, type,
                                            ghost_type);
       Array<UInt> & mat_renumbering =
           material_local_new_numbering(type, ghost_type);
 
-      UInt nb_element = elem_filter.getSize();
+      UInt nb_element = elem_filter.size();
       element.kind = (*el_begin).kind;
       Array<UInt> elem_filter_tmp;
 
       UInt new_id = 0;
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = elem_filter(el);
 
         if (std::find(el_begin, el_end, element) == el_end) {
           elem_filter_tmp.push_back(element.element);
 
           mat_renumbering(el) = new_id;
           mat_loc_num(element.element) = new_id;
           ++new_id;
         } else {
           mat_renumbering(el) = UInt(-1);
         }
       }
 
-      elem_filter.resize(elem_filter_tmp.getSize());
+      elem_filter.resize(elem_filter_tmp.size());
       elem_filter.copy(elem_filter_tmp);
     }
   }
 
   for (std::map<ID, InternalField<Real> *>::iterator it =
            internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (std::map<ID, InternalField<UInt> *>::iterator it =
            internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (std::map<ID, InternalField<bool> *>::iterator it =
            internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::resizeInternals() {
   AKANTU_DEBUG_IN();
   for (std::map<ID, InternalField<Real> *>::iterator it =
            internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->resize();
 
   for (std::map<ID, InternalField<UInt> *>::iterator it =
            internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->resize();
 
   for (std::map<ID, InternalField<bool> *>::iterator it =
            internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->resize();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onElementsAdded(const Array<Element> &,
                                const NewElementsEvent &) {
   this->resizeInternals();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     __attribute__((unused)) const RemovedElementsEvent & event) {
   UInt my_num = model.getInternalIndexFromID(getID());
 
   ElementTypeMapArray<UInt> material_local_new_numbering(
       "remove mat filter elem", getID(), getMemoryID());
 
   Array<Element>::const_iterator<Element> el_begin = element_list.begin();
   Array<Element>::const_iterator<Element> el_end = element_list.end();
 
   for (ghost_type_t::iterator g = ghost_type_t::begin();
        g != ghost_type_t::end(); ++g) {
     GhostType gt = *g;
 
     ElementTypeMapArray<UInt>::type_iterator it =
         new_numbering.firstType(_all_dimensions, gt, _ek_not_defined);
     ElementTypeMapArray<UInt>::type_iterator end =
         new_numbering.lastType(_all_dimensions, gt, _ek_not_defined);
     for (; it != end; ++it) {
       ElementType type = *it;
       if (element_filter.exists(type, gt) &&
-          element_filter(type, gt).getSize()) {
+          element_filter(type, gt).size()) {
         Array<UInt> & elem_filter = element_filter(type, gt);
 
         Array<UInt> & mat_indexes = this->model.getMaterialByElement(*it, gt);
         Array<UInt> & mat_loc_num =
             this->model.getMaterialLocalNumbering(*it, gt);
         UInt nb_element = this->model.getMesh().getNbElement(type, gt);
 
         // all materials will resize of the same size...
         mat_indexes.resize(nb_element);
         mat_loc_num.resize(nb_element);
 
         if (!material_local_new_numbering.exists(type, gt))
-          material_local_new_numbering.alloc(elem_filter.getSize(), 1, type,
+          material_local_new_numbering.alloc(elem_filter.size(), 1, type,
                                              gt);
 
         Array<UInt> & mat_renumbering = material_local_new_numbering(type, gt);
         const Array<UInt> & renumbering = new_numbering(type, gt);
         Array<UInt> elem_filter_tmp;
         UInt ni = 0;
         Element el;
         el.type = type;
         el.ghost_type = gt;
         el.kind = Mesh::getKind(type);
-        for (UInt i = 0; i < elem_filter.getSize(); ++i) {
+        for (UInt i = 0; i < elem_filter.size(); ++i) {
           el.element = elem_filter(i);
           if (std::find(el_begin, el_end, el) == el_end) {
             UInt new_el = renumbering(el.element);
             AKANTU_DEBUG_ASSERT(
                 new_el != UInt(-1),
                 "A not removed element as been badly renumbered");
             elem_filter_tmp.push_back(new_el);
             mat_renumbering(i) = ni;
 
             mat_indexes(new_el) = my_num;
             mat_loc_num(new_el) = ni;
             ++ni;
           } else {
             mat_renumbering(i) = UInt(-1);
           }
         }
 
-        elem_filter.resize(elem_filter_tmp.getSize());
+        elem_filter.resize(elem_filter_tmp.size());
         elem_filter.copy(elem_filter_tmp);
       }
     }
   }
 
   for (std::map<ID, InternalField<Real> *>::iterator it =
            internal_vectors_real.begin();
        it != internal_vectors_real.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (std::map<ID, InternalField<UInt> *>::iterator it =
            internal_vectors_uint.begin();
        it != internal_vectors_uint.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 
   for (std::map<ID, InternalField<bool> *>::iterator it =
            internal_vectors_bool.begin();
        it != internal_vectors_bool.end(); ++it)
     it->second->removeIntegrationPoints(material_local_new_numbering);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onBeginningSolveStep(__attribute__((unused))
                                     const AnalysisMethod & method) {
   this->savePreviousState();
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onEndSolveStep(__attribute__((unused))
                               const AnalysisMethod & method) {
   ElementTypeMapArray<UInt>::type_iterator it = this->element_filter.firstType(
       _all_dimensions, _not_ghost, _ek_not_defined);
   ElementTypeMapArray<UInt>::type_iterator end =
       element_filter.lastType(_all_dimensions, _not_ghost, _ek_not_defined);
 
   for (; it != end; ++it) {
     this->updateEnergies(*it, _not_ghost);
   }
 }
 /* -------------------------------------------------------------------------- */
 void Material::onDamageIteration() { this->savePreviousState(); }
 
 /* -------------------------------------------------------------------------- */
 void Material::onDamageUpdate() {
   ElementTypeMapArray<UInt>::type_iterator it = this->element_filter.firstType(
       _all_dimensions, _not_ghost, _ek_not_defined);
   ElementTypeMapArray<UInt>::type_iterator end =
       element_filter.lastType(_all_dimensions, _not_ghost, _ek_not_defined);
 
   for (; it != end; ++it) {
     this->updateEnergiesAfterDamage(*it, _not_ghost);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::onDump() {
   if (this->isFiniteDeformation())
     this->computeAllCauchyStresses(_not_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   std::string type = getID().substr(getID().find_last_of(":") + 1);
 
   stream << space << "Material " << type << " [" << std::endl;
   Parsable::printself(stream, indent);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /// extrapolate internal values
 void Material::extrapolateInternal(const ID & id, const Element & element,
                                    __attribute__((unused))
                                    const Matrix<Real> & point,
                                    Matrix<Real> & extrapolated) {
   if (this->isInternal<Real>(id, element.kind)) {
     UInt nb_element =
-        this->element_filter(element.type, element.ghost_type).getSize();
+        this->element_filter(element.type, element.ghost_type).size();
     const ID name = this->getID() + ":" + id;
     UInt nb_quads =
         this->internal_vectors_real[name]->getFEEngine().getNbIntegrationPoints(
             element.type, element.ghost_type);
     const Array<Real> & internal =
         this->getArray<Real>(id, element.type, element.ghost_type);
     UInt nb_component = internal.getNbComponent();
     Array<Real>::const_matrix_iterator internal_it =
         internal.begin_reinterpret(nb_component, nb_quads, nb_element);
     Element local_element = this->convertToLocalElement(element);
 
     /// instead of really extrapolating, here the value of the first GP
     /// is copied into the result vector. This works only for linear
     /// elements
     /// @todo extrapolate!!!!
     AKANTU_DEBUG_WARNING("This is a fix, values are not truly extrapolated");
 
     const Matrix<Real> & values = internal_it[local_element.element];
     UInt index = 0;
     Vector<Real> tmp(nb_component);
     for (UInt j = 0; j < values.cols(); ++j) {
       tmp = values(j);
       if (tmp.norm() > 0) {
         index = j;
         break;
       }
     }
 
     for (UInt i = 0; i < extrapolated.size(); ++i) {
       extrapolated(i) = values(index);
     }
   } else {
     Matrix<Real> default_values(extrapolated.rows(), extrapolated.cols(), 0.);
     extrapolated = default_values;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Material::applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const GhostType ghost_type) {
 
   ElementTypeMapArray<UInt>::type_iterator it = this->element_filter.firstType(
       _all_dimensions, _not_ghost, _ek_not_defined);
   ElementTypeMapArray<UInt>::type_iterator end =
       element_filter.lastType(_all_dimensions, _not_ghost, _ek_not_defined);
 
   for (; it != end; ++it) {
     ElementType type = *it;
-    if (!element_filter(type, ghost_type).getSize())
+    if (!element_filter(type, ghost_type).size())
       continue;
     Array<Real>::matrix_iterator eigen_it =
         this->eigengradu(type, ghost_type)
             .begin(spatial_dimension, spatial_dimension);
     Array<Real>::matrix_iterator eigen_end =
         this->eigengradu(type, ghost_type)
             .end(spatial_dimension, spatial_dimension);
     for (; eigen_it != eigen_end; ++eigen_it) {
       Matrix<Real> & current_eigengradu = *eigen_it;
       current_eigengradu = prescribed_eigen_grad_u;
     }
   }
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/material.hh b/src/model/solid_mechanics/material.hh
index 0969d76de..f4803eaf3 100644
--- a/src/model/solid_mechanics/material.hh
+++ b/src/model/solid_mechanics/material.hh
@@ -1,680 +1,680 @@
 
 /**
  * @file   material.hh
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Mother class for all materials
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_factory.hh"
 #include "aka_voigthelper.hh"
 #include "data_accessor.hh"
 #include "integration_point.hh"
 #include "parsable.hh"
 #include "parser.hh"
 /* -------------------------------------------------------------------------- */
 #include "internal_field.hh"
 #include "random_internal_field.hh"
 /* -------------------------------------------------------------------------- */
 #include "mesh_events.hh"
 #include "solid_mechanics_model_event_handler.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_HH__
 #define __AKANTU_MATERIAL_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class Model;
 class SolidMechanicsModel;
 } // namespace akantu
 
 namespace akantu {
 
 /**
  * Interface of all materials
  * Prerequisites for a new material
  * - inherit from this class
  * - implement the following methods:
  * \code
  *  virtual Real getStableTimeStep(Real h, const Element & element =
  * ElementNull);
  *
  *  virtual void computeStress(ElementType el_type,
  *                             GhostType ghost_type = _not_ghost);
  *
  *  virtual void computeTangentStiffness(const ElementType & el_type,
  *                                       Array<Real> & tangent_matrix,
  *                                       GhostType ghost_type = _not_ghost);
  * \endcode
  *
  */
 
 class Material : public Memory,
                  public DataAccessor<Element>,
                  public Parsable,
                  public MeshEventHandler,
                  protected SolidMechanicsModelEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 #if __cplusplus > 199711L
   Material(const Material & mat) = delete;
   Material & operator=(const Material & mat) = delete;
 #endif
 
   /// Initialize material with defaults
   Material(SolidMechanicsModel & model, const ID & id = "");
 
   /// Initialize material with custom mesh & fe_engine
   Material(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
            FEEngine & fe_engine, const ID & id = "");
 
   /// Destructor
   virtual ~Material();
 
 protected:
   void initialize();
 
   /* ------------------------------------------------------------------------ */
   /* Function that materials can/should reimplement                           */
   /* ------------------------------------------------------------------------ */
 protected:
   /// constitutive law
   virtual void computeStress(__attribute__((unused)) ElementType el_type,
                              __attribute__((unused))
                              GhostType ghost_type = _not_ghost) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// compute the tangent stiffness matrix
   virtual void computeTangentModuli(__attribute__((unused))
                                     const ElementType & el_type,
                                     __attribute__((unused))
                                     Array<Real> & tangent_matrix,
                                     __attribute__((unused))
                                     GhostType ghost_type = _not_ghost) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// compute the potential energy
   virtual void computePotentialEnergy(ElementType el_type,
                                       GhostType ghost_type = _not_ghost);
 
   /// compute the potential energy for an element
   virtual void
   computePotentialEnergyByElement(__attribute__((unused)) ElementType type,
                                   __attribute__((unused)) UInt index,
                                   __attribute__((unused))
                                   Vector<Real> & epot_on_quad_points) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   virtual void updateEnergies(__attribute__((unused)) ElementType el_type,
                               __attribute__((unused))
                               GhostType ghost_type = _not_ghost) {}
 
   virtual void updateEnergiesAfterDamage(__attribute__((unused))
                                          ElementType el_type,
                                          __attribute__((unused))
                                          GhostType ghost_type = _not_ghost) {}
 
   /// set the material to steady state (to be implemented for materials that
   /// need it)
   virtual void setToSteadyState(__attribute__((unused)) ElementType el_type,
                                 __attribute__((unused))
                                 GhostType ghost_type = _not_ghost) {}
 
   /// function called to update the internal parameters when the modifiable
   /// parameters are modified
   virtual void updateInternalParameters() {}
 
 public:
   /// extrapolate internal values
   virtual void extrapolateInternal(const ID & id, const Element & element,
                                    const Matrix<Real> & points,
                                    Matrix<Real> & extrapolated);
 
   /// compute the p-wave speed in the material
   virtual Real getPushWaveSpeed(__attribute__((unused))
                                 const Element & element) const {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// compute the s-wave speed in the material
   virtual Real getShearWaveSpeed(__attribute__((unused))
                                  const Element & element) const {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// get a material celerity to compute the stable time step (default: is the
   /// push wave speed)
   virtual Real getCelerity(const Element & element) const {
     return getPushWaveSpeed(element);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T>
   void registerInternal(__attribute__((unused)) InternalField<T> & vect) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   template <typename T>
   void unregisterInternal(__attribute__((unused)) InternalField<T> & vect) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// initialize the material computed parameter
   virtual void initMaterial();
 
   /// compute the residual for this material
   //  virtual void updateResidual(GhostType ghost_type = _not_ghost);
 
   /// assemble the residual for this material
   virtual void assembleInternalForces(GhostType ghost_type);
 
   /// save the stress in the previous_stress if needed
   virtual void savePreviousState();
 
   /// compute the stresses for this material
   virtual void computeAllStresses(GhostType ghost_type = _not_ghost);
   virtual void
   computeAllStressesFromTangentModuli(GhostType ghost_type = _not_ghost);
   virtual void computeAllCauchyStresses(GhostType ghost_type = _not_ghost);
 
   /// set material to steady state
   void setToSteadyState(GhostType ghost_type = _not_ghost);
 
   /// compute the stiffness matrix
   virtual void assembleStiffnessMatrix(GhostType ghost_type);
 
   /// add an element to the local mesh filter
   inline UInt addElement(const ElementType & type, UInt element,
                          const GhostType & ghost_type);
 
   /// add many elements at once
   void addElements(const Array<Element> & elements_to_add);
 
   /// remove many element at once
   void removeElements(const Array<Element> & elements_to_remove);
 
   /// function to print the contain of the class
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /**
    * interpolate stress on given positions for each element by means
    * of a geometrical interpolation on quadrature points
    */
   void interpolateStress(ElementTypeMapArray<Real> & result,
                          const GhostType ghost_type = _not_ghost);
 
   /**
    * interpolate stress on given positions for each element by means
    * of a geometrical interpolation on quadrature points and store the
    * results per facet
    */
   void interpolateStressOnFacets(ElementTypeMapArray<Real> & result,
                                  ElementTypeMapArray<Real> & by_elem_result,
                                  const GhostType ghost_type = _not_ghost);
 
   /**
    * function to initialize the elemental field interpolation
    * function by inverting the quadrature points' coordinates
    */
   void initElementalFieldInterpolation(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates);
 
   /* ------------------------------------------------------------------------ */
   /* Common part                                                              */
   /* ------------------------------------------------------------------------ */
 protected:
   /* ------------------------------------------------------------------------ */
   inline UInt getTangentStiffnessVoigtSize(UInt spatial_dimension) const;
 
   /// compute the potential energy by element
   void computePotentialEnergyByElements();
 
   /// resize the intenals arrays
   virtual void resizeInternals();
 
   /* ------------------------------------------------------------------------ */
   /* Finite deformation functions                                             */
   /* This functions area implementing what is described in the paper of Bathe */
   /* et al, in IJNME, Finite Element Formulations For Large Deformation       */
   /* Dynamic Analysis, Vol 9, 353-386, 1975                                   */
   /* ------------------------------------------------------------------------ */
 protected:
   /// assemble the residual
   template <UInt dim> void assembleInternalForces(GhostType ghost_type);
 
   /// Computation of Cauchy stress tensor in the case of finite deformation from
   /// the 2nd Piola-Kirchhoff for a given element type
   template <UInt dim>
   void computeCauchyStress(ElementType el_type,
                            GhostType ghost_type = _not_ghost);
 
   /// Computation the Cauchy stress the 2nd Piola-Kirchhoff and the deformation
   /// gradient
   template <UInt dim>
   inline void computeCauchyStressOnQuad(const Matrix<Real> & F,
                                         const Matrix<Real> & S,
                                         Matrix<Real> & cauchy,
                                         const Real & C33 = 1.0) const;
 
   template <UInt dim>
   void computeAllStressesFromTangentModuli(const ElementType & type,
                                            GhostType ghost_type);
 
   template <UInt dim>
   void assembleStiffnessMatrix(const ElementType & type, GhostType ghost_type);
 
   /// assembling in finite deformation
   template <UInt dim>
   void assembleStiffnessMatrixNL(const ElementType & type,
                                  GhostType ghost_type);
 
   template <UInt dim>
   void assembleStiffnessMatrixL2(const ElementType & type,
                                  GhostType ghost_type);
 
   /// Size of the Stress matrix for the case of finite deformation see: Bathe et
   /// al, IJNME, Vol 9, 353-386, 1975
   inline UInt getCauchyStressMatrixSize(UInt spatial_dimension) const;
 
   /// Sets the stress matrix according to Bathe et al, IJNME, Vol 9, 353-386,
   /// 1975
   template <UInt dim>
   inline void setCauchyStressMatrix(const Matrix<Real> & S_t,
                                     Matrix<Real> & sigma);
 
   /// write the stress tensor in the Voigt notation.
   template <UInt dim>
   inline void setCauchyStressArray(const Matrix<Real> & S_t,
                                    Matrix<Real> & sigma_voight);
 
   /* ------------------------------------------------------------------------ */
   /* Conversion functions                                                     */
   /* ------------------------------------------------------------------------ */
 public:
   template <UInt dim>
   static inline void gradUToF(const Matrix<Real> & grad_u, Matrix<Real> & F);
   static inline void rightCauchy(const Matrix<Real> & F, Matrix<Real> & C);
   static inline void leftCauchy(const Matrix<Real> & F, Matrix<Real> & B);
 
   template <UInt dim>
   static inline void gradUToEpsilon(const Matrix<Real> & grad_u,
                                     Matrix<Real> & epsilon);
   template <UInt dim>
   static inline void gradUToGreenStrain(const Matrix<Real> & grad_u,
                                         Matrix<Real> & epsilon);
 
   static inline Real stressToVonMises(const Matrix<Real> & stress);
 
 protected:
   /// converts global element to local element
   inline Element convertToLocalElement(const Element & global_element) const;
   /// converts local element to global element
   inline Element convertToGlobalElement(const Element & local_element) const;
 
   /// converts global quadrature point to local quadrature point
   inline IntegrationPoint
   convertToLocalPoint(const IntegrationPoint & global_point) const;
   /// converts local quadrature point to global quadrature point
   inline IntegrationPoint
   convertToGlobalPoint(const IntegrationPoint & local_point) const;
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
   virtual inline UInt getNbData(const Array<Element> & elements,
                                 const SynchronizationTag & tag) const;
 
   virtual inline void packData(CommunicationBuffer & buffer,
                                const Array<Element> & elements,
                                const SynchronizationTag & tag) const;
 
   virtual inline void unpackData(CommunicationBuffer & buffer,
                                  const Array<Element> & elements,
                                  const SynchronizationTag & tag);
 
   template <typename T>
   inline void packElementDataHelper(const ElementTypeMapArray<T> & data_to_pack,
                                     CommunicationBuffer & buffer,
                                     const Array<Element> & elements,
                                     const ID & fem_id = ID()) const;
 
   template <typename T>
   inline void unpackElementDataHelper(ElementTypeMapArray<T> & data_to_unpack,
                                       CommunicationBuffer & buffer,
                                       const Array<Element> & elements,
                                       const ID & fem_id = ID());
 
   /* ------------------------------------------------------------------------ */
   /* MeshEventHandler inherited members                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   virtual void onNodesAdded(const Array<UInt> &, const NewNodesEvent &){};
   virtual void onNodesRemoved(const Array<UInt> &, const Array<UInt> &,
                               const RemovedNodesEvent &){};
 
   virtual void onElementsAdded(const Array<Element> & element_list,
                                const NewElementsEvent & event);
 
   virtual void
   onElementsRemoved(const Array<Element> & element_list,
                     const ElementTypeMapArray<UInt> & new_numbering,
                     const RemovedElementsEvent & event);
 
   virtual void onElementsChanged(const Array<Element> &, const Array<Element> &,
                                  const ElementTypeMapArray<UInt> &,
                                  const ChangedElementsEvent &){};
 
   /* ------------------------------------------------------------------------ */
   /* SolidMechanicsModelEventHandler inherited members                        */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void onBeginningSolveStep(const AnalysisMethod & method);
   virtual void onEndSolveStep(const AnalysisMethod & method);
   virtual void onDamageIteration();
   virtual void onDamageUpdate();
   virtual void onDump();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(Name, name, const std::string &);
 
   AKANTU_GET_MACRO(Model, model, const SolidMechanicsModel &)
 
   AKANTU_GET_MACRO(ID, Memory::getID(), const ID &);
   AKANTU_GET_MACRO(Rho, rho, Real);
   AKANTU_SET_MACRO(Rho, rho, Real);
 
   AKANTU_GET_MACRO(SpatialDimension, spatial_dimension, UInt);
 
   /// return the potential energy for the subset of elements contained by the
   /// material
   Real getPotentialEnergy();
   /// return the potential energy for the provided element
   Real getPotentialEnergy(ElementType & type, UInt index);
 
   /// return the energy (identified by id) for the subset of elements contained
   /// by the material
   virtual Real getEnergy(std::string energy_id);
   /// return the energy (identified by id) for the provided element
   virtual Real getEnergy(std::string energy_id, ElementType type, UInt index);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ElementFilter, element_filter, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(GradU, gradu, Real);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Stress, stress, Real);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(PotentialEnergy, potential_energy,
                                          Real);
   AKANTU_GET_MACRO(GradU, gradu, const ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO(Stress, stress, const ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO(ElementFilter, element_filter,
                    const ElementTypeMapArray<UInt> &);
   AKANTU_GET_MACRO(FEEngine, fem, FEEngine &);
 
   bool isNonLocal() const { return is_non_local; }
 
   template <typename T>
   const Array<T> & getArray(const ID & id, const ElementType & type,
                             const GhostType & ghost_type = _not_ghost) const;
   template <typename T>
   Array<T> & getArray(const ID & id, const ElementType & type,
                       const GhostType & ghost_type = _not_ghost);
 
   template <typename T>
   const InternalField<T> & getInternal(const ID & id) const;
   template <typename T> InternalField<T> & getInternal(const ID & id);
 
   template <typename T>
   inline bool isInternal(const ID & id, const ElementKind & element_kind) const;
 
   template <typename T>
   ElementTypeMap<UInt>
   getInternalDataPerElem(const ID & id, const ElementKind & element_kind) const;
 
   bool isFiniteDeformation() const { return finite_deformation; }
   bool isInelasticDeformation() const { return inelastic_deformation; }
 
   template <typename T> inline void setParam(const ID & param, T value);
   inline const Parameter & getParam(const ID & param) const;
 
   template <typename T>
   void flattenInternal(const std::string & field_id,
                        ElementTypeMapArray<T> & internal_flat,
                        const GhostType ghost_type = _not_ghost,
                        ElementKind element_kind = _ek_not_defined) const;
 
   /// apply a constant eigengrad_u everywhere in the material
   virtual void applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const GhostType = _not_ghost);
 
   /// specify if the matrix need to be recomputed for this material
   virtual bool hasStiffnessMatrixChanged() { return true; }
 
 protected:
   bool isInit() const { return is_init; }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// boolean to know if the material has been initialized
   bool is_init;
 
   std::map<ID, InternalField<Real> *> internal_vectors_real;
   std::map<ID, InternalField<UInt> *> internal_vectors_uint;
   std::map<ID, InternalField<bool> *> internal_vectors_bool;
 
 protected:
   /// Link to the fem object in the model
   FEEngine & fem;
 
   /// Finite deformation
   bool finite_deformation;
 
   /// Finite deformation
   bool inelastic_deformation;
 
   /// material name
   std::string name;
 
   /// The model to witch the material belong
   SolidMechanicsModel & model;
 
   /// density : rho
   Real rho;
 
   /// spatial dimension
   UInt spatial_dimension;
 
   /// list of element handled by the material
   ElementTypeMapArray<UInt> element_filter;
 
   /// stresses arrays ordered by element types
   InternalField<Real> stress;
 
   /// eigengrad_u arrays ordered by element types
   InternalField<Real> eigengradu;
 
   /// grad_u arrays ordered by element types
   InternalField<Real> gradu;
 
   /// Green Lagrange strain (Finite deformation)
   InternalField<Real> green_strain;
 
   /// Second Piola-Kirchhoff stress tensor arrays ordered by element types
   /// (Finite deformation)
   InternalField<Real> piola_kirchhoff_2;
 
   /// potential energy by element
   InternalField<Real> potential_energy;
 
   /// tell if using in non local mode or not
   bool is_non_local;
 
   /// tell if the material need the previous stress state
   bool use_previous_stress;
 
   /// tell if the material need the previous strain state
   bool use_previous_gradu;
 
   /// elemental field interpolation coordinates
   InternalField<Real> interpolation_inverse_coordinates;
 
   /// elemental field interpolation points
   InternalField<Real> interpolation_points_matrices;
 
   /// vector that contains the names of all the internals that need to
   /// be transferred when material interfaces move
   std::vector<ID> internals_to_transfer;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Material & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "material_inline_impl.cc"
 
 #include "internal_field_tmpl.hh"
 #include "random_internal_field_tmpl.hh"
 
 /* -------------------------------------------------------------------------- */
 /* Auto loop                                                                  */
 /* -------------------------------------------------------------------------- */
 /// This can be used to automatically write the loop on quadrature points in
 /// functions such as computeStress. This macro in addition to write the loop
 /// provides two tensors (matrices) sigma and grad_u
 #define MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type)       \
   Array<Real>::matrix_iterator gradu_it =                                      \
       this->gradu(el_type, ghost_type)                                         \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
   Array<Real>::matrix_iterator gradu_end =                                     \
       this->gradu(el_type, ghost_type)                                         \
           .end(this->spatial_dimension, this->spatial_dimension);              \
                                                                                \
   this->stress(el_type, ghost_type)                                            \
-      .resize(this->gradu(el_type, ghost_type).getSize());                     \
+      .resize(this->gradu(el_type, ghost_type).size());                     \
                                                                                \
   Array<Real>::iterator<Matrix<Real>> stress_it =                              \
       this->stress(el_type, ghost_type)                                        \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
                                                                                \
   if (this->isFiniteDeformation()) {                                           \
     this->piola_kirchhoff_2(el_type, ghost_type)                               \
-        .resize(this->gradu(el_type, ghost_type).getSize());                   \
+        .resize(this->gradu(el_type, ghost_type).size());                   \
     stress_it = this->piola_kirchhoff_2(el_type, ghost_type)                   \
                     .begin(this->spatial_dimension, this->spatial_dimension);  \
   }                                                                            \
                                                                                \
   for (; gradu_it != gradu_end; ++gradu_it, ++stress_it) {                     \
     Matrix<Real> & __attribute__((unused)) grad_u = *gradu_it;                 \
     Matrix<Real> & __attribute__((unused)) sigma = *stress_it
 
 #define MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END }
 
 /// This can be used to automatically write the loop on quadrature points in
 /// functions such as computeTangentModuli. This macro in addition to write the
 /// loop provides two tensors (matrices) sigma_tensor, grad_u, and a matrix
 /// where the elemental tangent moduli should be stored in Voigt Notation
 #define MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_mat)              \
   Array<Real>::matrix_iterator gradu_it =                                      \
       this->gradu(el_type, ghost_type)                                         \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
   Array<Real>::matrix_iterator gradu_end =                                     \
       this->gradu(el_type, ghost_type)                                         \
           .end(this->spatial_dimension, this->spatial_dimension);              \
   Array<Real>::matrix_iterator sigma_it =                                      \
       this->stress(el_type, ghost_type)                                        \
           .begin(this->spatial_dimension, this->spatial_dimension);            \
                                                                                \
-  tangent_mat.resize(this->gradu(el_type, ghost_type).getSize());              \
+  tangent_mat.resize(this->gradu(el_type, ghost_type).size());              \
                                                                                \
   UInt tangent_size =                                                          \
       this->getTangentStiffnessVoigtSize(this->spatial_dimension);             \
   Array<Real>::matrix_iterator tangent_it =                                    \
       tangent_mat.begin(tangent_size, tangent_size);                           \
                                                                                \
   for (; gradu_it != gradu_end; ++gradu_it, ++sigma_it, ++tangent_it) {        \
     Matrix<Real> & __attribute__((unused)) grad_u = *gradu_it;                 \
     Matrix<Real> & __attribute__((unused)) sigma_tensor = *sigma_it;           \
     Matrix<Real> & tangent = *tangent_it
 
 #define MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END }
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 using MaterialFactory =
     Factory<Material, UInt, const ID &, SolidMechanicsModel &, const ID &>;
 } // namespace akantu
 
 #define INSTANTIATE_MATERIAL_ONLY(mat_name)                                    \
   template class mat_name<1>;                                                  \
   template class mat_name<2>;                                                  \
   template class mat_name<3>
 
 #define MATERIAL_DEFAULT_PER_DIM_ALLOCATOR(id, mat_name)                       \
   [](UInt dim, const ID &, SolidMechanicsModel & model,                        \
      const ID & id) -> std::unique_ptr<Material> {                             \
     switch (dim) {                                                             \
     case 1:                                                                    \
       return std::make_unique<mat_name<1>>(model, id);                         \
     case 2:                                                                    \
       return std::make_unique<mat_name<2>>(model, id);                         \
     case 3:                                                                    \
       return std::make_unique<mat_name<3>>(model, id);                         \
     default:                                                                   \
       AKANTU_EXCEPTION("The dimension "                                        \
                        << dim << "is not a valid dimension for the material "  \
                        << #id);                                                \
     }                                                                          \
   }
 
 #define INSTANTIATE_MATERIAL(id, mat_name)                                     \
   INSTANTIATE_MATERIAL_ONLY(mat_name);                                         \
   static bool material_is_alocated_##id =                                      \
       MaterialFactory::getInstance().registerAllocator(                        \
           #id, MATERIAL_DEFAULT_PER_DIM_ALLOCATOR(id, mat_name))
 
 #endif /* __AKANTU_MATERIAL_HH__ */
diff --git a/src/model/solid_mechanics/material_inline_impl.cc b/src/model/solid_mechanics/material_inline_impl.cc
index 26dcfbbf6..9bbda3334 100644
--- a/src/model/solid_mechanics/material_inline_impl.cc
+++ b/src/model/solid_mechanics/material_inline_impl.cc
@@ -1,461 +1,461 @@
 /**
  * @file   material_inline_impl.cc
  *
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Wed Nov 25 2015
  *
  * @brief  Implementation of the inline functions of the class material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_INLINE_IMPL_CC__
 #define __AKANTU_MATERIAL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::addElement(const ElementType & type, UInt element,
                                  const GhostType & ghost_type) {
   Array<UInt> & el_filter = this->element_filter(type, ghost_type);
   el_filter.push_back(element);
-  return el_filter.getSize() - 1;
+  return el_filter.size() - 1;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getTangentStiffnessVoigtSize(UInt dim) const {
   return (dim * (dim - 1) / 2 + dim);
 }
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getCauchyStressMatrixSize(UInt dim) const {
   return (dim * dim);
 }
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToF(const Matrix<Real> & grad_u, Matrix<Real> & F) {
   AKANTU_DEBUG_ASSERT(F.size() >= grad_u.size() && grad_u.size() == dim * dim,
                       "The dimension of the tensor F should be greater or "
                       "equal to the dimension of the tensor grad_u.");
 
   F.eye();
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       F(i, j) += grad_u(i, j);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::computeCauchyStressOnQuad(const Matrix<Real> & F,
                                                 const Matrix<Real> & piola,
                                                 Matrix<Real> & sigma,
                                                 const Real & C33) const {
 
   Real J = F.det() * sqrt(C33);
 
   Matrix<Real> F_S(dim, dim);
   F_S.mul<false, false>(F, piola);
   Real constant = J ? 1. / J : 0;
   sigma.mul<false, true>(F_S, F, constant);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::rightCauchy(const Matrix<Real> & F, Matrix<Real> & C) {
   C.mul<true, false>(F, F);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::leftCauchy(const Matrix<Real> & F, Matrix<Real> & B) {
   B.mul<false, true>(F, F);
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToEpsilon(const Matrix<Real> & grad_u,
                                      Matrix<Real> & epsilon) {
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       epsilon(i, j) = 0.5 * (grad_u(i, j) + grad_u(j, i));
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::gradUToGreenStrain(const Matrix<Real> & grad_u,
                                          Matrix<Real> & epsilon) {
   epsilon.mul<true, false>(grad_u, grad_u, .5);
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       epsilon(i, j) += 0.5 * (grad_u(i, j) + grad_u(j, i));
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real Material::stressToVonMises(const Matrix<Real> & stress) {
   // compute deviatoric stress
   UInt dim = stress.cols();
   Matrix<Real> deviatoric_stress =
       Matrix<Real>::eye(dim, -1. * stress.trace() / 3.);
 
   for (UInt i = 0; i < dim; ++i)
     for (UInt j = 0; j < dim; ++j)
       deviatoric_stress(i, j) += stress(i, j);
 
   // return Von Mises stress
   return std::sqrt(3. * deviatoric_stress.doubleDot(deviatoric_stress) / 2.);
 }
 
 /* ---------------------------------------------------------------------------*/
 template <UInt dim>
 inline void Material::setCauchyStressArray(const Matrix<Real> & S_t,
                                            Matrix<Real> & sigma_voight) {
   AKANTU_DEBUG_IN();
   sigma_voight.clear();
   // see Finite ekement formulations for large deformation dynamic analysis,
   // Bathe et al. IJNME vol 9, 1975, page 364 ^t\tau
 
   /*
    * 1d: [ s11 ]'
    * 2d: [ s11 s22 s12 ]'
    * 3d: [ s11 s22 s33 s23 s13 s12 ]
    */
   for (UInt i = 0; i < dim; ++i) // diagonal terms
     sigma_voight(i, 0) = S_t(i, i);
 
   for (UInt i = 1; i < dim; ++i) // term s12 in 2D and terms s23 s13 in 3D
     sigma_voight(dim + i - 1, 0) = S_t(dim - i - 1, dim - 1);
 
   for (UInt i = 2; i < dim; ++i) // term s13 in 3D
     sigma_voight(dim + i, 0) = S_t(0, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 inline void Material::setCauchyStressMatrix(const Matrix<Real> & S_t,
                                             Matrix<Real> & sigma) {
   AKANTU_DEBUG_IN();
 
   sigma.clear();
 
   /// see Finite ekement formulations for large deformation dynamic analysis,
   /// Bathe et al. IJNME vol 9, 1975, page 364 ^t\tau
   for (UInt i = 0; i < dim; ++i) {
     for (UInt m = 0; m < dim; ++m) {
       for (UInt n = 0; n < dim; ++n) {
         sigma(i * dim + m, i * dim + n) = S_t(m, n);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline Element
 Material::convertToLocalElement(const Element & global_element) const {
   UInt ge = global_element.element;
 #ifndef AKANTU_NDEBUG
   UInt model_mat_index = this->model.getMaterialByElement(
       global_element.type, global_element.ghost_type)(ge);
 
   UInt mat_index = this->model.getMaterialIndex(this->name);
   AKANTU_DEBUG_ASSERT(model_mat_index == mat_index,
                       "Conversion of a global  element in a local element for "
                       "the wrong material "
                           << this->name << std::endl);
 #endif
   UInt le = this->model.getMaterialLocalNumbering(
       global_element.type, global_element.ghost_type)(ge);
 
   Element tmp_quad(global_element.type, le, global_element.ghost_type,
                    global_element.kind);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Element
 Material::convertToGlobalElement(const Element & local_element) const {
   UInt le = local_element.element;
   UInt ge =
       this->element_filter(local_element.type, local_element.ghost_type)(le);
 
   Element tmp_quad(local_element.type, ge, local_element.ghost_type,
                    local_element.kind);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline IntegrationPoint
 Material::convertToLocalPoint(const IntegrationPoint & global_point) const {
   const FEEngine & fem = this->model.getFEEngine();
   UInt nb_quad = fem.getNbIntegrationPoints(global_point.type);
   Element el =
       this->convertToLocalElement(static_cast<const Element &>(global_point));
   IntegrationPoint tmp_quad(el, global_point.num_point, nb_quad);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline IntegrationPoint
 Material::convertToGlobalPoint(const IntegrationPoint & local_point) const {
   const FEEngine & fem = this->model.getFEEngine();
   UInt nb_quad = fem.getNbIntegrationPoints(local_point.type);
   Element el =
       this->convertToGlobalElement(static_cast<const Element &>(local_point));
   IntegrationPoint tmp_quad(el, local_point.num_point, nb_quad);
   return tmp_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Material::getNbData(const Array<Element> & elements,
                                 const SynchronizationTag & tag) const {
   if (tag == _gst_smm_stress) {
     return (this->isFiniteDeformation() ? 3 : 1) * spatial_dimension *
            spatial_dimension * sizeof(Real) *
            this->getModel().getNbIntegrationPoints(elements);
   }
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::packData(CommunicationBuffer & buffer,
                                const Array<Element> & elements,
                                const SynchronizationTag & tag) const {
   if (tag == _gst_smm_stress) {
     if (this->isFiniteDeformation()) {
       packElementDataHelper(piola_kirchhoff_2, buffer, elements);
       packElementDataHelper(gradu, buffer, elements);
     }
     packElementDataHelper(stress, buffer, elements);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void Material::unpackData(CommunicationBuffer & buffer,
                                  const Array<Element> & elements,
                                  const SynchronizationTag & tag) {
   if (tag == _gst_smm_stress) {
     if (this->isFiniteDeformation()) {
       unpackElementDataHelper(piola_kirchhoff_2, buffer, elements);
       unpackElementDataHelper(gradu, buffer, elements);
     }
     unpackElementDataHelper(stress, buffer, elements);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Parameter & Material::getParam(const ID & param) const {
   try {
     return get(param);
   } catch (...) {
     AKANTU_EXCEPTION("No parameter " << param << " in the material "
                                      << getID());
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::setParam(const ID & param, T value) {
   try {
     set<T>(param, value);
   } catch (...) {
     AKANTU_EXCEPTION("No parameter " << param << " in the material "
                                      << getID());
   }
   updateInternalParameters();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::packElementDataHelper(
     const ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
     const Array<Element> & elements, const ID & fem_id) const {
   DataAccessor::packElementalDataHelper<T>(data_to_pack, buffer, elements, true,
                                            model.getFEEngine(fem_id));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Material::unpackElementDataHelper(
     ElementTypeMapArray<T> & data_to_unpack, CommunicationBuffer & buffer,
     const Array<Element> & elements, const ID & fem_id) {
   DataAccessor::unpackElementalDataHelper<T>(data_to_unpack, buffer, elements,
                                              true, model.getFEEngine(fem_id));
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Material::registerInternal<Real>(InternalField<Real> & vect) {
   internal_vectors_real[vect.getID()] = &vect;
 }
 
 template <>
 inline void Material::registerInternal<UInt>(InternalField<UInt> & vect) {
   internal_vectors_uint[vect.getID()] = &vect;
 }
 
 template <>
 inline void Material::registerInternal<bool>(InternalField<bool> & vect) {
   internal_vectors_bool[vect.getID()] = &vect;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void Material::unregisterInternal<Real>(InternalField<Real> & vect) {
   internal_vectors_real.erase(vect.getID());
 }
 
 template <>
 inline void Material::unregisterInternal<UInt>(InternalField<UInt> & vect) {
   internal_vectors_uint.erase(vect.getID());
 }
 
 template <>
 inline void Material::unregisterInternal<bool>(InternalField<bool> & vect) {
   internal_vectors_bool.erase(vect.getID());
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline bool Material::isInternal(__attribute__((unused)) const ID & id,
                                  __attribute__((unused)) const ElementKind & element_kind) const {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 template <>
 inline bool Material::isInternal<Real>(const ID & id,
                                        const ElementKind & element_kind) const {
   std::map<ID, InternalField<Real> *>::const_iterator internal_array =
       internal_vectors_real.find(this->getID() + ":" + id);
 
   if (internal_array == internal_vectors_real.end() ||
       internal_array->second->getElementKind() != element_kind)
     return false;
   return true;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline ElementTypeMap<UInt>
 Material::getInternalDataPerElem(const ID & field_id,
                                  const ElementKind & element_kind) const {
 
   if (!this->template isInternal<T>(field_id, element_kind))
     AKANTU_EXCEPTION("Cannot find internal field " << id << " in material "
                                                    << this->name);
 
   const InternalField<T> & internal_field =
       this->template getInternal<T>(field_id);
   const FEEngine & fe_engine = internal_field.getFEEngine();
   UInt nb_data_per_quad = internal_field.getNbComponent();
 
   ElementTypeMap<UInt> res;
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     typedef typename InternalField<T>::type_iterator type_iterator;
     type_iterator tit = internal_field.firstType(*gt);
     type_iterator tend = internal_field.lastType(*gt);
 
     for (; tit != tend; ++tit) {
       UInt nb_quadrature_points = fe_engine.getNbIntegrationPoints(*tit, *gt);
       res(*tit, *gt) = nb_data_per_quad * nb_quadrature_points;
     }
   }
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Material::flattenInternal(const std::string & field_id,
                                ElementTypeMapArray<T> & internal_flat,
                                const GhostType ghost_type,
                                ElementKind element_kind) const {
 
   if (!this->template isInternal<T>(field_id, element_kind))
     AKANTU_EXCEPTION("Cannot find internal field " << id << " in material "
                                                    << this->name);
 
   const InternalField<T> & internal_field =
       this->template getInternal<T>(field_id);
 
   const FEEngine & fe_engine = internal_field.getFEEngine();
   const Mesh & mesh = fe_engine.getMesh();
 
   typedef typename InternalField<T>::filter_type_iterator type_iterator;
   type_iterator tit = internal_field.filterFirstType(ghost_type);
   type_iterator tend = internal_field.filterLastType(ghost_type);
 
   for (; tit != tend; ++tit) {
     ElementType type = *tit;
 
     const Array<Real> & src_vect = internal_field(type, ghost_type);
     const Array<UInt> & filter = internal_field.getFilter(type, ghost_type);
 
     // total number of elements in the corresponding mesh
     UInt nb_element_dst = mesh.getNbElement(type, ghost_type);
     // number of element in the internal field
-    UInt nb_element_src = filter.getSize();
+    UInt nb_element_src = filter.size();
     // number of quadrature points per elem
     UInt nb_quad_per_elem = fe_engine.getNbIntegrationPoints(type);
     // number of data per quadrature point
     UInt nb_data_per_quad = internal_field.getNbComponent();
 
     if (!internal_flat.exists(type, ghost_type)) {
       internal_flat.alloc(nb_element_dst * nb_quad_per_elem, nb_data_per_quad,
                           type, ghost_type);
     }
 
     if (nb_element_src == 0)
       continue;
 
     // number of data per element
     UInt nb_data = nb_quad_per_elem * nb_data_per_quad;
 
     Array<Real> & dst_vect = internal_flat(type, ghost_type);
     dst_vect.resize(nb_element_dst * nb_quad_per_elem);
 
     Array<UInt>::const_scalar_iterator it = filter.begin();
     Array<UInt>::const_scalar_iterator end = filter.end();
 
     Array<Real>::const_vector_iterator it_src =
         src_vect.begin_reinterpret(nb_data, nb_element_src);
     Array<Real>::vector_iterator it_dst =
         dst_vect.begin_reinterpret(nb_data, nb_element_dst);
 
     for (; it != end; ++it, ++it_src) {
       it_dst[*it] = *it_src;
     }
   }
 }
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_INLINE_IMPL_CC__ */
diff --git a/src/model/solid_mechanics/material_selector.hh b/src/model/solid_mechanics/material_selector.hh
index 603a250b9..54df2c595 100644
--- a/src/model/solid_mechanics/material_selector.hh
+++ b/src/model/solid_mechanics/material_selector.hh
@@ -1,147 +1,147 @@
 /**
  * @file   material_selector.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Dec 17 2015
  *
  * @brief  class describing how to choose a material for a given element
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_SELECTOR_HH__
 #define __AKANTU_MATERIAL_SELECTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class SolidMechanicsModel;
 
 /**
  * main class to assign same or different materials for different
  * elements
  */
 class MaterialSelector {
 public:
   MaterialSelector() : fallback_value(0) {}
   virtual ~MaterialSelector() {}
   virtual UInt operator()(__attribute__((unused)) const Element & element) {
     return fallback_value;
   }
 
   void setFallback(UInt f) { fallback_value = f; }
 
 protected:
   UInt fallback_value;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * class that assigns the first material to regular elements by default
  */
 class DefaultMaterialSelector : public MaterialSelector {
 public:
   DefaultMaterialSelector(const ElementTypeMapArray<UInt> & material_index)
       : material_index(material_index) {}
 
   UInt operator()(const Element & element) {
     try {
       DebugLevel dbl = debug::getDebugLevel();
       debug::setDebugLevel(dblError);
 
       const Array<UInt> & mat_indexes =
           material_index(element.type, element.ghost_type);
       UInt mat = this->fallback_value;
 
-      if (element.element < mat_indexes.getSize())
+      if (element.element < mat_indexes.size())
         mat = mat_indexes(element.element);
 
       debug::setDebugLevel(dbl);
       return mat;
     } catch (...) {
       return MaterialSelector::operator()(element);
     }
   }
 
 private:
   const ElementTypeMapArray<UInt> & material_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Use elemental data to assign materials
  */
 template <typename T>
 class ElementDataMaterialSelector : public MaterialSelector {
 public:
   ElementDataMaterialSelector(const ElementTypeMapArray<T> & element_data,
                               const SolidMechanicsModel & model,
                               UInt first_index = 1)
       : element_data(element_data), model(model), first_index(first_index) {}
 
   inline T elementData(const Element & element) {
     DebugLevel dbl = debug::getDebugLevel();
     debug::setDebugLevel(dblError);
     T data = element_data(element.type, element.ghost_type)(element.element);
     debug::setDebugLevel(dbl);
     return data;
   }
 
   inline UInt operator()(const Element & element) {
     return MaterialSelector::operator()(element);
   }
 
 protected:
   /// list of element with the specified data (i.e. tag value)
   const ElementTypeMapArray<T> & element_data;
 
   /// the model that the materials belong
   const SolidMechanicsModel & model;
 
   /// first material index: equal to 1 if none specified
   UInt first_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * class to use mesh data information to assign different materials
  * where name is the tag value: tag_0, tag_1
  */
 template <typename T>
 class MeshDataMaterialSelector : public ElementDataMaterialSelector<T> {
 public:
   MeshDataMaterialSelector(const std::string & name,
                            const SolidMechanicsModel & model,
                            UInt first_index = 1);
 };
 
 } // akantu
 
 #endif /* __AKANTU_MATERIAL_SELECTOR_HH__ */
diff --git a/src/model/solid_mechanics/materials/internal_field_tmpl.hh b/src/model/solid_mechanics/materials/internal_field_tmpl.hh
index 156bd55e7..88d2b2539 100644
--- a/src/model/solid_mechanics/materials/internal_field_tmpl.hh
+++ b/src/model/solid_mechanics/materials/internal_field_tmpl.hh
@@ -1,320 +1,320 @@
 /**
  * @file   internal_field_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Material internal properties
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_INTERNAL_FIELD_TMPL_HH__
 #define __AKANTU_INTERNAL_FIELD_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 InternalField<T>::InternalField(const ID & id, Material & material)
     : ElementTypeMapArray<T>(id, material.getID(), material.getMemoryID()),
       material(material), fem(&(material.getModel().getFEEngine())),
       element_filter(material.getElementFilter()), default_value(T()),
       spatial_dimension(material.getModel().getSpatialDimension()),
       element_kind(_ek_regular), nb_component(0), is_init(false),
       previous_values(NULL) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 InternalField<T>::InternalField(
     const ID & id, Material & material, FEEngine & fem,
     const ElementTypeMapArray<UInt> & element_filter)
     : ElementTypeMapArray<T>(id, material.getID(), material.getMemoryID()),
       material(material), fem(&fem), element_filter(element_filter),
       default_value(T()), spatial_dimension(material.getSpatialDimension()),
       element_kind(_ek_regular), nb_component(0), is_init(false),
       previous_values(NULL) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 InternalField<T>::InternalField(
     const ID & id, Material & material, UInt dim, FEEngine & fem,
     const ElementTypeMapArray<UInt> & element_filter)
     : ElementTypeMapArray<T>(id, material.getID(), material.getMemoryID()),
       material(material), fem(&fem), element_filter(element_filter),
       default_value(T()), spatial_dimension(dim), element_kind(_ek_regular),
       nb_component(0), is_init(false), previous_values(NULL) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 InternalField<T>::InternalField(const ID & id, const InternalField<T> & other)
     : ElementTypeMapArray<T>(id, other.material.getID(),
                              other.material.getMemoryID()),
       material(other.material), fem(other.fem),
       element_filter(other.element_filter), default_value(other.default_value),
       spatial_dimension(other.spatial_dimension),
       element_kind(other.element_kind), nb_component(other.nb_component),
       is_init(false), previous_values(NULL) {
 
   AKANTU_DEBUG_ASSERT(other.is_init,
                       "Cannot create a copy of a non initialized field");
   this->internalInitialize(this->nb_component);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> InternalField<T>::~InternalField() {
   if (this->is_init) {
     this->material.unregisterInternal(*this);
   }
 
   delete previous_values;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void InternalField<T>::setFEEngine(FEEngine & fe_engine) {
   this->fem = &fe_engine;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void InternalField<T>::setElementKind(ElementKind element_kind) {
   this->element_kind = element_kind;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void InternalField<T>::initialize(UInt nb_component) {
   internalInitialize(nb_component);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void InternalField<T>::initializeHistory() {
   if (!previous_values)
     previous_values = new InternalField<T>("previous_" + this->getID(), *this);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void InternalField<T>::resize() {
   if (!this->is_init)
     return;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     filter_type_iterator it = this->filterFirstType(*gt);
     filter_type_iterator end = this->filterLastType(*gt);
 
     for (; it != end; ++it) {
-      UInt nb_element = this->element_filter(*it, *gt).getSize();
+      UInt nb_element = this->element_filter(*it, *gt).size();
 
       UInt nb_quadrature_points = this->fem->getNbIntegrationPoints(*it, *gt);
       UInt new_size = nb_element * nb_quadrature_points;
 
       UInt old_size = 0;
       Array<T> * vect = NULL;
 
       if (this->exists(*it, *gt)) {
         vect = &(this->operator()(*it, *gt));
-        old_size = vect->getSize();
+        old_size = vect->size();
         vect->resize(new_size);
       } else {
         vect = &(this->alloc(nb_element * nb_quadrature_points, nb_component,
                              *it, *gt));
       }
 
       this->setArrayValues(vect->storage() + old_size * vect->getNbComponent(),
                            vect->storage() + new_size * vect->getNbComponent());
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void InternalField<T>::setDefaultValue(const T & value) {
   this->default_value = value;
   this->reset();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void InternalField<T>::reset() {
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     type_iterator it = this->firstType(*gt);
     type_iterator end = this->lastType(*gt);
     for (; it != end; ++it) {
       Array<T> & vect = this->operator()(*it, *gt);
       vect.clear();
       this->setArrayValues(vect.storage(),
                            vect.storage() +
-                               vect.getSize() * vect.getNbComponent());
+                               vect.size() * vect.getNbComponent());
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void InternalField<T>::internalInitialize(UInt nb_component) {
   if (!this->is_init) {
     this->nb_component = nb_component;
 
     for (ghost_type_t::iterator gt = ghost_type_t::begin();
          gt != ghost_type_t::end(); ++gt) {
       filter_type_iterator it = this->filterFirstType(*gt);
       filter_type_iterator end = this->filterLastType(*gt);
 
       for (; it != end; ++it) {
-        UInt nb_element = this->element_filter(*it, *gt).getSize();
+        UInt nb_element = this->element_filter(*it, *gt).size();
         UInt nb_quadrature_points = this->fem->getNbIntegrationPoints(*it, *gt);
         if (this->exists(*it, *gt))
           this->operator()(*it, *gt).resize(nb_element * nb_quadrature_points);
         else
           this->alloc(nb_element * nb_quadrature_points, nb_component, *it,
                       *gt);
       }
     }
 
     this->material.registerInternal(*this);
     this->is_init = true;
   }
   this->reset();
 
   if (this->previous_values)
     this->previous_values->internalInitialize(nb_component);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void InternalField<T>::setArrayValues(T * begin, T * end) {
   for (; begin < end; ++begin)
     *begin = this->default_value;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void InternalField<T>::saveCurrentValues() {
   AKANTU_DEBUG_ASSERT(this->previous_values != NULL,
                       "The history of the internal "
                           << this->getID() << " has not been activated");
 
   if (!this->is_init)
     return;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     type_iterator it = this->firstType(*gt);
     type_iterator end = this->lastType(*gt);
     for (; it != end; ++it) {
       this->previous_values->operator()(*it, *gt)
           .copy(this->operator()(*it, *gt));
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void InternalField<T>::removeIntegrationPoints(
     const ElementTypeMapArray<UInt> & new_numbering) {
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     ElementTypeMapArray<UInt>::type_iterator it =
         new_numbering.firstType(_all_dimensions, *gt, _ek_not_defined);
     ElementTypeMapArray<UInt>::type_iterator end =
         new_numbering.lastType(_all_dimensions, *gt, _ek_not_defined);
     for (; it != end; ++it) {
       ElementType type = *it;
       if (this->exists(type, *gt)) {
         Array<T> & vect = this->operator()(type, *gt);
-        if (!vect.getSize())
+        if (!vect.size())
           continue;
         const Array<UInt> & renumbering = new_numbering(type, *gt);
 
         UInt nb_quad_per_elem = fem->getNbIntegrationPoints(type, *gt);
         UInt nb_component = vect.getNbComponent();
 
-        Array<T> tmp(renumbering.getSize() * nb_quad_per_elem, nb_component);
+        Array<T> tmp(renumbering.size() * nb_quad_per_elem, nb_component);
 
         AKANTU_DEBUG_ASSERT(
-            tmp.getSize() == vect.getSize(),
+            tmp.size() == vect.size(),
             "Something strange append some mater was created from nowhere!!");
 
         AKANTU_DEBUG_ASSERT(
-            tmp.getSize() == vect.getSize(),
+            tmp.size() == vect.size(),
             "Something strange append some mater was created or disappeared in "
-                << vect.getID() << "(" << vect.getSize()
-                << "!=" << tmp.getSize() << ") "
+                << vect.getID() << "(" << vect.size()
+                << "!=" << tmp.size() << ") "
                                             "!!");
 
         UInt new_size = 0;
-        for (UInt i = 0; i < renumbering.getSize(); ++i) {
+        for (UInt i = 0; i < renumbering.size(); ++i) {
           UInt new_i = renumbering(i);
           if (new_i != UInt(-1)) {
             memcpy(tmp.storage() + new_i * nb_component * nb_quad_per_elem,
                    vect.storage() + i * nb_component * nb_quad_per_elem,
                    nb_component * nb_quad_per_elem * sizeof(T));
             ++new_size;
           }
         }
         tmp.resize(new_size * nb_quad_per_elem);
         vect.copy(tmp);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void InternalField<T>::printself(std::ostream & stream, int indent) const {
   stream << "InternalField [ " << this->getID();
 #if !defined(AKANTU_NDEBUG)
   if (AKANTU_DEBUG_TEST(dblDump)) {
     stream << std::endl;
     ElementTypeMapArray<T>::printself(stream, indent + 3);
   } else {
 #endif
     stream << " {" << this->getData(_not_ghost).size() << " types - "
            << this->getData(_ghost).size() << " ghost types"
            << "}";
 #if !defined(AKANTU_NDEBUG)
   }
 #endif
   stream << " ]";
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ParameterTyped<InternalField<Real> >::setAuto(
     const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   Real r = in_param;
   param.setDefaultValue(r);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline InternalField<T>::operator T() const {
   return default_value;
 }
 
 } // akantu
 
 #endif /* __AKANTU_INTERNAL_FIELD_TMPL_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear.cc b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear.cc
index a16acc590..25b195500 100644
--- a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear.cc
+++ b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear.cc
@@ -1,700 +1,700 @@
 /**
  * @file   material_cohesive_linear.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Feb 22 2012
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Linear irreversible cohesive law of mixed mode loading with
  * random stress definition for extrinsic type
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <numeric>
 
 /* -------------------------------------------------------------------------- */
 #include "dof_synchronizer.hh"
 #include "material_cohesive_linear.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "sparse_matrix.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 MaterialCohesiveLinear<spatial_dimension>::MaterialCohesiveLinear(
     SolidMechanicsModel & model, const ID & id)
     : MaterialCohesive(model, id), sigma_c_eff("sigma_c_eff", *this),
       delta_c_eff("delta_c_eff", *this),
       insertion_stress("insertion_stress", *this),
       opening_prec("opening_prec", *this),
       reduction_penalty("reduction_penalty", *this) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("beta", beta, Real(0.), _pat_parsable | _pat_readable,
                       "Beta parameter");
 
   this->registerParam("G_c", G_c, Real(0.), _pat_parsable | _pat_readable,
                       "Mode I fracture energy");
 
   this->registerParam("penalty", penalty, Real(0.),
                       _pat_parsable | _pat_readable, "Penalty coefficient");
 
   this->registerParam("volume_s", volume_s, Real(0.),
                       _pat_parsable | _pat_readable,
                       "Reference volume for sigma_c scaling");
 
   this->registerParam("m_s", m_s, Real(1.), _pat_parsable | _pat_readable,
                       "Weibull exponent for sigma_c scaling");
 
   this->registerParam("kappa", kappa, Real(1.), _pat_parsable | _pat_readable,
                       "Kappa parameter");
 
   this->registerParam(
       "contact_after_breaking", contact_after_breaking, false,
       _pat_parsable | _pat_readable,
       "Activation of contact when the elements are fully damaged");
 
   this->registerParam("max_quad_stress_insertion", max_quad_stress_insertion,
                       false, _pat_parsable | _pat_readable,
                       "Insertion of cohesive element when stress is high "
                       "enough just on one quadrature point");
 
   this->registerParam("recompute", recompute, false,
                       _pat_parsable | _pat_modifiable, "recompute solution");
 
   this->use_previous_delta_max = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinear<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   MaterialCohesive::initMaterial();
 
   /// compute scalars
   beta2_kappa2 = beta * beta / kappa / kappa;
   beta2_kappa = beta * beta / kappa;
 
   if (Math::are_float_equal(beta, 0))
     beta2_inv = 0;
   else
     beta2_inv = 1. / beta / beta;
 
   sigma_c_eff.initialize(1);
   delta_c_eff.initialize(1);
   insertion_stress.initialize(spatial_dimension);
   opening_prec.initialize(spatial_dimension);
   reduction_penalty.initialize(1);
 
   if (!Math::are_float_equal(delta_c, 0.))
     delta_c_eff.setDefaultValue(delta_c);
   else
     delta_c_eff.setDefaultValue(2 * G_c / sigma_c);
 
   if (model->getIsExtrinsic())
     scaleInsertionTraction();
   opening_prec.initializeHistory();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinear<spatial_dimension>::scaleInsertionTraction() {
   AKANTU_DEBUG_IN();
 
   // do nothing if volume_s hasn't been specified by the user
   if (Math::are_float_equal(volume_s, 0.))
     return;
 
   const Mesh & mesh_facets = model->getMeshFacets();
   const FEEngine & fe_engine = model->getFEEngine();
   const FEEngine & fe_engine_facet = model->getFEEngine("FacetsFEEngine");
 
   // loop over facet type
   Mesh::type_iterator first = mesh_facets.firstType(spatial_dimension - 1);
   Mesh::type_iterator last = mesh_facets.lastType(spatial_dimension - 1);
 
   Real base_sigma_c = sigma_c;
 
   for (; first != last; ++first) {
     ElementType type_facet = *first;
 
     const Array<std::vector<Element> > & facet_to_element =
         mesh_facets.getElementToSubelement(type_facet);
 
-    UInt nb_facet = facet_to_element.getSize();
+    UInt nb_facet = facet_to_element.size();
     UInt nb_quad_per_facet = fe_engine_facet.getNbIntegrationPoints(type_facet);
 
     // iterator to modify sigma_c for all the quadrature points of a facet
     Array<Real>::vector_iterator sigma_c_iterator =
         sigma_c(type_facet).begin_reinterpret(nb_quad_per_facet, nb_facet);
 
     for (UInt f = 0; f < nb_facet; ++f, ++sigma_c_iterator) {
 
       const std::vector<Element> & element_list = facet_to_element(f);
 
       // compute bounding volume
       Real volume = 0;
 
       std::vector<Element>::const_iterator elem = element_list.begin();
       std::vector<Element>::const_iterator elem_end = element_list.end();
 
       for (; elem != elem_end; ++elem) {
         if (*elem == ElementNull)
           continue;
 
         // unit vector for integration in order to obtain the volume
         UInt nb_quadrature_points =
             fe_engine.getNbIntegrationPoints(elem->type);
         Vector<Real> unit_vector(nb_quadrature_points, 1);
 
         volume += fe_engine.integrate(unit_vector, elem->type, elem->element,
                                       elem->ghost_type);
       }
 
       // scale sigma_c
       *sigma_c_iterator -= base_sigma_c;
       *sigma_c_iterator *= std::pow(volume_s / volume, 1. / m_s);
       *sigma_c_iterator += base_sigma_c;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinear<spatial_dimension>::checkInsertion(
     bool check_only) {
   AKANTU_DEBUG_IN();
 
   const Mesh & mesh_facets = model->getMeshFacets();
   CohesiveElementInserter & inserter = model->getElementInserter();
 
   Real tolerance = Math::getTolerance();
 
   Mesh::type_iterator it = mesh_facets.firstType(spatial_dimension - 1);
   Mesh::type_iterator last = mesh_facets.lastType(spatial_dimension - 1);
 
   for (; it != last; ++it) {
     ElementType type_facet = *it;
     ElementType type_cohesive = FEEngine::getCohesiveElementType(type_facet);
     const Array<bool> & facets_check = inserter.getCheckFacets(type_facet);
     Array<bool> & f_insertion = inserter.getInsertionFacets(type_facet);
     Array<UInt> & f_filter = facet_filter(type_facet);
     Array<Real> & sig_c_eff = sigma_c_eff(type_cohesive);
     Array<Real> & del_c = delta_c_eff(type_cohesive);
     Array<Real> & ins_stress = insertion_stress(type_cohesive);
     Array<Real> & trac_old = tractions_old(type_cohesive);
     Array<Real> & open_prec = opening_prec(type_cohesive);
     Array<bool> & red_penalty = reduction_penalty(type_cohesive);
     const Array<Real> & f_stress = model->getStressOnFacets(type_facet);
     const Array<Real> & sigma_lim = sigma_c(type_facet);
     Real max_ratio = 0.;
     UInt index_f = 0;
     UInt index_filter = 0;
     UInt nn = 0;
 
     UInt nb_quad_facet =
         model->getFEEngine("FacetsFEEngine").getNbIntegrationPoints(type_facet);
     UInt nb_quad_cohesive = model->getFEEngine("CohesiveFEEngine")
                                 .getNbIntegrationPoints(type_cohesive);
 
     AKANTU_DEBUG_ASSERT(nb_quad_cohesive == nb_quad_facet,
                         "The cohesive element and the corresponding facet do "
                         "not have the same numbers of integration points");
 
-    UInt nb_facet = f_filter.getSize();
+    UInt nb_facet = f_filter.size();
     //  if (nb_facet == 0) continue;
 
     Array<Real>::const_iterator<Real> sigma_lim_it = sigma_lim.begin();
 
     Matrix<Real> stress_tmp(spatial_dimension, spatial_dimension);
     Matrix<Real> normal_traction(spatial_dimension, nb_quad_facet);
     Vector<Real> stress_check(nb_quad_facet);
     UInt sp2 = spatial_dimension * spatial_dimension;
 
     const Array<Real> & tangents = model->getTangents(type_facet);
     const Array<Real> & normals =
         model->getFEEngine("FacetsFEEngine")
             .getNormalsOnIntegrationPoints(type_facet);
     Array<Real>::const_vector_iterator normal_begin =
         normals.begin(spatial_dimension);
     Array<Real>::const_vector_iterator tangent_begin =
         tangents.begin(tangents.getNbComponent());
     Array<Real>::const_matrix_iterator facet_stress_begin =
         f_stress.begin(spatial_dimension, spatial_dimension * 2);
 
     std::vector<Real> new_sigmas;
     std::vector<Vector<Real> > new_normal_traction;
     std::vector<Real> new_delta_c;
 
     // loop over each facet belonging to this material
     for (UInt f = 0; f < nb_facet; ++f, ++sigma_lim_it) {
       UInt facet = f_filter(f);
       // skip facets where check shouldn't be realized
       if (!facets_check(facet))
         continue;
 
       // compute the effective norm on each quadrature point of the facet
       for (UInt q = 0; q < nb_quad_facet; ++q) {
         UInt current_quad = facet * nb_quad_facet + q;
         const Vector<Real> & normal = normal_begin[current_quad];
         const Vector<Real> & tangent = tangent_begin[current_quad];
         const Matrix<Real> & facet_stress_it = facet_stress_begin[current_quad];
 
         // compute average stress on the current quadrature point
         Matrix<Real> stress_1(facet_stress_it.storage(), spatial_dimension,
                               spatial_dimension);
 
         Matrix<Real> stress_2(facet_stress_it.storage() + sp2,
                               spatial_dimension, spatial_dimension);
 
         stress_tmp.copy(stress_1);
         stress_tmp += stress_2;
         stress_tmp /= 2.;
 
         Vector<Real> normal_traction_vec(normal_traction(q));
 
         // compute normal and effective stress
         stress_check(q) = computeEffectiveNorm(stress_tmp, normal, tangent,
                                                normal_traction_vec);
       }
 
       // verify if the effective stress overcomes the threshold
       Real final_stress = stress_check.mean();
       if (max_quad_stress_insertion)
         final_stress = *std::max_element(
             stress_check.storage(), stress_check.storage() + nb_quad_facet);
 
       if (final_stress > (*sigma_lim_it - tolerance)) {
         if (model->isDefaultSolverExplicit()) {
           f_insertion(facet) = true;
 
           if (!check_only) {
             // store the new cohesive material parameters for each quadrature
             // point
             for (UInt q = 0; q < nb_quad_facet; ++q) {
               Real new_sigma = stress_check(q);
               Vector<Real> normal_traction_vec(normal_traction(q));
 
               if (spatial_dimension != 3)
                 normal_traction_vec *= -1.;
 
               new_sigmas.push_back(new_sigma);
               new_normal_traction.push_back(normal_traction_vec);
 
               Real new_delta;
 
               // set delta_c in function of G_c or a given delta_c value
               if (Math::are_float_equal(delta_c, 0.))
                 new_delta = 2 * G_c / new_sigma;
               else
                 new_delta = (*sigma_lim_it) / new_sigma * delta_c;
 
               new_delta_c.push_back(new_delta);
             }
           }
 
         } else {
           Real ratio = final_stress / (*sigma_lim_it);
           if (ratio > max_ratio) {
             ++nn;
             max_ratio = ratio;
             index_f = f;
             index_filter = f_filter(f);
           }
         }
       }
     }
 
     /// Insertion of only 1 cohesive element in case of implicit approach. The
     /// one subjected to the highest stress.
     if (!model->isDefaultSolverExplicit()) {
       StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
       Array<Real> abs_max(comm.getNbProc());
       abs_max(comm.whoAmI()) = max_ratio;
       comm.allGather(abs_max);
 
       auto it =
           std::max_element(abs_max.begin(), abs_max.end());
       Int pos = it - abs_max.begin();
 
       if (pos != comm.whoAmI()) {
         AKANTU_DEBUG_OUT();
         return;
       }
 
       if (nn) {
         f_insertion(index_filter) = true;
 
         if (!check_only) {
           //  Array<Real>::iterator<Matrix<Real> > normal_traction_it =
           //  normal_traction.begin_reinterpret(nb_quad_facet,
           //  spatial_dimension, nb_facet);
           Array<Real>::const_iterator<Real> sigma_lim_it = sigma_lim.begin();
 
           for (UInt q = 0; q < nb_quad_cohesive; ++q) {
 
             Real new_sigma = (sigma_lim_it[index_f]);
             Vector<Real> normal_traction_vec(spatial_dimension, 0.0);
 
             new_sigmas.push_back(new_sigma);
             new_normal_traction.push_back(normal_traction_vec);
 
             Real new_delta;
 
             // set delta_c in function of G_c or a given delta_c value
             if (!Math::are_float_equal(delta_c, 0.))
               new_delta = delta_c;
             else
               new_delta = 2 * G_c / (new_sigma);
 
             new_delta_c.push_back(new_delta);
           }
         }
       }
     }
 
     // update material data for the new elements
-    UInt old_nb_quad_points = sig_c_eff.getSize();
+    UInt old_nb_quad_points = sig_c_eff.size();
     UInt new_nb_quad_points = new_sigmas.size();
     sig_c_eff.resize(old_nb_quad_points + new_nb_quad_points);
     ins_stress.resize(old_nb_quad_points + new_nb_quad_points);
     trac_old.resize(old_nb_quad_points + new_nb_quad_points);
     del_c.resize(old_nb_quad_points + new_nb_quad_points);
     open_prec.resize(old_nb_quad_points + new_nb_quad_points);
     red_penalty.resize(old_nb_quad_points + new_nb_quad_points);
 
     for (UInt q = 0; q < new_nb_quad_points; ++q) {
       sig_c_eff(old_nb_quad_points + q) = new_sigmas[q];
       del_c(old_nb_quad_points + q) = new_delta_c[q];
       red_penalty(old_nb_quad_points + q) = false;
       for (UInt dim = 0; dim < spatial_dimension; ++dim) {
         ins_stress(old_nb_quad_points + q, dim) = new_normal_traction[q](dim);
         trac_old(old_nb_quad_points + q, dim) = new_normal_traction[q](dim);
         open_prec(old_nb_quad_points + q, dim) = 0.;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinear<spatial_dimension>::computeTraction(
     const Array<Real> & normal, ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /// define iterators
   auto traction_it =
       tractions(el_type, ghost_type).begin(spatial_dimension);
 
   auto opening_it =
       opening(el_type, ghost_type).begin(spatial_dimension);
 
   /// opening_prec is the opening of the previous step in the
   /// Newton-Raphson loop
   auto opening_prec_it =
       opening_prec(el_type, ghost_type).begin(spatial_dimension);
 
   auto contact_traction_it =
       contact_tractions(el_type, ghost_type).begin(spatial_dimension);
 
   auto contact_opening_it =
       contact_opening(el_type, ghost_type).begin(spatial_dimension);
 
   auto normal_it =
       normal.begin(spatial_dimension);
 
   auto traction_end =
       tractions(el_type, ghost_type).end(spatial_dimension);
 
   auto sigma_c_it =
       sigma_c_eff(el_type, ghost_type).begin();
 
   auto delta_max_it =
       delta_max(el_type, ghost_type).begin();
 
   auto delta_max_prev_it =
       delta_max.previous(el_type, ghost_type).begin();
 
   auto delta_c_it =
       delta_c_eff(el_type, ghost_type).begin();
 
   auto damage_it = damage(el_type, ghost_type).begin();
 
   auto insertion_stress_it =
       insertion_stress(el_type, ghost_type).begin(spatial_dimension);
 
   auto reduction_penalty_it =
       reduction_penalty(el_type, ghost_type).begin();
 
   Vector<Real> normal_opening(spatial_dimension);
   Vector<Real> tangential_opening(spatial_dimension);
 
   if (!this->model->isDefaultSolverExplicit())
     this->delta_max(el_type, ghost_type)
         .copy(this->delta_max.previous(el_type, ghost_type));
 
   /// loop on each quadrature point
   for (; traction_it != traction_end;
        ++traction_it, ++opening_it, ++opening_prec_it, ++normal_it,
        ++sigma_c_it, ++delta_max_it, ++delta_c_it, ++damage_it,
        ++contact_traction_it, ++insertion_stress_it, ++contact_opening_it,
        ++delta_max_prev_it, ++reduction_penalty_it) {
 
     Real normal_opening_norm, tangential_opening_norm;
     bool penetration;
     Real current_penalty = 0.;
     this->computeTractionOnQuad(
         *traction_it, *delta_max_it, *delta_max_prev_it, *delta_c_it,
         *insertion_stress_it, *sigma_c_it, *opening_it, *opening_prec_it,
         *normal_it, normal_opening, tangential_opening, normal_opening_norm,
         tangential_opening_norm, *damage_it, penetration, *reduction_penalty_it,
         current_penalty, *contact_traction_it, *contact_opening_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinear<spatial_dimension>::checkDeltaMax(
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /**
   * This function set a predefined value to the parameter
   * delta_max_prev of the elements that have been inserted in the
   * last loading step for which convergence has not been
   * reached. This is done before reducing the loading and re-doing
   * the step.  Otherwise, the updating of delta_max_prev would be
   * done with reference to the non-convergent solution. In this
   * function also other variables related to the contact and
   * friction behavior are correctly set.
   */
 
   Mesh & mesh = fem_cohesive->getMesh();
   Mesh::type_iterator it =
       mesh.firstType(spatial_dimension, ghost_type, _ek_cohesive);
   Mesh::type_iterator last_type =
       mesh.lastType(spatial_dimension, ghost_type, _ek_cohesive);
 
   /**
   * the variable "recompute" is set to true to activate the
   * procedure that reduce the penalty parameter for
   * compression. This procedure is set true only during the phase of
   * load_reduction, that has to be set in the maiin file. The
   * penalty parameter will be reduced only for the elements having
   * reduction_penalty = true.
   */
   recompute = true;
 
   for (; it != last_type; ++it) {
     Array<UInt> & elem_filter = element_filter(*it, ghost_type);
 
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     if (nb_element == 0)
       continue;
 
     ElementType el_type = *it;
 
     /// define iterators
     auto delta_max_it =
         delta_max(el_type, ghost_type).begin();
 
     auto delta_max_end =
         delta_max(el_type, ghost_type).end();
 
     auto delta_max_prev_it =
         delta_max.previous(el_type, ghost_type).begin();
 
     auto delta_c_it =
         delta_c_eff(el_type, ghost_type).begin();
 
     auto opening_prec_it =
         opening_prec(el_type, ghost_type).begin(spatial_dimension);
 
     auto opening_prec_prev_it =
         opening_prec.previous(el_type, ghost_type).begin(spatial_dimension);
 
     /// loop on each quadrature point
     for (; delta_max_it != delta_max_end; ++delta_max_it, ++delta_max_prev_it,
                                           ++delta_c_it, ++opening_prec_it,
                                           ++opening_prec_prev_it) {
 
       if (*delta_max_prev_it == 0)
         /// elements inserted in the last incremental step, that did
         /// not converge
         *delta_max_it = *delta_c_it / 1000;
       else
         /// elements introduced in previous incremental steps, for
         /// which a correct value of delta_max_prev already exists
         *delta_max_it = *delta_max_prev_it;
 
       /// in case convergence is not reached, set opening_prec to the
       /// value referred to the previous incremental step
       *opening_prec_it = *opening_prec_prev_it;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinear<spatial_dimension>::resetVariables(
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /**
   * This function set the variables "recompute" and
   * "reduction_penalty" to false. It is called by solveStepCohesive
   * when convergence is reached. Such variables, in fact, have to be
   * false at the beginning of a new incremental step.
   */
 
   Mesh & mesh = fem_cohesive->getMesh();
   Mesh::type_iterator it =
       mesh.firstType(spatial_dimension, ghost_type, _ek_cohesive);
   Mesh::type_iterator last_type =
       mesh.lastType(spatial_dimension, ghost_type, _ek_cohesive);
 
   recompute = false;
 
   for (; it != last_type; ++it) {
     Array<UInt> & elem_filter = element_filter(*it, ghost_type);
 
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     if (nb_element == 0)
       continue;
 
     ElementType el_type = *it;
 
     auto reduction_penalty_it =
         reduction_penalty(el_type, ghost_type).begin();
 
     auto reduction_penalty_end =
         reduction_penalty(el_type, ghost_type).end();
 
     /// loop on each quadrature point
     for (; reduction_penalty_it != reduction_penalty_end;
          ++reduction_penalty_it) {
 
       *reduction_penalty_it = false;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinear<spatial_dimension>::computeTangentTraction(
     const ElementType & el_type, Array<Real> & tangent_matrix,
     const Array<Real> & normal, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /// define iterators
   auto tangent_it =
       tangent_matrix.begin(spatial_dimension, spatial_dimension);
 
   auto tangent_end =
       tangent_matrix.end(spatial_dimension, spatial_dimension);
 
   auto normal_it =
       normal.begin(spatial_dimension);
 
   auto opening_it =
       opening(el_type, ghost_type).begin(spatial_dimension);
 
   /// NB: delta_max_it points on delta_max_previous, i.e. the
   /// delta_max related to the solution of the previous incremental
   /// step
   auto delta_max_it =
       delta_max.previous(el_type, ghost_type).begin();
 
   auto sigma_c_it =
       sigma_c_eff(el_type, ghost_type).begin();
 
   auto delta_c_it =
       delta_c_eff(el_type, ghost_type).begin();
 
   auto damage_it = damage(el_type, ghost_type).begin();
 
   auto contact_opening_it =
       contact_opening(el_type, ghost_type).begin(spatial_dimension);
 
   auto reduction_penalty_it =
       reduction_penalty(el_type, ghost_type).begin();
 
   Vector<Real> normal_opening(spatial_dimension);
   Vector<Real> tangential_opening(spatial_dimension);
 
   for (; tangent_it != tangent_end; ++tangent_it, ++normal_it, ++opening_it,
                                     ++delta_max_it, ++sigma_c_it, ++delta_c_it,
                                     ++damage_it, ++contact_opening_it,
                                     ++reduction_penalty_it) {
 
     Real normal_opening_norm, tangential_opening_norm;
     bool penetration;
     Real current_penalty = 0.;
     this->computeTangentTractionOnQuad(
         *tangent_it, *delta_max_it, *delta_c_it, *sigma_c_it, *opening_it,
         *normal_it, normal_opening, tangential_opening, normal_opening_norm,
         tangential_opening_norm, *damage_it, penetration, *reduction_penalty_it,
         current_penalty, *contact_opening_it);
 
     // check if the tangential stiffness matrix is symmetric
     //    for (UInt h = 0; h < spatial_dimension; ++h){
     //      for (UInt l = h; l < spatial_dimension; ++l){
     //        if (l > h){
     //          Real k_ls = (*tangent_it)[spatial_dimension*h+l];
     //          Real k_us =  (*tangent_it)[spatial_dimension*l+h];
     //          //          std::cout << "k_ls = " << k_ls << std::endl;
     //          //          std::cout << "k_us = " << k_us << std::endl;
     //          if (std::abs(k_ls) > 1e-13 && std::abs(k_us) > 1e-13){
     //            Real error = std::abs((k_ls - k_us) / k_us);
     //            if (error > 1e-10){
     //	      std::cout << "non symmetric cohesive matrix" << std::endl;
     //	      //  std::cout << "error " << error << std::endl;
     //            }
     //          }
     //        }
     //      }
     //    }
   }
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(cohesive_linear, MaterialCohesiveLinear);
 
 } // akantu
diff --git a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_friction.cc b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_friction.cc
index c21e2ff4b..7725cbd89 100644
--- a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_friction.cc
+++ b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_friction.cc
@@ -1,386 +1,386 @@
 /**
  * @file   material_cohesive_linear_friction.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Tue Jan 12 2016
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Linear irreversible cohesive law of mixed mode loading with
  * random stress definition for extrinsic type
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material_cohesive_linear_friction.hh"
 #include "solid_mechanics_model_cohesive.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 MaterialCohesiveLinearFriction<spatial_dimension>::
     MaterialCohesiveLinearFriction(SolidMechanicsModel & model, const ID & id)
     : MaterialParent(model, id), residual_sliding("residual_sliding", *this),
       friction_force("friction_force", *this) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("mu", mu_max, Real(0.), _pat_parsable | _pat_readable,
                       "Maximum value of the friction coefficient");
 
   this->registerParam("penalty_for_friction", friction_penalty, Real(0.),
                       _pat_parsable | _pat_readable,
                       "Penalty parameter for the friction behavior");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearFriction<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   MaterialParent::initMaterial();
 
   friction_force.initialize(spatial_dimension);
   residual_sliding.initialize(1);
   residual_sliding.initializeHistory();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearFriction<spatial_dimension>::computeTraction(
     __attribute__((unused)) const Array<Real> & normal, ElementType el_type,
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   residual_sliding.resize();
   friction_force.resize();
 
   /// define iterators
   Array<Real>::vector_iterator traction_it =
       this->tractions(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator traction_end =
       this->tractions(el_type, ghost_type).end(spatial_dimension);
 
   Array<Real>::vector_iterator opening_it =
       this->opening(el_type, ghost_type).begin(spatial_dimension);
 
   /// opening_prec is the opening at the end of the previous step in
   /// the Newton-Raphson loop
   Array<Real>::vector_iterator opening_prec_it =
       this->opening_prec(el_type, ghost_type).begin(spatial_dimension);
 
   /// opening_prec_prev is the opening (opening + penetration)
   /// referred to the convergence of the previous incremental step
   Array<Real>::vector_iterator opening_prec_prev_it =
       this->opening_prec.previous(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator contact_traction_it =
       this->contact_tractions(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator contact_opening_it =
       this->contact_opening(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::const_iterator<Vector<Real>> normal_it =
       this->normal.begin(spatial_dimension);
 
   Array<Real>::iterator<Real> sigma_c_it =
       this->sigma_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> delta_max_it =
       this->delta_max(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> delta_max_prev_it =
       this->delta_max.previous(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> delta_c_it =
       this->delta_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> damage_it =
       this->damage(el_type, ghost_type).begin();
 
   Array<Real>::vector_iterator insertion_stress_it =
       this->insertion_stress(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::iterator<Real> res_sliding_it =
       this->residual_sliding(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> res_sliding_prev_it =
       this->residual_sliding.previous(el_type, ghost_type).begin();
 
   Array<Real>::vector_iterator friction_force_it =
       this->friction_force(el_type, ghost_type).begin(spatial_dimension);
 
   Array<bool>::iterator<bool> reduction_penalty_it =
       this->reduction_penalty(el_type, ghost_type).begin();
 
   Vector<Real> normal_opening(spatial_dimension);
   Vector<Real> tangential_opening(spatial_dimension);
 
   if (!this->model->isDefaultSolverExplicit())
     this->delta_max(el_type, ghost_type)
         .copy(this->delta_max.previous(el_type, ghost_type));
 
   /// loop on each quadrature point
   for (; traction_it != traction_end;
        ++traction_it, ++opening_it, ++opening_prec_prev_it, ++opening_prec_it,
        ++normal_it, ++sigma_c_it, ++delta_max_it, ++delta_c_it, ++damage_it,
        ++contact_traction_it, ++insertion_stress_it, ++contact_opening_it,
        ++delta_max_prev_it, ++res_sliding_it, ++res_sliding_prev_it,
        ++friction_force_it, ++reduction_penalty_it) {
 
     Real normal_opening_norm, tangential_opening_norm;
     bool penetration;
     Real current_penalty = 0.;
     this->computeTractionOnQuad(
         *traction_it, *delta_max_it, *delta_max_prev_it, *delta_c_it,
         *insertion_stress_it, *sigma_c_it, *opening_it, *opening_prec_it,
         *normal_it, normal_opening, tangential_opening, normal_opening_norm,
         tangential_opening_norm, *damage_it, penetration, *reduction_penalty_it,
         current_penalty, *contact_traction_it, *contact_opening_it);
 
     if (penetration) {
 
       /// the friction coefficient mu increases with the damage. It
       /// equals the maximum value when damage = 1.
       //      Real damage = std::min(*delta_max_prev_it / *delta_c_it,
       //      Real(1.));
       Real mu = mu_max; // * damage;
 
       /// the definition of tau_max refers to the opening
       /// (penetration) of the previous incremental step
       Real normal_opening_prev_norm =
           std::min(opening_prec_prev_it->dot(*normal_it), Real(0.));
 
       //      Vector<Real> normal_opening_prev = (*normal_it);
       //      normal_opening_prev *= normal_opening_prev_norm;
 
       Real tau_max =
           mu * current_penalty * (std::abs(normal_opening_prev_norm));
       Real delta_sliding_norm =
           std::abs(tangential_opening_norm - *res_sliding_prev_it);
 
       /// tau is the norm of the friction force, acting tangentially to the
       /// surface
       Real tau = std::min(friction_penalty * delta_sliding_norm, tau_max);
 
       if ((tangential_opening_norm - *res_sliding_prev_it) < 0.0)
         tau = -tau;
 
       /// from tau get the x and y components of friction, to be added in the
       /// force vector
       Vector<Real> tangent_unit_vector(spatial_dimension);
       tangent_unit_vector = tangential_opening / tangential_opening_norm;
       *friction_force_it = tau * tangent_unit_vector;
 
       /// update residual_sliding
       *res_sliding_it =
           tangential_opening_norm - (std::abs(tau) / friction_penalty);
 
     } else {
 
       friction_force_it->clear();
     }
 
     *traction_it += *friction_force_it;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearFriction<spatial_dimension>::checkDeltaMax(
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MaterialParent::checkDeltaMax();
 
   Mesh & mesh = this->fem_cohesive->getMesh();
   Mesh::type_iterator it =
       mesh.firstType(spatial_dimension, ghost_type, _ek_cohesive);
   Mesh::type_iterator last_type =
       mesh.lastType(spatial_dimension, ghost_type, _ek_cohesive);
 
   for (; it != last_type; ++it) {
     Array<UInt> & elem_filter = this->element_filter(*it, ghost_type);
 
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     if (nb_element == 0)
       continue;
 
     ElementType el_type = *it;
 
     /// define iterators
     Array<Real>::iterator<Real> delta_max_it =
         this->delta_max(el_type, ghost_type).begin();
 
     Array<Real>::iterator<Real> delta_max_end =
         this->delta_max(el_type, ghost_type).end();
 
     Array<Real>::iterator<Real> res_sliding_it =
         this->residual_sliding(el_type, ghost_type).begin();
 
     Array<Real>::iterator<Real> res_sliding_prev_it =
         this->residual_sliding.previous(el_type, ghost_type).begin();
 
     /// loop on each quadrature point
     for (; delta_max_it != delta_max_end;
          ++delta_max_it, ++res_sliding_it, ++res_sliding_prev_it) {
 
       /**
        * in case convergence is not reached, set "residual_sliding"
        * for the friction behaviour to the value referred to the
        * previous incremental step
        */
       *res_sliding_it = *res_sliding_prev_it;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearFriction<spatial_dimension>::computeTangentTraction(
     const ElementType & el_type, Array<Real> & tangent_matrix,
     __attribute__((unused)) const Array<Real> & normal, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /// define iterators
   Array<Real>::matrix_iterator tangent_it =
       tangent_matrix.begin(spatial_dimension, spatial_dimension);
 
   Array<Real>::matrix_iterator tangent_end =
       tangent_matrix.end(spatial_dimension, spatial_dimension);
 
   Array<Real>::const_vector_iterator normal_it =
       this->normal.begin(spatial_dimension);
 
   Array<Real>::vector_iterator opening_it =
       this->opening(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator opening_prec_prev_it =
       this->opening_prec.previous(el_type, ghost_type).begin(spatial_dimension);
 
   /**
    * NB: delta_max_it points on delta_max_previous, i.e. the
    * delta_max related to the solution of the previous incremental
    * step
    */
   Array<Real>::iterator<Real> delta_max_it =
       this->delta_max.previous(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> sigma_c_it =
       this->sigma_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> delta_c_it =
       this->delta_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Real> damage_it =
       this->damage(el_type, ghost_type).begin();
 
   Array<Real>::iterator<Vector<Real>> contact_opening_it =
       this->contact_opening(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::iterator<Real> res_sliding_prev_it =
       this->residual_sliding.previous(el_type, ghost_type).begin();
 
   Array<bool>::iterator<bool> reduction_penalty_it =
       this->reduction_penalty(el_type, ghost_type).begin();
 
   Vector<Real> normal_opening(spatial_dimension);
   Vector<Real> tangential_opening(spatial_dimension);
 
   for (; tangent_it != tangent_end;
        ++tangent_it, ++normal_it, ++opening_it, ++opening_prec_prev_it,
        ++delta_max_it, ++sigma_c_it, ++delta_c_it, ++damage_it,
        ++contact_opening_it, ++res_sliding_prev_it, ++reduction_penalty_it) {
 
     Real normal_opening_norm, tangential_opening_norm;
     bool penetration;
     Real current_penalty = 0.;
     this->computeTangentTractionOnQuad(
         *tangent_it, *delta_max_it, *delta_c_it, *sigma_c_it, *opening_it,
         *normal_it, normal_opening, tangential_opening, normal_opening_norm,
         tangential_opening_norm, *damage_it, penetration, *reduction_penalty_it,
         current_penalty, *contact_opening_it);
 
     if (penetration) {
       //      Real damage = std::min(*delta_max_it / *delta_c_it, Real(1.));
       Real mu = mu_max; // * damage;
 
       Real normal_opening_prev_norm =
           std::min(opening_prec_prev_it->dot(*normal_it), Real(0.));
       //      Vector<Real> normal_opening_prev = (*normal_it);
       //      normal_opening_prev *= normal_opening_prev_norm;
 
       Real tau_max =
           mu * current_penalty * (std::abs(normal_opening_prev_norm));
       Real delta_sliding_norm =
           std::abs(tangential_opening_norm - *res_sliding_prev_it);
 
       // tau is the norm of the friction force, acting tangentially to the
       // surface
       Real tau = std::min(friction_penalty * delta_sliding_norm, tau_max);
 
       if (tau < tau_max && tau_max > Math::getTolerance()) {
         Matrix<Real> I(spatial_dimension, spatial_dimension);
         I.eye(1.);
 
         Matrix<Real> n_outer_n(spatial_dimension, spatial_dimension);
         n_outer_n.outerProduct(*normal_it, *normal_it);
 
         Matrix<Real> nn(n_outer_n);
         I -= nn;
         *tangent_it += I * friction_penalty;
       }
     }
 
     // check if the tangential stiffness matrix is symmetric
     //    for (UInt h = 0; h < spatial_dimension; ++h){
     //      for (UInt l = h; l < spatial_dimension; ++l){
     //        if (l > h){
     //          Real k_ls = (*tangent_it)[spatial_dimension*h+l];
     //          Real k_us =  (*tangent_it)[spatial_dimension*l+h];
     //          //          std::cout << "k_ls = " << k_ls << std::endl;
     //          //          std::cout << "k_us = " << k_us << std::endl;
     //          if (std::abs(k_ls) > 1e-13 && std::abs(k_us) > 1e-13){
     //            Real error = std::abs((k_ls - k_us) / k_us);
     //            if (error > 1e-10){
     //	      std::cout << "non symmetric cohesive matrix" << std::endl;
     //	      //  std::cout << "error " << error << std::endl;
     //            }
     //          }
     //        }
     //      }
     //    }
   }
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(cohesive_linear_friction, MaterialCohesiveLinearFriction);
 
 } // akantu
diff --git a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_uncoupled.cc b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_uncoupled.cc
index aba88eece..611a8f00e 100644
--- a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_uncoupled.cc
+++ b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_linear_uncoupled.cc
@@ -1,596 +1,596 @@
 /**
  * @file   material_cohesive_linear_uncoupled.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Wed Feb 22 2012
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Linear irreversible cohesive law of mixed mode loading with
  * random stress definition for extrinsic type
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <numeric>
 
 /* -------------------------------------------------------------------------- */
 #include "material_cohesive_linear_uncoupled.hh"
 #include "solid_mechanics_model_cohesive.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 MaterialCohesiveLinearUncoupled<spatial_dimension>::
     MaterialCohesiveLinearUncoupled(SolidMechanicsModel & model, const ID & id)
     : MaterialCohesiveLinear<spatial_dimension>(model, id),
       delta_n_max("delta_n_max", *this), delta_t_max("delta_t_max", *this),
       damage_n("damage_n", *this), damage_t("damage_t", *this) {
 
   AKANTU_DEBUG_IN();
 
   this->registerParam(
       "roughness", R, Real(1.), _pat_parsable | _pat_readable,
       "Roughness to define coupling between mode II and mode I");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearUncoupled<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   MaterialCohesiveLinear<spatial_dimension>::initMaterial();
 
   delta_n_max.initialize(1);
   delta_t_max.initialize(1);
   damage_n.initialize(1);
   damage_t.initialize(1);
 
   delta_n_max.initializeHistory();
   delta_t_max.initializeHistory();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearUncoupled<spatial_dimension>::computeTraction(
     const Array<Real> &, ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   delta_n_max.resize();
   delta_t_max.resize();
   damage_n.resize();
   damage_t.resize();
 
   /// define iterators
   Array<Real>::vector_iterator traction_it =
       this->tractions(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator traction_end =
       this->tractions(el_type, ghost_type).end(spatial_dimension);
 
   Array<Real>::vector_iterator opening_it =
       this->opening(el_type, ghost_type).begin(spatial_dimension);
 
   /// opening_prec is the opening of the previous step in the
   /// Newton-Raphson loop
   Array<Real>::vector_iterator opening_prec_it =
       this->opening_prec(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator contact_traction_it =
       this->contact_tractions(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::vector_iterator contact_opening_it =
       this->contact_opening(el_type, ghost_type).begin(spatial_dimension);
 
   Array<Real>::const_vector_iterator normal_it =
       this->normal.begin(spatial_dimension);
 
   Array<Real>::scalar_iterator sigma_c_it =
       this->sigma_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator delta_n_max_it =
       delta_n_max(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator delta_t_max_it =
       delta_t_max(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator delta_c_it =
       this->delta_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator damage_n_it =
       damage_n(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator damage_t_it =
       damage_t(el_type, ghost_type).begin();
 
   Array<Real>::vector_iterator insertion_stress_it =
       this->insertion_stress(el_type, ghost_type).begin(spatial_dimension);
 
   Array<bool>::scalar_iterator reduction_penalty_it =
       this->reduction_penalty(el_type, ghost_type).begin();
 
   Vector<Real> normal_opening(spatial_dimension);
   Vector<Real> tangential_opening(spatial_dimension);
 
   if (!this->model->isDefaultSolverExplicit()) {
     this->delta_n_max(el_type, ghost_type)
         .copy(this->delta_n_max.previous(el_type, ghost_type));
     this->delta_t_max(el_type, ghost_type)
         .copy(this->delta_t_max.previous(el_type, ghost_type));
   }
 
   /// loop on each quadrature point
   for (; traction_it != traction_end;
        ++traction_it, ++opening_it, ++opening_prec_it, ++contact_traction_it,
        ++contact_opening_it, ++normal_it, ++sigma_c_it, ++delta_n_max_it,
        ++delta_t_max_it, ++delta_c_it, ++damage_n_it, ++damage_t_it,
        ++insertion_stress_it, ++reduction_penalty_it) {
 
     Real normal_opening_norm, tangential_opening_norm;
     bool penetration;
     Real current_penalty = 0.;
     Real delta_c2_R2 = *delta_c_it * (*delta_c_it) / R / R;
 
     /// compute normal and tangential opening vectors
     normal_opening_norm = opening_it->dot(*normal_it);
     Vector<Real> normal_opening = *normal_it;
     normal_opening *= normal_opening_norm;
 
     //    std::cout<< "normal_opening_norm = " << normal_opening_norm
     //    <<std::endl;
 
     Vector<Real> tangential_opening = *opening_it;
     tangential_opening -= normal_opening;
     tangential_opening_norm = tangential_opening.norm();
 
     /// compute effective opening displacement
     Real delta_n =
         tangential_opening_norm * tangential_opening_norm * this->beta2_kappa2;
     Real delta_t =
         tangential_opening_norm * tangential_opening_norm * this->beta2_kappa2;
 
     penetration = normal_opening_norm < 0.0;
     if (this->contact_after_breaking == false &&
         Math::are_float_equal(*damage_n_it, 1.))
       penetration = false;
 
     /**
      * If during the convergence loop a cohesive element continues to
      * jumps from penetration to opening, and convergence is not
      * reached, its penalty parameter will be reduced in the
      * recomputation of the same incremental step. Recompute is set
      * equal to true when convergence is not reached in the
      * solveStepCohesive function and the execution of the program
      * goes back to the main file where the variable load_reduction
      * is set equal to true.
      */
     Real normal_opening_prec_norm = opening_prec_it->dot(*normal_it);
     //    Vector<Real> normal_opening_prec  = *normal_it;
     //    normal_opening_prec *= normal_opening_prec_norm;
     if (!this->model->isDefaultSolverExplicit()) // && !this->recompute)
       if ((normal_opening_prec_norm * normal_opening_norm) < 0.0)
         *reduction_penalty_it = true;
 
     *opening_prec_it = *opening_it;
 
     if (penetration) {
       if (this->recompute && *reduction_penalty_it) {
         /// the penalty parameter is locally reduced
         current_penalty = this->penalty / 100.;
       } else
         current_penalty = this->penalty;
 
       /// use penalty coefficient in case of penetration
       *contact_traction_it = normal_opening;
       *contact_traction_it *= current_penalty;
       *contact_opening_it = normal_opening;
 
       /// don't consider penetration contribution for delta
       *opening_it = tangential_opening;
       normal_opening.clear();
 
     } else {
       delta_n += normal_opening_norm * normal_opening_norm;
       delta_t += normal_opening_norm * normal_opening_norm * delta_c2_R2;
       contact_traction_it->clear();
       contact_opening_it->clear();
     }
 
     delta_n = std::sqrt(delta_n);
     delta_t = std::sqrt(delta_t);
 
     /// update maximum displacement and damage
     *delta_n_max_it = std::max(*delta_n_max_it, delta_n);
     *damage_n_it = std::min(*delta_n_max_it / *delta_c_it, Real(1.));
 
     *delta_t_max_it = std::max(*delta_t_max_it, delta_t);
     *damage_t_it = std::min(*delta_t_max_it / *delta_c_it, Real(1.));
 
     Vector<Real> normal_traction(spatial_dimension);
     Vector<Real> shear_traction(spatial_dimension);
 
     /// NORMAL TRACTIONS
     if (Math::are_float_equal(*damage_n_it, 1.))
       normal_traction.clear();
     else if (Math::are_float_equal(*damage_n_it, 0.)) {
       if (penetration)
         normal_traction.clear();
       else
         normal_traction = *insertion_stress_it;
     } else {
       // the following formulation holds both in loading and in
       // unloading-reloading
       normal_traction = normal_opening;
 
       AKANTU_DEBUG_ASSERT(*delta_n_max_it != 0.,
                           "Division by zero, tolerance might be too low");
 
       normal_traction *= *sigma_c_it / (*delta_n_max_it) * (1. - *damage_n_it);
     }
 
     /// SHEAR TRACTIONS
     if (Math::are_float_equal(*damage_t_it, 1.))
       shear_traction.clear();
     else if (Math::are_float_equal(*damage_t_it, 0.)) {
       shear_traction.clear();
     } else {
       shear_traction = tangential_opening;
 
       AKANTU_DEBUG_ASSERT(*delta_t_max_it != 0.,
                           "Division by zero, tolerance might be too low");
 
       shear_traction *= this->beta2_kappa;
       shear_traction *= *sigma_c_it / (*delta_t_max_it) * (1. - *damage_t_it);
     }
 
     *traction_it = normal_traction;
     *traction_it += shear_traction;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearUncoupled<spatial_dimension>::checkDeltaMax(
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /**
    * This function set a predefined value to the parameter
    * delta_max_prev of the elements that have been inserted in the
    * last loading step for which convergence has not been
    * reached. This is done before reducing the loading and re-doing
    * the step.  Otherwise, the updating of delta_max_prev would be
    * done with reference to the non-convergent solution. In this
    * function also other variables related to the contact and
    * friction behavior are correctly set.
    */
 
   Mesh & mesh = this->fem_cohesive->getMesh();
   Mesh::type_iterator it =
       mesh.firstType(spatial_dimension, ghost_type, _ek_cohesive);
   Mesh::type_iterator last_type =
       mesh.lastType(spatial_dimension, ghost_type, _ek_cohesive);
 
   /**
    * the variable "recompute" is set to true to activate the
    * procedure that reduces the penalty parameter for
    * compression. This procedure is available only during the phase of
    * load_reduction, that has to be set in the main file. The
    * penalty parameter will be reduced only for the elements having
    * reduction_penalty = true.
    */
   this->recompute = true;
 
   for (; it != last_type; ++it) {
     Array<UInt> & elem_filter = this->element_filter(*it, ghost_type);
 
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     if (nb_element == 0)
       continue;
 
     ElementType el_type = *it;
 
     //    std::cout << "element type: " << el_type << std::endl;
 
     /// define iterators
     Array<Real>::scalar_iterator delta_n_max_it =
         delta_n_max(el_type, ghost_type).begin();
 
     Array<Real>::scalar_iterator delta_n_max_end =
         delta_n_max(el_type, ghost_type).end();
 
     Array<Real>::scalar_iterator delta_n_max_prev_it =
         delta_n_max.previous(el_type, ghost_type).begin();
 
     Array<Real>::scalar_iterator delta_t_max_it =
         delta_t_max(el_type, ghost_type).begin();
 
     Array<Real>::scalar_iterator delta_t_max_prev_it =
         delta_t_max.previous(el_type, ghost_type).begin();
 
     Array<Real>::scalar_iterator delta_c_it =
         this->delta_c_eff(el_type, ghost_type).begin();
 
     Array<Real>::vector_iterator opening_prec_it =
         this->opening_prec(el_type, ghost_type).begin(spatial_dimension);
 
     Array<Real>::vector_iterator opening_prec_prev_it =
         this->opening_prec.previous(el_type, ghost_type)
             .begin(spatial_dimension);
 
     Int it = 0;
 
     /// loop on each quadrature point
     for (; delta_n_max_it != delta_n_max_end;
          ++delta_n_max_it, ++delta_t_max_it, ++delta_c_it,
          ++delta_n_max_prev_it, ++delta_t_max_prev_it, ++opening_prec_it,
          ++opening_prec_prev_it) {
 
       ++it;
 
       if (*delta_n_max_prev_it == 0) {
         /// elements inserted in the last incremental step, that did
         /// not converge
         *delta_n_max_it = *delta_c_it / 1000.;
       } else
         /// elements introduced in previous incremental steps, for
         /// which a correct value of delta_max_prev already exists
         *delta_n_max_it = *delta_n_max_prev_it;
 
       if (*delta_t_max_prev_it == 0) {
         *delta_t_max_it = *delta_c_it * this->kappa / this->beta / 1000.;
       } else
         *delta_t_max_it = *delta_t_max_prev_it;
 
       /// in case convergence is not reached, set opening_prec to the
       /// value referred to the previous incremental step
       *opening_prec_it = *opening_prec_prev_it;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveLinearUncoupled<spatial_dimension>::computeTangentTraction(
     const ElementType & el_type, Array<Real> & tangent_matrix,
     const Array<Real> &, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   /// define iterators
   Array<Real>::matrix_iterator tangent_it =
       tangent_matrix.begin(spatial_dimension, spatial_dimension);
 
   Array<Real>::matrix_iterator tangent_end =
       tangent_matrix.end(spatial_dimension, spatial_dimension);
 
   Array<Real>::const_vector_iterator normal_it =
       this->normal.begin(spatial_dimension);
 
   Array<Real>::vector_iterator opening_it =
       this->opening(el_type, ghost_type).begin(spatial_dimension);
 
   /// NB: delta_max_it points on delta_max_previous, i.e. the
   /// delta_max related to the solution of the previous incremental
   /// step
   Array<Real>::scalar_iterator delta_n_max_it =
       delta_n_max.previous(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator delta_t_max_it =
       delta_t_max.previous(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator sigma_c_it =
       this->sigma_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator delta_c_it =
       this->delta_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator damage_n_it =
       damage_n(el_type, ghost_type).begin();
 
   Array<Real>::vector_iterator contact_opening_it =
       this->contact_opening(el_type, ghost_type).begin(spatial_dimension);
 
   Array<bool>::scalar_iterator reduction_penalty_it =
       this->reduction_penalty(el_type, ghost_type).begin();
 
   Vector<Real> normal_opening(spatial_dimension);
   Vector<Real> tangential_opening(spatial_dimension);
 
   for (; tangent_it != tangent_end;
        ++tangent_it, ++normal_it, ++opening_it, ++sigma_c_it, ++delta_c_it,
        ++delta_n_max_it, ++delta_t_max_it, ++damage_n_it, ++contact_opening_it,
        ++reduction_penalty_it) {
 
     Real normal_opening_norm, tangential_opening_norm;
     bool penetration;
     Real current_penalty = 0.;
     Real delta_c2_R2 = *delta_c_it * (*delta_c_it) / R / R;
 
     /**
      * During the update of the residual the interpenetrations are
      * stored in the array "contact_opening", therefore, in the case
      * of penetration, in the array "opening" there are only the
      * tangential components.
      */
     *opening_it += *contact_opening_it;
 
     /// compute normal and tangential opening vectors
     normal_opening_norm = opening_it->dot(*normal_it);
     Vector<Real> normal_opening = *normal_it;
     normal_opening *= normal_opening_norm;
 
     Vector<Real> tangential_opening = *opening_it;
     tangential_opening -= normal_opening;
     tangential_opening_norm = tangential_opening.norm();
 
     Real delta_n =
         tangential_opening_norm * tangential_opening_norm * this->beta2_kappa2;
     Real delta_t =
         tangential_opening_norm * tangential_opening_norm * this->beta2_kappa2;
 
     penetration = normal_opening_norm < 0.0;
     if (this->contact_after_breaking == false &&
         Math::are_float_equal(*damage_n_it, 1.))
       penetration = false;
 
     Real derivative = 0; // derivative = d(t/delta)/ddelta
     Real T = 0;
 
     /// TANGENT STIFFNESS FOR NORMAL TRACTIONS
     Matrix<Real> n_outer_n(spatial_dimension, spatial_dimension);
     n_outer_n.outerProduct(*normal_it, *normal_it);
 
     if (penetration) {
       if (this->recompute && *reduction_penalty_it)
         current_penalty = this->penalty / 100.;
       else
         current_penalty = this->penalty;
 
       /// stiffness in compression given by the penalty parameter
       *tangent_it = n_outer_n;
       *tangent_it *= current_penalty;
 
       *opening_it = tangential_opening;
       normal_opening.clear();
     } else {
       delta_n += normal_opening_norm * normal_opening_norm;
       delta_n = std::sqrt(delta_n);
 
       delta_t += normal_opening_norm * normal_opening_norm * delta_c2_R2;
 
       /**
        * Delta has to be different from 0 to have finite values of
        * tangential stiffness.  At the element insertion, delta =
        * 0. Therefore, a fictictious value is defined, for the
        * evaluation of the first value of K.
        */
       if (delta_n < Math::getTolerance())
         delta_n = *delta_c_it / 1000.;
 
       // loading
       if (delta_n >= *delta_n_max_it) {
         if (delta_n <= *delta_c_it) {
           derivative = -(*sigma_c_it) / (delta_n * delta_n);
           T = *sigma_c_it * (1 - delta_n / *delta_c_it);
         } else {
           derivative = 0.;
           T = 0.;
         }
         // unloading-reloading
       } else if (delta_n < *delta_n_max_it) {
         Real T_max = *sigma_c_it * (1 - *delta_n_max_it / *delta_c_it);
         derivative = 0.;
         T = T_max / *delta_n_max_it * delta_n;
       }
 
       /// computation of the derivative of the constitutive law (dT/ddelta)
       Matrix<Real> nn(n_outer_n);
       nn *= T / delta_n;
 
       Vector<Real> Delta_tilde(normal_opening);
       Delta_tilde *= (1. - this->beta2_kappa2);
       Vector<Real> mm(*opening_it);
       mm *= this->beta2_kappa2;
       Delta_tilde += mm;
 
       Vector<Real> Delta_hat(normal_opening);
       Matrix<Real> prov(spatial_dimension, spatial_dimension);
       prov.outerProduct(Delta_hat, Delta_tilde);
       prov *= derivative / delta_n;
       prov += nn;
 
       Matrix<Real> prov_t = prov.transpose();
 
       *tangent_it = prov_t;
     }
 
     derivative = 0.;
     T = 0.;
 
     /// TANGENT STIFFNESS FOR SHEAR TRACTIONS
     delta_t = std::sqrt(delta_t);
 
     /**
      * Delta has to be different from 0 to have finite values of
      * tangential stiffness.  At the element insertion, delta =
      * 0. Therefore, a fictictious value is defined, for the
      * evaluation of the first value of K.
      */
     if (delta_t < Math::getTolerance())
       delta_t = *delta_c_it / 1000.;
 
     // loading
     if (delta_t >= *delta_t_max_it) {
       if (delta_t <= *delta_c_it) {
         derivative = -(*sigma_c_it) / (delta_t * delta_t);
         T = *sigma_c_it * (1 - delta_t / *delta_c_it);
       } else {
         derivative = 0.;
         T = 0.;
       }
       // unloading-reloading
     } else if (delta_t < *delta_t_max_it) {
       Real T_max = *sigma_c_it * (1 - *delta_t_max_it / *delta_c_it);
       derivative = 0.;
       T = T_max / *delta_t_max_it * delta_t;
     }
 
     /// computation of the derivative of the constitutive law (dT/ddelta)
     Matrix<Real> I(spatial_dimension, spatial_dimension);
     I.eye();
     Matrix<Real> nn(n_outer_n);
     I -= nn;
     I *= T / delta_t;
 
     Vector<Real> Delta_tilde(normal_opening);
     Delta_tilde *= (delta_c2_R2 - this->beta2_kappa2);
     Vector<Real> mm(*opening_it);
     mm *= this->beta2_kappa2;
     Delta_tilde += mm;
 
     Vector<Real> Delta_hat(tangential_opening);
     Delta_hat *= this->beta2_kappa;
     Matrix<Real> prov(spatial_dimension, spatial_dimension);
     prov.outerProduct(Delta_hat, Delta_tilde);
     prov *= derivative / delta_t;
     prov += I;
 
     Matrix<Real> prov_t = prov.transpose();
 
     *tangent_it += prov_t;
   }
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(cohesive_linear_uncoupled, MaterialCohesiveLinearUncoupled);
 
 } // akantu
diff --git a/src/model/solid_mechanics/materials/material_cohesive/material_cohesive.cc b/src/model/solid_mechanics/materials/material_cohesive/material_cohesive.cc
index 4e86fab39..2dbdcc745 100644
--- a/src/model/solid_mechanics/materials/material_cohesive/material_cohesive.cc
+++ b/src/model/solid_mechanics/materials/material_cohesive/material_cohesive.cc
@@ -1,576 +1,576 @@
 /**
  * @file   material_cohesive.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Seyedeh Mohadeseh Taheri Mousavi <mohadeseh.taherimousavi@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Feb 22 2012
  * @date last modification: Tue Jan 12 2016
  *
  * @brief  Specialization of the material class for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material_cohesive.hh"
 #include "aka_random_generator.hh"
 #include "dof_synchronizer.hh"
 #include "shape_cohesive.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "sparse_matrix.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MaterialCohesive::MaterialCohesive(SolidMechanicsModel & model, const ID & id)
     : Material(model, id),
       facet_filter("facet_filter", id, this->getMemoryID()),
       fem_cohesive(&(
           model.getFEEngineClass<MyFEEngineCohesiveType>("CohesiveFEEngine"))),
       reversible_energy("reversible_energy", *this),
       total_energy("total_energy", *this), opening("opening", *this),
       opening_old("opening (old)", *this), tractions("tractions", *this),
       tractions_old("tractions (old)", *this),
       contact_tractions("contact_tractions", *this),
       contact_opening("contact_opening", *this), delta_max("delta max", *this),
       use_previous_delta_max(false), use_previous_opening(false),
       damage("damage", *this), sigma_c("sigma_c", *this),
       normal(0, spatial_dimension, "normal") {
 
   AKANTU_DEBUG_IN();
 
   this->model = dynamic_cast<SolidMechanicsModelCohesive *>(&model);
 
   this->registerParam("sigma_c", sigma_c, _pat_parsable | _pat_readable,
                       "Critical stress");
   this->registerParam("delta_c", delta_c, Real(0.),
                       _pat_parsable | _pat_readable, "Critical displacement");
 
   this->element_filter.initialize(this->model->getMesh(),
                                   _spatial_dimension = spatial_dimension,
                                   _element_kind = _ek_cohesive);
   // this->model->getMesh().initElementTypeMapArray(
   //     this->element_filter, 1, spatial_dimension, false, _ek_cohesive);
 
   if (this->model->getIsExtrinsic())
     this->facet_filter.initialize(this->model->getMeshFacets(),
                                   _spatial_dimension = spatial_dimension - 1,
                                   _element_kind = _ek_regular);
   // this->model->getMeshFacets().initElementTypeMapArray(facet_filter, 1,
   //                                                      spatial_dimension -
   //                                                      1);
 
   this->reversible_energy.initialize(1);
   this->total_energy.initialize(1);
   this->tractions_old.initialize(spatial_dimension);
   this->tractions.initialize(spatial_dimension);
   this->opening_old.initialize(spatial_dimension);
   this->contact_tractions.initialize(spatial_dimension);
   this->contact_opening.initialize(spatial_dimension);
   this->opening.initialize(spatial_dimension);
   this->delta_max.initialize(1);
   this->damage.initialize(1);
 
   if (this->model->getIsExtrinsic())
     this->sigma_c.initialize(1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MaterialCohesive::~MaterialCohesive() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialCohesive::initMaterial() {
   AKANTU_DEBUG_IN();
   Material::initMaterial();
   if (this->use_previous_delta_max)
     this->delta_max.initializeHistory();
   if (this->use_previous_opening)
     this->opening.initializeHistory();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialCohesive::assembleInternalForces(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_DEBUG_TOOLS)
   debug::element_manager.printData(debug::_dm_material_cohesive,
                                    "Cohesive Tractions", tractions);
 #endif
 
   auto & internal_force = const_cast<Array<Real> &>(model->getInternalForce());
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type,
                                                _ek_cohesive)) {
     auto & elem_filter = element_filter(type, ghost_type);
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     if (nb_element == 0)
       continue;
 
     const auto & shapes = fem_cohesive->getShapes(type, ghost_type);
     auto & traction = tractions(type, ghost_type);
     auto & contact_traction = contact_tractions(type, ghost_type);
 
     UInt size_of_shapes = shapes.getNbComponent();
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     UInt nb_quadrature_points =
         fem_cohesive->getNbIntegrationPoints(type, ghost_type);
 
     /// compute @f$t_i N_a@f$
 
     Array<Real> * traction_cpy = new Array<Real>(
         nb_element * nb_quadrature_points, spatial_dimension * size_of_shapes);
 
     auto traction_it = traction.begin(spatial_dimension, 1);
     auto contact_traction_it = contact_traction.begin(spatial_dimension, 1);
     auto shapes_filtered_begin = shapes.begin(1, size_of_shapes);
     auto traction_cpy_it =
         traction_cpy->begin(spatial_dimension, size_of_shapes);
 
     Matrix<Real> traction_tmp(spatial_dimension, 1);
 
     for (UInt el = 0; el < nb_element; ++el) {
 
       UInt current_quad = elem_filter(el) * nb_quadrature_points;
 
       for (UInt q = 0; q < nb_quadrature_points; ++q, ++traction_it,
                 ++contact_traction_it, ++current_quad, ++traction_cpy_it) {
 
         const Matrix<Real> & shapes_filtered =
             shapes_filtered_begin[current_quad];
 
         traction_tmp.copy(*traction_it);
         traction_tmp += *contact_traction_it;
 
         traction_cpy_it->mul<false, false>(traction_tmp, shapes_filtered);
       }
     }
 
     /**
      * compute @f$\int t \cdot N\, dS@f$ by  @f$ \sum_q \mathbf{N}^t
      * \mathbf{t}_q \overline w_q J_q@f$
      */
     Array<Real> * int_t_N = new Array<Real>(
         nb_element, spatial_dimension * size_of_shapes, "int_t_N");
 
     fem_cohesive->integrate(*traction_cpy, *int_t_N,
                             spatial_dimension * size_of_shapes, type,
                             ghost_type, elem_filter);
 
     delete traction_cpy;
 
     int_t_N->extendComponentsInterlaced(2, int_t_N->getNbComponent());
 
     Real * int_t_N_val = int_t_N->storage();
     for (UInt el = 0; el < nb_element; ++el) {
       for (UInt n = 0; n < size_of_shapes * spatial_dimension; ++n)
         int_t_N_val[n] *= -1.;
       int_t_N_val += nb_nodes_per_element * spatial_dimension;
     }
 
     /// assemble
     model->getDOFManager().assembleElementalArrayLocalArray(
         *int_t_N, internal_force, type, ghost_type, -1, elem_filter);
 
     delete int_t_N;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialCohesive::assembleStiffnessMatrix(GhostType ghost_type) {
 
   AKANTU_DEBUG_IN();
 
   for (auto type : element_filter.elementTypes(spatial_dimension, ghost_type,
                                                _ek_cohesive)) {
     UInt nb_quadrature_points =
         fem_cohesive->getNbIntegrationPoints(type, ghost_type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     const Array<Real> & shapes = fem_cohesive->getShapes(type, ghost_type);
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
 
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
 
     if (!nb_element)
       continue;
 
     UInt size_of_shapes = shapes.getNbComponent();
 
     Array<Real> * shapes_filtered = new Array<Real>(
         nb_element * nb_quadrature_points, size_of_shapes, "filtered shapes");
 
     Real * shapes_val = shapes.storage();
     Real * shapes_filtered_val = shapes_filtered->storage();
     UInt * elem_filter_val = elem_filter.storage();
 
     for (UInt el = 0; el < nb_element; ++el) {
       shapes_val = shapes.storage() +
                    elem_filter_val[el] * size_of_shapes * nb_quadrature_points;
       memcpy(shapes_filtered_val, shapes_val,
              size_of_shapes * nb_quadrature_points * sizeof(Real));
       shapes_filtered_val += size_of_shapes * nb_quadrature_points;
     }
 
     /**
      * compute A matrix @f$ \mathbf{A} = \left[\begin{array}{c c c c c c c c c c
      *c c}
      * 1 & 0 & 0 & 0 & 0 & 0 & -1 &  0 &  0 &  0 &  0 &  0 \\
      * 0 & 1 & 0 & 0 & 0 & 0 &  0 & -1 &  0 &  0 &  0 &  0 \\
      * 0 & 0 & 1 & 0 & 0 & 0 &  0 &  0 & -1 &  0 &  0 &  0 \\
      * 0 & 0 & 0 & 1 & 0 & 0 &  0 &  0 &  0 & -1 &  0 &  0 \\
      * 0 & 0 & 0 & 0 & 1 & 0 &  0 &  0 &  0 &  0 & -1 &  0 \\
      * 0 & 0 & 0 & 0 & 0 & 1 &  0 &  0 &  0 &  0 &  0 & -1
      * \end{array} \right]@f$
      **/
 
     // UInt size_of_A =
     // spatial_dimension*size_of_shapes*spatial_dimension*nb_nodes_per_element;
     // Real * A = new Real[size_of_A];
     // memset(A, 0, size_of_A*sizeof(Real));
     Matrix<Real> A(spatial_dimension * size_of_shapes,
                    spatial_dimension * nb_nodes_per_element);
 
     for (UInt i = 0; i < spatial_dimension * size_of_shapes; ++i) {
       A(i, i) = 1;
       A(i, i + spatial_dimension * size_of_shapes) = -1;
     }
 
     // compute traction. This call is not necessary for the linear
     // cohesive law that, currently, is the only one used for the
     // extrinsic approach.
     //    if (!model->getIsExtrinsic()){
     //  computeTraction(ghost_type);
     //}
 
     /// get the tangent matrix @f$\frac{\partial{(t/\delta)}}{\partial{\delta}}
     /// @f$
     Array<Real> * tangent_stiffness_matrix = new Array<Real>(
         nb_element * nb_quadrature_points,
         spatial_dimension * spatial_dimension, "tangent_stiffness_matrix");
 
     //    Array<Real> * normal = new Array<Real>(nb_element *
     //    nb_quadrature_points, spatial_dimension, "normal");
     normal.resize(nb_quadrature_points);
 
     computeNormal(model->getCurrentPosition(), normal, type, ghost_type);
 
     /// compute openings @f$\mathbf{\delta}@f$
     // computeOpening(model->getDisplacement(), opening(type, ghost_type), type,
     // ghost_type);
 
     tangent_stiffness_matrix->clear();
 
     computeTangentTraction(type, *tangent_stiffness_matrix, normal, ghost_type);
 
     // delete normal;
 
     UInt size_at_nt_d_n_a = spatial_dimension * nb_nodes_per_element *
                             spatial_dimension * nb_nodes_per_element;
     Array<Real> * at_nt_d_n_a = new Array<Real>(
         nb_element * nb_quadrature_points, size_at_nt_d_n_a, "A^t*N^t*D*N*A");
 
     Array<Real>::iterator<Vector<Real>> shapes_filt_it =
         shapes_filtered->begin(size_of_shapes);
 
     Array<Real>::matrix_iterator D_it =
         tangent_stiffness_matrix->begin(spatial_dimension, spatial_dimension);
 
     Array<Real>::matrix_iterator At_Nt_D_N_A_it =
         at_nt_d_n_a->begin(spatial_dimension * nb_nodes_per_element,
                            spatial_dimension * nb_nodes_per_element);
 
     Array<Real>::matrix_iterator At_Nt_D_N_A_end =
         at_nt_d_n_a->end(spatial_dimension * nb_nodes_per_element,
                          spatial_dimension * nb_nodes_per_element);
 
     Matrix<Real> N(spatial_dimension, spatial_dimension * size_of_shapes);
     Matrix<Real> N_A(spatial_dimension,
                      spatial_dimension * nb_nodes_per_element);
     Matrix<Real> D_N_A(spatial_dimension,
                        spatial_dimension * nb_nodes_per_element);
 
     for (; At_Nt_D_N_A_it != At_Nt_D_N_A_end;
          ++At_Nt_D_N_A_it, ++D_it, ++shapes_filt_it) {
       N.clear();
       /**
        * store  the   shapes  in  voigt   notations  matrix  @f$\mathbf{N}  =
        * \begin{array}{cccccc} N_0(\xi) & 0 & N_1(\xi)  &0 & N_2(\xi) & 0 \\
        * 0 & * N_0(\xi)& 0 &N_1(\xi)& 0 & N_2(\xi) \end{array} @f$
        **/
       for (UInt i = 0; i < spatial_dimension; ++i)
         for (UInt n = 0; n < size_of_shapes; ++n)
           N(i, i + spatial_dimension * n) = (*shapes_filt_it)(n);
 
       /**
        * compute stiffness matrix  @f$   \mathbf{K}    =    \delta \mathbf{U}^T
        * \int_{\Gamma_c}    {\mathbf{P}^t \frac{\partial{\mathbf{t}}}
        *{\partial{\delta}}
        * \mathbf{P} d\Gamma \Delta \mathbf{U}}  @f$
        **/
       N_A.mul<false, false>(N, A);
       D_N_A.mul<false, false>(*D_it, N_A);
       (*At_Nt_D_N_A_it).mul<true, false>(D_N_A, N_A);
     }
 
     delete tangent_stiffness_matrix;
     delete shapes_filtered;
 
     Array<Real> * K_e = new Array<Real>(nb_element, size_at_nt_d_n_a, "K_e");
 
     fem_cohesive->integrate(*at_nt_d_n_a, *K_e, size_at_nt_d_n_a, type,
                             ghost_type, elem_filter);
 
     delete at_nt_d_n_a;
 
     model->getDOFManager().assembleElementalMatricesToMatrix(
         "K", "displacement", *K_e, type, ghost_type, _unsymmetric, elem_filter);
 
     delete K_e;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- *
  * Compute traction from displacements
  *
  * @param[in] ghost_type compute the residual for _ghost or _not_ghost element
  */
 void MaterialCohesive::computeTraction(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_DEBUG_TOOLS)
   debug::element_manager.printData(debug::_dm_material_cohesive,
                                    "Cohesive Openings", opening);
 #endif
 
   for (auto & type : element_filter.elementTypes(spatial_dimension, ghost_type,
                                                  _ek_cohesive)) {
     Array<UInt> & elem_filter = element_filter(type, ghost_type);
 
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
     if (nb_element == 0)
       continue;
 
     UInt nb_quadrature_points =
         nb_element * fem_cohesive->getNbIntegrationPoints(type, ghost_type);
 
     normal.resize(nb_quadrature_points);
 
     /// compute normals @f$\mathbf{n}@f$
     computeNormal(model->getCurrentPosition(), normal, type, ghost_type);
 
     /// compute openings @f$\mathbf{\delta}@f$
     computeOpening(model->getDisplacement(), opening(type, ghost_type), type,
                    ghost_type);
 
     /// compute traction @f$\mathbf{t}@f$
     computeTraction(normal, type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialCohesive::computeNormal(const Array<Real> & position,
                                      Array<Real> & normal, ElementType type,
                                      GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   if (type == _cohesive_1d_2)
     fem_cohesive->computeNormalsOnIntegrationPoints(position, normal, type,
                                                     ghost_type);
   else {
 #define COMPUTE_NORMAL(type)                                                   \
   fem_cohesive->getShapeFunctions()                                            \
       .computeNormalsOnIntegrationPoints<type, CohesiveReduceFunctionMean>(    \
           position, normal, ghost_type, element_filter(type, ghost_type));
 
     AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(COMPUTE_NORMAL);
 #undef COMPUTE_NORMAL
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialCohesive::computeOpening(const Array<Real> & displacement,
                                       Array<Real> & opening, ElementType type,
                                       GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
 #define COMPUTE_OPENING(type)                                                  \
   fem_cohesive->getShapeFunctions()                                            \
       .interpolateOnIntegrationPoints<type, CohesiveReduceFunctionOpening>(    \
           displacement, opening, spatial_dimension, ghost_type,                \
           element_filter(type, ghost_type));
 
   AKANTU_BOOST_COHESIVE_ELEMENT_SWITCH(COMPUTE_OPENING);
 #undef COMPUTE_OPENING
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void MaterialCohesive::computeEnergies() {
   AKANTU_DEBUG_IN();
 
   Vector<Real> b(spatial_dimension);
   Vector<Real> h(spatial_dimension);
 
   for (auto & type : element_filter.elementTypes(spatial_dimension, _not_ghost,
                                                  _ek_cohesive)) {
     auto erev = reversible_energy(type, _not_ghost).begin();
     auto etot = total_energy(type, _not_ghost).begin();
     auto traction_it = tractions(type, _not_ghost).begin(spatial_dimension);
     auto traction_old_it =
         tractions_old(type, _not_ghost).begin(spatial_dimension);
     auto opening_it = opening(type, _not_ghost).begin(spatial_dimension);
     auto opening_old_it =
         opening_old(type, _not_ghost).begin(spatial_dimension);
 
     auto traction_end = tractions(type, _not_ghost).end(spatial_dimension);
 
     /// loop on each quadrature point
     for (; traction_it != traction_end; ++traction_it, ++traction_old_it,
                                         ++opening_it, ++opening_old_it, ++erev,
                                         ++etot) {
       /// trapezoidal integration
       b = *opening_it;
       b -= *opening_old_it;
 
       h = *traction_old_it;
       h += *traction_it;
 
       *etot += .5 * b.dot(h);
       *erev = .5 * traction_it->dot(*opening_it);
     }
   }
 
   /// update old values
   GhostType ghost_type = _not_ghost;
   for (auto & type : element_filter.elementTypes(spatial_dimension, _not_ghost,
                                                  _ek_cohesive)) {
     tractions_old(type, ghost_type).copy(tractions(type, ghost_type));
     opening_old(type, ghost_type).copy(opening(type, ghost_type));
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real MaterialCohesive::getReversibleEnergy() {
   AKANTU_DEBUG_IN();
   Real erev = 0.;
 
   /// integrate reversible energy for each type of elements
   for (auto & type : element_filter.elementTypes(spatial_dimension, _not_ghost,
                                                  _ek_cohesive)) {
     erev +=
         fem_cohesive->integrate(reversible_energy(type, _not_ghost), type,
                                 _not_ghost, element_filter(type, _not_ghost));
   }
 
   AKANTU_DEBUG_OUT();
   return erev;
 }
 
 /* -------------------------------------------------------------------------- */
 Real MaterialCohesive::getDissipatedEnergy() {
   AKANTU_DEBUG_IN();
   Real edis = 0.;
 
   /// integrate dissipated energy for each type of elements
   for (auto & type : element_filter.elementTypes(spatial_dimension, _not_ghost,
                                                  _ek_cohesive)) {
     Array<Real> dissipated_energy(total_energy(type, _not_ghost));
     dissipated_energy -= reversible_energy(type, _not_ghost);
     edis += fem_cohesive->integrate(dissipated_energy, type, _not_ghost,
                                     element_filter(type, _not_ghost));
   }
 
   AKANTU_DEBUG_OUT();
   return edis;
 }
 
 /* -------------------------------------------------------------------------- */
 Real MaterialCohesive::getContactEnergy() {
   AKANTU_DEBUG_IN();
   Real econ = 0.;
 
   /// integrate contact energy for each type of elements
   for (auto & type : element_filter.elementTypes(spatial_dimension, _not_ghost,
                                                  _ek_cohesive)) {
 
     auto & el_filter = element_filter(type, _not_ghost);
     UInt nb_quad_per_el =
         fem_cohesive->getNbIntegrationPoints(type, _not_ghost);
-    UInt nb_quad_points = el_filter.getSize() * nb_quad_per_el;
+    UInt nb_quad_points = el_filter.size() * nb_quad_per_el;
     Array<Real> contact_energy(nb_quad_points);
 
     auto contact_traction_it =
         contact_tractions(type, _not_ghost).begin(spatial_dimension);
     auto contact_opening_it =
         contact_opening(type, _not_ghost).begin(spatial_dimension);
 
     /// loop on each quadrature point
     for (UInt q = 0; q < nb_quad_points;
          ++contact_traction_it, ++contact_opening_it, ++q) {
 
       contact_energy(q) = .5 * contact_traction_it->dot(*contact_opening_it);
     }
 
     econ +=
         fem_cohesive->integrate(contact_energy, type, _not_ghost, el_filter);
   }
 
   AKANTU_DEBUG_OUT();
   return econ;
 }
 
 /* -------------------------------------------------------------------------- */
 Real MaterialCohesive::getEnergy(std::string type) {
   AKANTU_DEBUG_IN();
 
   if (type == "reversible")
     return getReversibleEnergy();
   else if (type == "dissipated")
     return getDissipatedEnergy();
   else if (type == "cohesive contact")
     return getContactEnergy();
 
   AKANTU_DEBUG_OUT();
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
diff --git a/src/model/solid_mechanics/materials/material_cohesive/material_cohesive_inline_impl.cc b/src/model/solid_mechanics/materials/material_cohesive/material_cohesive_inline_impl.cc
index 38206e23e..3a769a2e1 100644
--- a/src/model/solid_mechanics/materials/material_cohesive/material_cohesive_inline_impl.cc
+++ b/src/model/solid_mechanics/materials/material_cohesive/material_cohesive_inline_impl.cc
@@ -1,95 +1,95 @@
 /**
  * @file   material_cohesive_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Aug 04 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  MaterialCohesive inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 inline UInt MaterialCohesive::addFacet(const Element & element) {
   Array<UInt> & f_filter = facet_filter(element.type, element.ghost_type);
   f_filter.push_back(element.element);
-  return f_filter.getSize()-1;
+  return f_filter.size()-1;
 }
 
 
 /* -------------------------------------------------------------------------- */
 template<ElementType type>
 void MaterialCohesive::computeNormal(const Array<Real> & position,
 				     Array<Real> & normal,
 				     GhostType ghost_type) {
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt MaterialCohesive::getNbDataForElements(const Array<Element> & elements,
 						   SynchronizationTag tag) const {
 
   switch (tag) {
   case _gst_smm_stress: {
     return 2 * spatial_dimension * sizeof(Real) * this->getModel().getNbIntegrationPoints(elements, "CohesiveFEEngine");
   }
   case _gst_smmc_damage: {
     return sizeof(Real) * this->getModel().getNbIntegrationPoints(elements, "CohesiveFEEngine");
   }
   default: {}
   }
 
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void MaterialCohesive::packElementData(CommunicationBuffer & buffer,
 					      const Array<Element> & elements,
 					      SynchronizationTag tag) const {
   switch (tag) {
   case _gst_smm_stress: {
     packElementDataHelper(tractions, buffer, elements, "CohesiveFEEngine");
     packElementDataHelper(contact_tractions, buffer, elements, "CohesiveFEEngine");
     break;
   }
   case _gst_smmc_damage:
     packElementDataHelper(damage, buffer, elements, "CohesiveFEEngine"); break;
   default: {}
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void MaterialCohesive::unpackElementData(CommunicationBuffer & buffer,
 						const Array<Element> & elements,
 						SynchronizationTag tag) {
   switch (tag) {
   case _gst_smm_stress: {
     unpackElementDataHelper(tractions, buffer, elements, "CohesiveFEEngine");
     unpackElementDataHelper(contact_tractions, buffer, elements, "CohesiveFEEngine");
     break;
   }
   case _gst_smmc_damage:
     unpackElementDataHelper(damage, buffer, elements, "CohesiveFEEngine"); break;
   default: {}
   }
 }
diff --git a/src/model/solid_mechanics/materials/material_damage/material_damage_non_local.hh b/src/model/solid_mechanics/materials/material_damage/material_damage_non_local.hh
index 9d03c937a..76f1fd0a1 100644
--- a/src/model/solid_mechanics/materials/material_damage/material_damage_non_local.hh
+++ b/src/model/solid_mechanics/materials/material_damage/material_damage_non_local.hh
@@ -1,97 +1,97 @@
 /**
  * @file   material_damage_non_local.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Aug 23 2012
  * @date last modification: Wed Oct 21 2015
  *
  * @brief  interface for non local damage material
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material_non_local.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_DAMAGE_NON_LOCAL_HH__
 #define __AKANTU_MATERIAL_DAMAGE_NON_LOCAL_HH__
 
 namespace akantu {
 
 template <UInt dim, class MaterialDamageLocal>
 class MaterialDamageNonLocal : public MaterialNonLocal<dim, MaterialDamageLocal> {
 public:
   using MaterialParent = MaterialNonLocal<dim, MaterialDamageLocal>;
 
   MaterialDamageNonLocal(SolidMechanicsModel & model, const ID & id)
       : MaterialParent(model, id) {};
 
   /* ------------------------------------------------------------------------ */
   virtual void initMaterial() {
     MaterialParent::initMaterial();
   }
 
 protected:
   /* ------------------------------------------------------------------------ */
   virtual void computeNonLocalStress(ElementType type,
                                      GhostType ghost_type = _not_ghost) = 0;
 
   /* ------------------------------------------------------------------------ */
   void computeNonLocalStresses(GhostType ghost_type) override {
     AKANTU_DEBUG_IN();
 
     for (auto type :
          this->element_filter.elementTypes(dim, ghost_type)) {
       auto & elem_filter = this->element_filter(type, ghost_type);
-      if (elem_filter.getSize() == 0)
+      if (elem_filter.size() == 0)
         continue;
 
       computeNonLocalStress(type, ghost_type);
     }
 
     AKANTU_DEBUG_OUT();
   }
 
 public:
   /* ------------------------------------------------------------------------ */
   inline UInt getNbData(const Array<Element> & elements,
                         const SynchronizationTag & tag) const override {
     return MaterialParent::getNbData(elements, tag);
   }
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const override {
     MaterialParent::packData(buffer, elements, tag);
   }
 
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag) {
     MaterialParent::unpackData(buffer, elements, tag);
   }
 };
 
 } // namespace akantu
 
 #endif /* __AKANTU_MATERIAL_DAMAGE_NON_LOCAL_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_embedded/material_reinforcement.cc b/src/model/solid_mechanics/materials/material_embedded/material_reinforcement.cc
index 304c97685..3fd3dce3b 100644
--- a/src/model/solid_mechanics/materials/material_embedded/material_reinforcement.cc
+++ b/src/model/solid_mechanics/materials/material_embedded/material_reinforcement.cc
@@ -1,784 +1,784 @@
 /**
  * @file   material_reinforcement.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Wed Mar 25 2015
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Reinforcement material
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #include "aka_common.hh"
 #include "aka_voigthelper.hh"
 #include "material_reinforcement.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 MaterialReinforcement<dim>::MaterialReinforcement(SolidMechanicsModel & model,
                                                   UInt spatial_dimension,
                                                   const Mesh & mesh,
                                                   FEEngine & fe_engine,
                                                   const ID & id)
     : Material(model, dim, mesh, fe_engine,
                id), // /!\ dim, not spatial_dimension !
       model(NULL),
       stress_embedded("stress_embedded", *this, 1, fe_engine,
                       this->element_filter),
       gradu_embedded("gradu_embedded", *this, 1, fe_engine,
                      this->element_filter),
       directing_cosines("directing_cosines", *this, 1, fe_engine,
                         this->element_filter),
       pre_stress("pre_stress", *this, 1, fe_engine, this->element_filter),
       area(1.0), shape_derivatives() {
   AKANTU_DEBUG_IN();
   this->initialize(model);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialReinforcement<dim>::initialize(SolidMechanicsModel & a_model) {
   AKANTU_DEBUG_IN();
   this->model = dynamic_cast<EmbeddedInterfaceModel *>(&a_model);
   AKANTU_DEBUG_ASSERT(this->model != NULL,
                       "MaterialReinforcement needs an EmbeddedInterfaceModel");
 
   this->registerParam("area", area, _pat_parsable | _pat_modifiable,
                       "Reinforcement cross-sectional area");
   this->registerParam("pre_stress", pre_stress, _pat_parsable | _pat_modifiable,
                       "Uniform pre-stress");
 
   this->unregisterInternal(this->stress);
 
   // Fool the AvgHomogenizingFunctor
   // stress.initialize(dim * dim);
 
   // Reallocate the element filter
   this->element_filter.free();
   this->model->getInterfaceMesh().initElementTypeMapArray(this->element_filter,
                                                           1, 1, false, _ek_regular);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim> MaterialReinforcement<dim>::~MaterialReinforcement() {
   AKANTU_DEBUG_IN();
 
   ElementTypeMap<ElementTypeMapArray<Real> *>::type_iterator
     it = shape_derivatives.firstType(),
     end = shape_derivatives.lastType();
 
   for (; it != end; ++it) {
     delete shape_derivatives(*it, _not_ghost);
     delete shape_derivatives(*it, _ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim> void MaterialReinforcement<dim>::initMaterial() {
   Material::initMaterial();
 
   stress_embedded.initialize(dim * dim);
   gradu_embedded.initialize(dim * dim);
   pre_stress.initialize(1);
 
   /// We initialise the stuff that is not going to change during the simulation
   this->allocBackgroundShapeDerivatives();
   this->initBackgroundShapeDerivatives();
   this->initDirectingCosines();
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Background shape derivatives need to be stored per background element
  * types but also per embedded element type, which is why they are stored
  * in an ElementTypeMap<ElementTypeMapArray<Real> *>. The outer ElementTypeMap
  * refers to the embedded types, and the inner refers to the background types.
  */
 template <UInt dim>
 void MaterialReinforcement<dim>::allocBackgroundShapeDerivatives() {
   AKANTU_DEBUG_IN();
 
   Mesh & interface_mesh = model->getInterfaceMesh();
   Mesh & mesh = model->getMesh();
 
   ghost_type_t::iterator int_ghost_it = ghost_type_t::begin();
 
   // Loop over interface ghosts
   for (; int_ghost_it != ghost_type_t::end(); ++int_ghost_it) {
     Mesh::type_iterator interface_type_it =
         interface_mesh.firstType(1, *int_ghost_it);
     Mesh::type_iterator interface_type_end =
         interface_mesh.lastType(1, *int_ghost_it);
 
     // Loop over interface types
     for (; interface_type_it != interface_type_end; ++interface_type_it) {
       Mesh::type_iterator background_type_it =
           mesh.firstType(dim, *int_ghost_it);
       Mesh::type_iterator background_type_end =
           mesh.lastType(dim, *int_ghost_it);
 
       // Loop over background types
       for (; background_type_it != background_type_end ; ++background_type_it) {
         const ElementType & int_type = *interface_type_it;
         const ElementType & back_type = *background_type_it;
         const GhostType & int_ghost = *int_ghost_it;
 
         std::string shaped_id = "embedded_shape_derivatives";
 
         if (int_ghost == _ghost) shaped_id += ":ghost";
 
         ElementTypeMapArray<Real> * shaped_etma = new ElementTypeMapArray<Real>(shaped_id, this->name);
 
         UInt nb_points = Mesh::getNbNodesPerElement(back_type);
         UInt nb_quad_points = model->getFEEngine("EmbeddedInterfaceFEEngine").getNbIntegrationPoints(int_type);
-        UInt nb_elements = element_filter(int_type, int_ghost).getSize();
+        UInt nb_elements = element_filter(int_type, int_ghost).size();
 
         // Alloc the background ElementTypeMapArray
         shaped_etma->alloc(nb_elements * nb_quad_points,
                            dim * nb_points,
                            back_type);
 
         // Insert the background ElementTypeMapArray in the interface
         // ElementTypeMap
         shape_derivatives(shaped_etma, int_type, int_ghost);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void MaterialReinforcement<dim>::initBackgroundShapeDerivatives() {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh = model->getMesh();
 
   Mesh::type_iterator type_it = mesh.firstType(dim, _not_ghost);
   Mesh::type_iterator type_end = mesh.lastType(dim, _not_ghost);
 
   for (; type_it != type_end; ++type_it) {
     computeBackgroundShapeDerivatives(*type_it, _not_ghost);
     // computeBackgroundShapeDerivatives(*type_it, _ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim> void MaterialReinforcement<dim>::initDirectingCosines() {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh = model->getInterfaceMesh();
 
   Mesh::type_iterator type_it = mesh.firstType(1, _not_ghost);
   Mesh::type_iterator type_end = mesh.lastType(1, _not_ghost);
 
   const UInt voigt_size = getTangentStiffnessVoigtSize(dim);
   directing_cosines.initialize(voigt_size * voigt_size);
 
   for (; type_it != type_end; ++type_it) {
     computeDirectingCosines(*type_it, _not_ghost);
     // computeDirectingCosines(*type_it, _ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void MaterialReinforcement<dim>::assembleStiffnessMatrix(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh & interface_mesh = model->getInterfaceMesh();
 
   Mesh::type_iterator type_it = interface_mesh.firstType(1, _not_ghost);
   Mesh::type_iterator type_end = interface_mesh.lastType(1, _not_ghost);
 
   for (; type_it != type_end; ++type_it) {
     assembleStiffnessMatrix(*type_it, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void MaterialReinforcement<dim>::assembleInternalForces(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh & interface_mesh = model->getInterfaceMesh();
 
   Mesh::type_iterator type_it = interface_mesh.firstType(1, _not_ghost);
   Mesh::type_iterator type_end = interface_mesh.lastType(1, _not_ghost);
 
   for (; type_it != type_end; ++type_it) {
     this->assembleInternalForces(*type_it, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialReinforcement<dim>::computeGradU(const ElementType & type,
                                               GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Array<UInt> & elem_filter = element_filter(type, ghost_type);
-  UInt nb_element = elem_filter.getSize();
+  UInt nb_element = elem_filter.size();
   UInt nb_quad_points = model->getFEEngine("EmbeddedInterfaceFEEngine")
                             .getNbIntegrationPoints(type);
 
   Array<Real> & gradu_vec = gradu_embedded(type, ghost_type);
 
   Mesh::type_iterator back_it = model->getMesh().firstType(dim, ghost_type);
   Mesh::type_iterator back_end = model->getMesh().lastType(dim, ghost_type);
 
   for (; back_it != back_end; ++back_it) {
     UInt nodes_per_background_e = Mesh::getNbNodesPerElement(*back_it);
 
     Array<Real> & shapesd =
         shape_derivatives(type, ghost_type)->operator()(*back_it, ghost_type);
 
     Array<UInt> * background_filter =
         new Array<UInt>(nb_element, 1, "background_filter");
     filterInterfaceBackgroundElements(*background_filter, *back_it, type,
                                       ghost_type);
 
     Array<Real> * disp_per_element = new Array<Real>(0, dim * nodes_per_background_e, "disp_elem");
     FEEngine::extractNodalToElementField(model->getMesh(),
                                          model->getDisplacement(),
                                          *disp_per_element,
                                          *back_it, ghost_type, *background_filter);
 
     Array<Real>::matrix_iterator disp_it =
         disp_per_element->begin(dim, nodes_per_background_e);
     Array<Real>::matrix_iterator disp_end =
         disp_per_element->end(dim, nodes_per_background_e);
 
     Array<Real>::matrix_iterator shapes_it =
         shapesd.begin(dim, nodes_per_background_e);
     Array<Real>::matrix_iterator grad_u_it = gradu_vec.begin(dim, dim);
 
     for (; disp_it != disp_end; ++disp_it) {
       for (UInt i = 0; i < nb_quad_points; i++, ++shapes_it, ++grad_u_it) {
         Matrix<Real> & B = *shapes_it;
         Matrix<Real> & du = *grad_u_it;
         Matrix<Real> & u = *disp_it;
 
         du.mul<false, true>(u, B);
       }
     }
 
     delete background_filter;
     delete disp_per_element;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialReinforcement<dim>::computeAllStresses(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh::type_iterator it = model->getInterfaceMesh().firstType();
   Mesh::type_iterator last_type = model->getInterfaceMesh().lastType();
 
   for (; it != last_type; ++it) {
     computeGradU(*it, ghost_type);
     computeStress(*it, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialReinforcement<dim>::assembleInternalForces(
     const ElementType & type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh = model->getMesh();
 
   Mesh::type_iterator type_it = mesh.firstType(dim, ghost_type);
   Mesh::type_iterator type_end = mesh.lastType(dim, ghost_type);
 
   for (; type_it != type_end; ++type_it) {
     assembleInternalForcesInterface(type, *type_it, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 /**
  * Computes and assemble the residual. Residual in reinforcement is computed as
  * :
  * \f[
  * \vec{r} = A_s \int_S{\mathbf{B}^T\mathbf{C}^T \vec{\sigma_s}\,\mathrm{d}s}
  * \f]
  */
 template <UInt dim>
 void MaterialReinforcement<dim>::assembleInternalForcesInterface(
     const ElementType & interface_type, const ElementType & background_type,
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt voigt_size = getTangentStiffnessVoigtSize(dim);
 
   Array<Real> & residual = const_cast<Array<Real> &>(model->getResidual());
 
   FEEngine & interface_engine = model->getFEEngine("EmbeddedInterfaceFEEngine");
   FEEngine & background_engine = model->getFEEngine();
 
   Array<UInt> & elem_filter = element_filter(interface_type, ghost_type);
 
   UInt nodes_per_background_e = Mesh::getNbNodesPerElement(background_type);
   UInt nb_quadrature_points =
       interface_engine.getNbIntegrationPoints(interface_type, ghost_type);
-  UInt nb_element = elem_filter.getSize();
+  UInt nb_element = elem_filter.size();
 
   UInt back_dof = dim * nodes_per_background_e;
 
   Array<Real> & shapesd = shape_derivatives(interface_type, ghost_type)
                               ->
                               operator()(background_type, ghost_type);
 
   Array<Real> * integrant = new Array<Real>(nb_quadrature_points * nb_element,
                                             back_dof,
                                             "integrant");
 
   Array<Real>::vector_iterator integrant_it = integrant->begin(back_dof);
   Array<Real>::vector_iterator integrant_end = integrant->end(back_dof);
 
   Array<Real>::matrix_iterator B_it =
       shapesd.begin(dim, nodes_per_background_e);
   Array<Real>::matrix_iterator C_it =
       directing_cosines(interface_type, ghost_type)
           .begin(voigt_size, voigt_size);
   Array<Real>::matrix_iterator sigma_it =
       stress_embedded(interface_type, ghost_type).begin(dim, dim);
 
   Vector<Real> sigma(voigt_size);
   Matrix<Real> Bvoigt(voigt_size, back_dof);
   Vector<Real> Ct_sigma(voigt_size);
 
   for (; integrant_it != integrant_end ; ++integrant_it,
          ++B_it,
          ++C_it,
          ++sigma_it) {
     VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(*B_it, Bvoigt, nodes_per_background_e);
     Matrix<Real> & C = *C_it;
     Vector<Real> & BtCt_sigma = *integrant_it;
 
     stressTensorToVoigtVector(*sigma_it, sigma);
 
     Ct_sigma.mul<true>(C, sigma);
     BtCt_sigma.mul<true>(Bvoigt, Ct_sigma);
     BtCt_sigma *= area;
   }
 
   Array<Real> * residual_interface =
       new Array<Real>(nb_element, back_dof, "residual_interface");
   interface_engine.integrate(*integrant, *residual_interface, back_dof,
                              interface_type, ghost_type, elem_filter);
 
   delete integrant;
 
   Array<UInt> * background_filter =
       new Array<UInt>(nb_element, 1, "background_filter");
 
   filterInterfaceBackgroundElements(*background_filter, background_type,
                                     interface_type, ghost_type);
   background_engine.assembleArray(
       *residual_interface, residual,
       model->getDOFSynchronizer().getLocalDOFEquationNumbers(), dim,
       background_type, ghost_type, *background_filter, -1.0);
   delete residual_interface;
   delete background_filter;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim>
 void MaterialReinforcement<dim>::filterInterfaceBackgroundElements(
     Array<UInt> & filter, const ElementType & type,
     const ElementType & interface_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   filter.resize(0);
   filter.clear();
 
   Array<Element> & elements =
       model->getInterfaceAssociatedElements(interface_type, ghost_type);
   Array<UInt> & elem_filter = element_filter(interface_type, ghost_type);
 
   Array<UInt>::scalar_iterator filter_it = elem_filter.begin(),
                                filter_end = elem_filter.end();
 
   for (; filter_it != filter_end; ++filter_it) {
     Element & elem = elements(*filter_it);
     if (elem.type == type)
       filter.push_back(elem.element);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void MaterialReinforcement<dim>::computeDirectingCosines(
     const ElementType & type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh & interface_mesh = this->model->getInterfaceMesh();
 
   const UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   const UInt steel_dof = dim * nb_nodes_per_element;
   const UInt voigt_size = getTangentStiffnessVoigtSize(dim);
   const UInt nb_quad_points = model->getFEEngine("EmbeddedInterfaceFEEngine")
                                   .getNbIntegrationPoints(type, ghost_type);
 
-  Array<Real> node_coordinates(this->element_filter(type, ghost_type).getSize(),
+  Array<Real> node_coordinates(this->element_filter(type, ghost_type).size(),
                                steel_dof);
 
   this->model->getFEEngine().template extractNodalToElementField<Real>(interface_mesh,
                                                                        interface_mesh.getNodes(),
                                                                        node_coordinates,
                                                                        type,
                                                                        ghost_type,
                                                                        this->element_filter(type, ghost_type));
 
   Array<Real>::matrix_iterator directing_cosines_it =
       directing_cosines(type, ghost_type).begin(voigt_size, voigt_size);
 
   Array<Real>::matrix_iterator node_coordinates_it =
       node_coordinates.begin(dim, nb_nodes_per_element);
   Array<Real>::matrix_iterator node_coordinates_end =
       node_coordinates.end(dim, nb_nodes_per_element);
 
   for (; node_coordinates_it != node_coordinates_end; ++node_coordinates_it) {
     for (UInt i = 0; i < nb_quad_points; i++, ++directing_cosines_it) {
       Matrix<Real> & nodes = *node_coordinates_it;
       Matrix<Real> & cosines = *directing_cosines_it;
 
       computeDirectingCosinesOnQuad(nodes, cosines);
     }
   }
 
   // Mauro: the directing_cosines internal is defined on the quadrature points of each element
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim>
 void MaterialReinforcement<dim>::assembleStiffnessMatrix(
     const ElementType & type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh = model->getMesh();
 
   Mesh::type_iterator type_it = mesh.firstType(dim, ghost_type);
   Mesh::type_iterator type_end = mesh.lastType(dim, ghost_type);
 
   for (; type_it != type_end; ++type_it) {
     assembleStiffnessMatrixInterface(type, *type_it, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Computes the reinforcement stiffness matrix (Gomes & Awruch, 2001)
  * \f[
  * \mathbf{K}_e = \sum_{i=1}^R{A_i\int_{S_i}{\mathbf{B}^T
  * \mathbf{C}_i^T \mathbf{D}_{s, i} \mathbf{C}_i \mathbf{B}\,\mathrm{d}s}}
  * \f]
  */
 template <UInt dim>
 void MaterialReinforcement<dim>::assembleStiffnessMatrixInterface(
     const ElementType & interface_type, const ElementType & background_type,
     GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   UInt voigt_size = getTangentStiffnessVoigtSize(dim);
 
   SparseMatrix & K = const_cast<SparseMatrix &>(model->getStiffnessMatrix());
 
   FEEngine & background_engine = model->getFEEngine();
   FEEngine & interface_engine = model->getFEEngine("EmbeddedInterfaceFEEngine");
 
   Array<UInt> & elem_filter = element_filter(interface_type, ghost_type);
   Array<Real> & grad_u = gradu_embedded(interface_type, ghost_type);
 
-  UInt nb_element = elem_filter.getSize();
+  UInt nb_element = elem_filter.size();
   UInt nodes_per_background_e = Mesh::getNbNodesPerElement(background_type);
   UInt nb_quadrature_points =
       interface_engine.getNbIntegrationPoints(interface_type, ghost_type);
 
   UInt back_dof = dim * nodes_per_background_e;
 
   UInt integrant_size = back_dof;
 
   grad_u.resize(nb_quadrature_points * nb_element);
 
   Array<Real> * tangent_moduli = new Array<Real>(
       nb_element * nb_quadrature_points, 1, "interface_tangent_moduli");
   tangent_moduli->clear();
   computeTangentModuli(interface_type, *tangent_moduli, ghost_type);
 
   Array<Real> & shapesd = shape_derivatives(interface_type, ghost_type)
                               ->
                               operator()(background_type, ghost_type);
 
   Array<Real> * integrant = new Array<Real>(nb_element * nb_quadrature_points,
                                             integrant_size * integrant_size,
                                             "B^t*C^t*D*C*B");
   integrant->clear();
 
   /// Temporary matrices for integrant product
   Matrix<Real> Bvoigt(voigt_size, back_dof);
   Matrix<Real> DC(voigt_size, voigt_size);
   Matrix<Real> DCB(voigt_size, back_dof);
   Matrix<Real> CtDCB(voigt_size, back_dof);
 
   Array<Real>::scalar_iterator D_it = tangent_moduli->begin();
   Array<Real>::scalar_iterator D_end = tangent_moduli->end();
 
   Array<Real>::matrix_iterator C_it =
       directing_cosines(interface_type, ghost_type)
           .begin(voigt_size, voigt_size);
   Array<Real>::matrix_iterator B_it =
       shapesd.begin(dim, nodes_per_background_e);
   Array<Real>::matrix_iterator integrant_it =
       integrant->begin(integrant_size, integrant_size);
 
   for (; D_it != D_end; ++D_it, ++C_it, ++B_it, ++integrant_it) {
     Real & D = *D_it;
     Matrix<Real> & C = *C_it;
     Matrix<Real> & B = *B_it;
     Matrix<Real> & BtCtDCB = *integrant_it;
 
     VoigtHelper<dim>::transferBMatrixToSymVoigtBMatrix(B, Bvoigt,
                                                        nodes_per_background_e);
 
     DC.clear();
     DC(0, 0) = D * area;
     DC *= C;
     DCB.mul<false, false>(DC, Bvoigt);
     CtDCB.mul<true, false>(C, DCB);
     BtCtDCB.mul<true, false>(Bvoigt, CtDCB);
   }
 
   delete tangent_moduli;
 
   Array<Real> * K_interface = new Array<Real>(
       nb_element, integrant_size * integrant_size, "K_interface");
   interface_engine.integrate(*integrant, *K_interface,
                              integrant_size * integrant_size, interface_type,
                              ghost_type, elem_filter);
 
   delete integrant;
 
   // Mauro: Here K_interface contains the local stiffness matrices,
   // directing_cosines contains the information about the orientation
   // of the reinforcements, any rotation of the local stiffness matrix
   // can be done here
 
   Array<UInt> * background_filter = new Array<UInt>(nb_element, 1, "background_filter");
 
   filterInterfaceBackgroundElements(*background_filter, background_type,
                                     interface_type, ghost_type);
 
   background_engine.assembleMatrix(*K_interface, K, dim, background_type,
                                    ghost_type, *background_filter);
 
   delete K_interface;
   delete background_filter;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 /// In this function, type and ghost_type refer to background elements
 template <UInt dim>
 void MaterialReinforcement<dim>::computeBackgroundShapeDerivatives(
     const ElementType & type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Mesh & interface_mesh = model->getInterfaceMesh();
 
   FEEngine & engine = model->getFEEngine();
   FEEngine & interface_engine = model->getFEEngine("EmbeddedInterfaceFEEngine");
 
   Mesh::type_iterator interface_type = interface_mesh.firstType();
   Mesh::type_iterator interface_last = interface_mesh.lastType();
 
   for (; interface_type != interface_last; ++interface_type) {
     Array<UInt> & filter = element_filter(*interface_type, ghost_type);
 
-    const UInt nb_elements = filter.getSize();
+    const UInt nb_elements = filter.size();
     const UInt nb_nodes = Mesh::getNbNodesPerElement(type);
     const UInt nb_quad_per_element =
         interface_engine.getNbIntegrationPoints(*interface_type);
 
     Array<Real> quad_pos(nb_quad_per_element * nb_elements, dim,
                          "interface_quad_points");
     quad_pos.resize(nb_quad_per_element * nb_elements);
     interface_engine.interpolateOnIntegrationPoints(
         interface_mesh.getNodes(), quad_pos, dim, *interface_type, ghost_type,
         filter);
 
     Array<Real> & background_shapesd =
         shape_derivatives(*interface_type, ghost_type)
             ->
             operator()(type, ghost_type);
     background_shapesd.clear();
 
     Array<UInt> * background_elements = new Array<UInt>(
         nb_elements, 1, "computeBackgroundShapeDerivatives:background_filter");
     filterInterfaceBackgroundElements(*background_elements, type,
                                       *interface_type, ghost_type);
 
     Array<UInt>::scalar_iterator back_it = background_elements->begin(),
                                  back_end = background_elements->end();
 
     Array<Real>::matrix_iterator shapesd_it =
         background_shapesd.begin(dim, nb_nodes);
 
     Array<Real>::vector_iterator quad_pos_it = quad_pos.begin(dim);
 
     for (; back_it != back_end; ++back_it) {
       for (UInt i = 0; i < nb_quad_per_element;
            i++, ++shapesd_it, ++quad_pos_it)
         engine.computeShapeDerivatives(*quad_pos_it, *back_it, type,
                                        *shapesd_it, ghost_type);
     }
 
     delete background_elements;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 template <UInt dim> Real MaterialReinforcement<dim>::getEnergy(std::string id) {
   AKANTU_DEBUG_IN();
   if (id == "potential") {
     Real epot = 0.;
 
     computePotentialEnergyByElements();
 
     Mesh::type_iterator it = element_filter.firstType(spatial_dimension),
                         end = element_filter.lastType(spatial_dimension);
 
     for (; it != end; ++it) {
       FEEngine & interface_engine =
           model->getFEEngine("EmbeddedInterfaceFEEngine");
       epot += interface_engine.integrate(potential_energy(*it, _not_ghost), *it,
                                          _not_ghost,
                                          element_filter(*it, _not_ghost));
       epot *= area;
     }
 
     return epot;
   }
 
   AKANTU_DEBUG_OUT();
   return 0;
 }
 
 // /* --------------------------------------------------------------------------
 // */
 // template<UInt dim>
 // ElementTypeMap<UInt> MaterialReinforcement<dim>::getInternalDataPerElem(const
 // ID & field_name,
 //                                                                         const
 //                                                                         ElementKind
 //                                                                         &
 //                                                                         kind,
 //                                                                         const
 //                                                                         ID &
 //                                                                         fe_engine_id)
 //                                                                         const
 //                                                                         {
 //   return Material::getInternalDataPerElem(field_name, kind,
 //   "EmbeddedInterfaceFEEngine");
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // // Author is Guillaume Anciaux, see material.cc
 // template<UInt dim>
 // void MaterialReinforcement<dim>::flattenInternal(const std::string &
 // field_id,
 //                                                  ElementTypeMapArray<Real> &
 //                                                  internal_flat,
 //                                                  const GhostType ghost_type,
 //                                                  ElementKind element_kind)
 //                                                  const {
 //   AKANTU_DEBUG_IN();
 
 //   if (field_id == "stress_embedded" || field_id == "inelastic_strain") {
 //     Material::flattenInternalIntern(field_id,
 //                                     internal_flat,
 //                                     1,
 //                                     ghost_type,
 //                                     _ek_not_defined,
 //                                     &(this->element_filter),
 //                                     &(this->model->getInterfaceMesh()));
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(MaterialReinforcement);
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/solid_mechanics/materials/material_embedded/material_reinforcement_template_tmpl.hh b/src/model/solid_mechanics/materials/material_embedded/material_reinforcement_template_tmpl.hh
index 0a5ff381b..ca02b9b5f 100644
--- a/src/model/solid_mechanics/materials/material_embedded/material_reinforcement_template_tmpl.hh
+++ b/src/model/solid_mechanics/materials/material_embedded/material_reinforcement_template_tmpl.hh
@@ -1,182 +1,182 @@
 /**
  * @file   material_reinforcement_template_tmpl.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Wed Mar 25 2015
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Reinforcement material templated with constitutive law
  *
  * @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/>.
  *
  */
 
 // /!\ no namespace here !
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 MaterialReinforcementTemplate<dim, ConstLaw>::MaterialReinforcementTemplate(SolidMechanicsModel & a_model,
                                                                             const ID & id):
   Material(a_model, 1,
            dynamic_cast<EmbeddedInterfaceModel &>(a_model).getInterfaceMesh(),
            a_model.getFEEngine("EmbeddedInterfaceFEEngine"), id),
   MaterialReinforcement<dim>(a_model, 1,
                              dynamic_cast<EmbeddedInterfaceModel &>(a_model).getInterfaceMesh(),
                              a_model.getFEEngine("EmbeddedInterfaceFEEngine"), id),
   ConstLaw(a_model, 1,
            dynamic_cast<EmbeddedInterfaceModel &>(a_model).getInterfaceMesh(),
            a_model.getFEEngine("EmbeddedInterfaceFEEngine"), id)
 {}
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 MaterialReinforcementTemplate<dim, ConstLaw>::~MaterialReinforcementTemplate()
 {}
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 void MaterialReinforcementTemplate<dim, ConstLaw>::initMaterial() {
   MaterialReinforcement<dim>::initMaterial();
   ConstLaw::initMaterial();
 
   // Needed for plasticity law
   this->ConstLaw::nu = 0.5;
   this->ConstLaw::updateInternalParameters();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 void MaterialReinforcementTemplate<dim, ConstLaw>::computeGradU(const ElementType & el_type,
                                                                 GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   
   MaterialReinforcement<dim>::computeGradU(el_type, ghost_type);
 
   const UInt voigt_size = Material::getTangentStiffnessVoigtSize(dim);
 
   Array<Real>::matrix_iterator full_gradu_it =
     this->MaterialReinforcement<dim>::gradu_embedded(el_type, ghost_type).begin(dim, dim);
   Array<Real>::matrix_iterator full_gradu_end =
     this->MaterialReinforcement<dim>::gradu_embedded(el_type, ghost_type).end(dim, dim);
 
   Array<Real>::scalar_iterator gradu_it =
     this->ConstLaw::gradu(el_type, ghost_type).begin();
 
   Array<Real>::matrix_iterator cosines_it = 
     this->directing_cosines(el_type, ghost_type).begin(voigt_size, voigt_size);
 
 
   for (; full_gradu_it != full_gradu_end ; ++full_gradu_it,
                                           ++gradu_it,
                                           ++cosines_it) {
     Matrix<Real> & full_gradu = *full_gradu_it;
     Real & gradu = *gradu_it;
     Matrix<Real> & C = *cosines_it;
     
     computeInterfaceGradUOnQuad(full_gradu, gradu, C);
   }
   
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 void MaterialReinforcementTemplate<dim, ConstLaw>::computeInterfaceGradUOnQuad(const Matrix<Real> & full_gradu,
                                                                                Real & gradu,
                                                                                const Matrix<Real> & C) {
   const UInt voigt_size = Material::getTangentStiffnessVoigtSize(dim);
 
   Matrix<Real> epsilon(dim, dim);
   Vector<Real> e_voigt(voigt_size);
   Vector<Real> e_interface_voigt(voigt_size);
 
   epsilon = 0.5 * (full_gradu + full_gradu.transpose());
   MaterialReinforcement<dim>::strainTensorToVoigtVector(epsilon, e_voigt);
   e_interface_voigt.mul<false>(C, e_voigt);
 
   gradu = e_interface_voigt(0);
 }
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 void MaterialReinforcementTemplate<dim, ConstLaw>::computeTangentModuli(const ElementType & el_type,
                                                                         Array<Real> & tangent,
                                                                         GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(tangent.getNbComponent() == 1, "Reinforcements only work in 1D");
 
   ConstLaw::computeTangentModuli(el_type, tangent, ghost_type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 void MaterialReinforcementTemplate<dim, ConstLaw>::computeStress(ElementType type,
                                                                  GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   
   ConstLaw::computeStress(type, ghost_type);
 
   Array<Real>::matrix_iterator full_sigma_it =
     this->MaterialReinforcement<dim>::stress_embedded(type, ghost_type).begin(dim, dim);
   Array<Real>::matrix_iterator full_sigma_end =
     this->MaterialReinforcement<dim>::stress_embedded(type, ghost_type).end(dim, dim);
   Array<Real>::scalar_iterator sigma_it =
     this->ConstLaw::stress(type, ghost_type).begin();
   Array<Real>::scalar_iterator pre_stress_it =
     this->MaterialReinforcement<dim>::pre_stress(type, ghost_type).begin();
 
   for (; full_sigma_it != full_sigma_end ; ++full_sigma_it, ++sigma_it, ++pre_stress_it) {
     Matrix<Real> & sigma = *full_sigma_it;
 
     sigma(0, 0) = *sigma_it + *pre_stress_it;
   }
   
   AKANTU_DEBUG_OUT();
 }
 
 
 /* -------------------------------------------------------------------------- */
 
 template<UInt dim, class ConstLaw>
 Real MaterialReinforcementTemplate<dim, ConstLaw>::getEnergy(std::string id) {
   return MaterialReinforcement<dim>::getEnergy(id);
 }
 
 /* -------------------------------------------------------------------------- */
 
 template <UInt dim, class ConstLaw>
 void MaterialReinforcementTemplate<dim, ConstLaw>::computePotentialEnergy(ElementType type,
                                                                           GhostType ghost_type) {
-  const UInt nb_elements = this->element_filter(type, ghost_type).getSize();
+  const UInt nb_elements = this->element_filter(type, ghost_type).size();
   const UInt nb_quad = this->model->getFEEngine("EmbeddedInterfaceFEEngine").getNbIntegrationPoints(type);
   this->ConstLaw::potential_energy.alloc(nb_quad * nb_elements, 1, type, ghost_type, 0.);
 
   ConstLaw::computePotentialEnergy(type, ghost_type);
 }
 
diff --git a/src/model/solid_mechanics/materials/material_non_local_tmpl.hh b/src/model/solid_mechanics/materials/material_non_local_tmpl.hh
index dc3e56c96..5ede42529 100644
--- a/src/model/solid_mechanics/materials/material_non_local_tmpl.hh
+++ b/src/model/solid_mechanics/materials/material_non_local_tmpl.hh
@@ -1,134 +1,134 @@
 /**
  * @file   material_non_local.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sat Sep 26 2015
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Implementation of material non-local
  *
  * @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 "material.hh"
 #include "material_non_local.hh"
 #include "non_local_neighborhood.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim, class LocalParent>
 MaterialNonLocal<dim, LocalParent>::MaterialNonLocal(
     SolidMechanicsModel & model, const ID & id)
     : LocalParent(model, id) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim, class LocalParent>
 void MaterialNonLocal<dim, LocalParent>::initMaterial() {
   MaterialNonLocalInterface::initMaterial();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim, class LocalParent>
 void MaterialNonLocal<dim, LocalParent>::insertIntegrationPointsInNeighborhoods(
     const GhostType & ghost_type,
     const ElementTypeMapReal & quadrature_points_coordinates) {
 
   IntegrationPoint q;
   q.ghost_type = ghost_type;
   q.kind = _ek_regular;
 
   auto & neighborhood =
       this->model.getNonLocalManager().getNeighborhood(this->name);
 
   for (auto & type :
        this->element_filter.elementTypes(dim, ghost_type, _ek_regular)) {
     q.type = type;
     const auto & elem_filter = this->element_filter(type, ghost_type);
-    UInt nb_element = elem_filter.getSize();
+    UInt nb_element = elem_filter.size();
 
     if (nb_element) {
       UInt nb_quad =
           this->getFEEngine().getNbIntegrationPoints(type, ghost_type);
 
       const auto & quads = quadrature_points_coordinates(type, ghost_type);
 
       auto nb_total_element =
           this->model.getMesh().getNbElement(type, ghost_type);
       auto quads_it = quads.begin_reinterpret(dim, nb_quad, nb_total_element);
       for (auto & elem : elem_filter) {
         Matrix<Real> quads = quads_it[elem];
         q.element = elem;
         for (UInt nq = 0; nq < nb_quad; ++nq) {
           q.num_point = nq;
           q.global_num = q.element * nb_quad + nq;
           neighborhood.insertIntegrationPoint(q, quads(nq));
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim, class LocalParent>
 void MaterialNonLocal<dim, LocalParent>::updateNonLocalInternals(
     ElementTypeMapReal & non_local_flattened, const ID & field_id,
     const GhostType & ghost_type, const ElementKind & kind) {
 
   /// loop over all types in the material
   for (auto & el_type :
        this->element_filter.elementTypes(dim, ghost_type, kind)) {
     Array<Real> & internal =
         this->template getInternal<Real>(field_id)(el_type, ghost_type);
 
     auto & internal_flat = non_local_flattened(el_type, ghost_type);
     auto nb_component = internal_flat.getNbComponent();
 
     auto internal_it = internal.begin(nb_component);
     auto internal_flat_it = internal_flat.begin(nb_component);
 
     /// loop all elements for the given type
     const auto & filter = this->element_filter(el_type, ghost_type);
     UInt nb_quads =
         this->getFEEngine().getNbIntegrationPoints(el_type, ghost_type);
     for (auto & elem : filter) {
       for (UInt q = 0; q < nb_quads; ++q, ++internal_it) {
         UInt global_quad = elem * nb_quads + q;
         *internal_it = internal_flat_it[global_quad];
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt dim, class LocalParent>
 void MaterialNonLocal<dim, LocalParent>::registerNeighborhood() {
   this->model.getNonLocalManager().registerNeighborhood(this->name, this->name);
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/materials/weight_functions/stress_based_weight_function.cc b/src/model/solid_mechanics/materials/weight_functions/stress_based_weight_function.cc
index c3e111249..e8e9108ba 100644
--- a/src/model/solid_mechanics/materials/weight_functions/stress_based_weight_function.cc
+++ b/src/model/solid_mechanics/materials/weight_functions/stress_based_weight_function.cc
@@ -1,117 +1,117 @@
 /**
  * @file   stress_based_weight_function.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Aug 24 2015
  * @date last modification: Wed Oct 07 2015
  *
  * @brief  implementation of the stres based weight function classes
  *
  * @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 "stress_based_weight_function.hh"
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 StressBasedWeightFunction::StressBasedWeightFunction(NonLocalManager & manager) :
   BaseWeightFunction(manager, "stress_based")
   // stress_diag("stress_diag", material), selected_stress_diag(NULL),
   // stress_base("stress_base", material), selected_stress_base(NULL),
   // characteristic_size("lc", material),  selected_characteristic_size(NULL) 
 {
 
   // this->registerParam("ft", this->ft, 0., _pat_parsable, "Tensile strength");
   // stress_diag.initialize(spatial_dimension);
   // stress_base.initialize(spatial_dimension * spatial_dimension);
   // characteristic_size.initialize(1);
 }
 
 /* -------------------------------------------------------------------------- */
 /// During intialization the characteristic sizes for all quadrature
 /// points are computed
 void StressBasedWeightFunction::init() {
   // const Mesh & mesh = this->material.getModel().getFEEngine().getMesh();
   // for (UInt g = _not_ghost; g <= _ghost; ++g) {
   //   GhostType gt = GhostType(g);
   //   Mesh::type_iterator it = mesh.firstType(spatial_dimension, gt);
   //   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, gt);
   //   for(; it != last_type; ++it) {
   //     UInt nb_quadrature_points =
   // 	this->material.getModel().getFEEngine().getNbQuadraturePoints(*it, gt);
   //     const Array<UInt> & element_filter = this->material.getElementFilter(*it, gt);
-  //     UInt nb_element = element_filter.getSize();
+  //     UInt nb_element = element_filter.size();
 
   //     Array<Real> ones(nb_element*nb_quadrature_points, 1, 1.);
   //     Array<Real> & lc = characteristic_size(*it, gt);
   //     this->material.getModel().getFEEngine().integrateOnQuadraturePoints(ones,
   // 								     lc,
   // 								     1,
   // 								     *it,
   // 								     gt,
   // 								     element_filter);
 
   //     for (UInt q = 0;  q < nb_quadrature_points * nb_element; q++) {
   // 	lc(q) = pow(lc(q), 1./ Real(spatial_dimension));
   //     }
   //   }
   // }
 }
 
 
 /* -------------------------------------------------------------------------- */
 /// computation of principals stresses and principal directions
 void StressBasedWeightFunction::updatePrincipalStress(__attribute__((unused)) GhostType ghost_type) {
 //   AKANTU_DEBUG_IN();
 
 //   const Mesh & mesh = this->material.getModel().getFEEngine().getMesh();
 
 //   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
 //   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
 //   for(; it != last_type; ++it) {
 //     Array<Real>::const_matrix_iterator sigma =
 //       this->material.getStress(*it, ghost_type).begin(spatial_dimension, spatial_dimension);
 //     Array<Real>::vector_iterator eigenvalues =
 //       stress_diag(*it, ghost_type).begin(spatial_dimension);
 //     Array<Real>::vector_iterator eigenvalues_end =
 //       stress_diag(*it, ghost_type).end(spatial_dimension);
 //     Array<Real>::matrix_iterator eigenvector =
 //       stress_base(*it, ghost_type).begin(spatial_dimension, spatial_dimension);
 
 // #ifndef __trick__
 //     Array<Real>::iterator<Real> cl = characteristic_size(*it, ghost_type).begin();
 // #endif
 //     UInt q = 0;
 //     for(;eigenvalues != eigenvalues_end; ++sigma, ++eigenvalues, ++eigenvector, ++cl, ++q) {
 //       sigma->eig(*eigenvalues, *eigenvector);
 //       *eigenvalues /= ft;
 // #ifndef __trick__
 //       // specify a lower bound for principal stress based on the size of the element
 //       for (UInt i = 0; i < spatial_dimension; ++i) {
 //         (*eigenvalues)(i) = std::max(*cl / this->R, (*eigenvalues)(i));
 //       }
 // #endif
 //     }
 //   }
 //   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model.cc b/src/model/solid_mechanics/solid_mechanics_model.cc
index 9570d37a6..da7a0280e 100644
--- a/src/model/solid_mechanics/solid_mechanics_model.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model.cc
@@ -1,1267 +1,1267 @@
 /**
  * @file   solid_mechanics_model.cc
  *
  * @author Ramin Aghababaei <ramin.aghababaei@epfl.ch>
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Implementation of the SolidMechanicsModel class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model.hh"
 #include "integrator_gauss.hh"
 #include "shape_lagrange.hh"
 
 #include "element_synchronizer.hh"
 #include "sparse_matrix.hh"
 #include "static_communicator.hh"
 #include "synchronizer_registry.hh"
 
 #include "dumpable_inline_impl.hh"
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_paraview.hh"
 #endif
 
 #include "material_non_local.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /**
  * A solid mechanics model need a mesh  and a dimension to be created. the model
  * by it  self can not  do a lot,  the good init  functions should be  called in
  * order to configure the model depending on what we want to do.
  *
  * @param  mesh mesh  representing  the model  we  want to  simulate
  * @param dim spatial  dimension of the problem, if dim =  0 (default value) the
  * dimension of the problem is assumed to be the on of the mesh
  * @param id an id to identify the model
  */
 SolidMechanicsModel::SolidMechanicsModel(Mesh & mesh, UInt dim, const ID & id,
                                          const MemoryID & memory_id)
     : Model(mesh, dim, id, memory_id), BoundaryCondition<SolidMechanicsModel>(),
       f_m2a(1.0), displacement(nullptr), previous_displacement(nullptr),
       displacement_increment(nullptr), mass(nullptr), velocity(nullptr),
       acceleration(nullptr), external_force(nullptr), internal_force(nullptr),
       blocked_dofs(nullptr), current_position(nullptr), mass_matrix(nullptr),
       velocity_damping_matrix(nullptr), stiffness_matrix(nullptr),
       jacobian_matrix(nullptr), material_index("material index", id, memory_id),
       material_local_numbering("material local numbering", id, memory_id),
       material_selector(new DefaultMaterialSelector(material_index)),
       is_default_material_selector(true), increment_flag(false),
       are_materials_instantiated(false) { //, pbc_synch(nullptr) {
   AKANTU_DEBUG_IN();
 
   this->registerFEEngineObject<MyFEEngineType>("SolidMechanicsFEEngine", mesh,
                                                Model::spatial_dimension);
 
   this->mesh.registerEventHandler(*this, _ehp_solid_mechanics_model);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("paraview_all", id, true);
   this->mesh.addDumpMesh(mesh, Model::spatial_dimension, _not_ghost,
                          _ek_regular);
 #endif
 
   this->initDOFManager();
 
   this->registerDataAccessor(*this);
 
   if (this->mesh.isDistributed()) {
     auto & synchronizer = this->mesh.getElementSynchronizer();
     this->registerSynchronizer(synchronizer, _gst_material_id);
     this->registerSynchronizer(synchronizer, _gst_smm_mass);
     this->registerSynchronizer(synchronizer, _gst_smm_stress);
     this->registerSynchronizer(synchronizer, _gst_smm_boundary);
     this->registerSynchronizer(synchronizer, _gst_for_dump);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModel::~SolidMechanicsModel() {
   AKANTU_DEBUG_IN();
 
   if (is_default_material_selector) {
     delete material_selector;
     material_selector = nullptr;
   }
 
   for (auto & internal : this->registered_internals) {
     delete internal.second;
   }
 
   //  delete pbc_synch;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::setTimeStep(Real time_step, const ID & solver_id) {
   Model::setTimeStep(time_step, solver_id);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper().setTimeStep(time_step);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 /* Initialization                                                             */
 /* -------------------------------------------------------------------------- */
 /**
  * This function groups  many of the initialization in on  function. For most of
  * basics  case the  function should  be  enough. The  functions initialize  the
  * model, the internal  vectors, set them to 0, and  depending on the parameters
  * it also initialize the explicit or implicit solver.
  *
  * @param material_file the  file containing the materials to  use
  * @param method the analysis method wanted.  See the akantu::AnalysisMethod for
  * the different possibilities
  */
 void SolidMechanicsModel::initFull(const ModelOptions & options) {
   Model::initFull(options);
 
   const SolidMechanicsModelOptions & smm_options =
       dynamic_cast<const SolidMechanicsModelOptions &>(options);
 
   this->method = smm_options.analysis_method;
 
   // initialize the vectors
   this->initArrays();
 
   if (!this->hasDefaultSolver())
     this->initNewSolver(this->method);
 
   // initialize pbc
   if (this->pbc_pair.size() != 0)
     this->initPBC();
 
   // initialize the materials
   if (this->parser->getLastParsedFile() != "") {
     this->instantiateMaterials();
   }
 
   //if (!smm_options.no_init_materials) {
   this->initMaterials();
   //}
 
   // if (increment_flag)
   this->initBC(*this, *displacement, *displacement_increment, *external_force);
   // else
   // this->initBC(*this, *displacement, *external_force);
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverType SolidMechanicsModel::getDefaultSolverType() const {
   return _tsst_dynamic_lumped;
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions SolidMechanicsModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case _tsst_dynamic_lumped: {
     options.non_linear_solver_type = _nls_lumped;
     options.integration_scheme_type["displacement"] = _ist_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case _tsst_static: {
     options.non_linear_solver_type = _nls_newton_raphson;
     options.integration_scheme_type["displacement"] = _ist_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   case _tsst_dynamic: {
     if (this->method == _explicit_consistent_mass) {
       options.non_linear_solver_type = _nls_newton_raphson;
       options.integration_scheme_type["displacement"] = _ist_central_difference;
       options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     } else {
       options.non_linear_solver_type = _nls_newton_raphson;
       options.integration_scheme_type["displacement"] = _ist_trapezoidal_rule_2;
       options.solution_type["displacement"] = IntegrationScheme::_displacement;
     }
     break;
   }
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initNewSolver(const AnalysisMethod & method) {
   ID solver_name;
   TimeStepSolverType tss_type;
 
   this->method = method;
 
   switch (this->method) {
   case _explicit_lumped_mass: {
     solver_name = "explicit_lumped";
     tss_type = _tsst_dynamic_lumped;
     break;
   }
   case _explicit_consistent_mass: {
     solver_name = "explicit";
     tss_type = _tsst_dynamic;
     break;
   }
   case _static: {
     solver_name = "static";
     tss_type = _tsst_static;
     break;
   }
   case _implicit_dynamic: {
     solver_name = "implicit";
     tss_type = _tsst_dynamic;
     break;
   }
   }
 
   if (!this->hasSolver(solver_name)) {
     ModelSolverOptions options = this->getDefaultSolverOptions(tss_type);
     this->getNewSolver(solver_name, tss_type, options.non_linear_solver_type);
     this->setIntegrationScheme(solver_name, "displacement",
                                options.integration_scheme_type["displacement"],
                                options.solution_type["displacement"]);
     this->setDefaultSolver(solver_name);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void SolidMechanicsModel::allocNodalField(Array<T> *& array, const ID & name) {
   if (array == nullptr) {
     UInt nb_nodes = mesh.getNbNodes();
     std::stringstream sstr_disp;
     sstr_disp << id << ":" << name;
 
     array =
         &(alloc<T>(sstr_disp.str(), nb_nodes, Model::spatial_dimension, T()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initSolver(
     TimeStepSolverType time_step_solver_type,
     __attribute__((unused)) NonLinearSolverType non_linear_solver_type) {
   DOFManager & dof_manager = this->getDOFManager();
 
   /* ------------------------------------------------------------------------ */
   // for alloc type of solvers
   this->allocNodalField(this->displacement, "displacement");
   this->allocNodalField(this->previous_displacement, "previous_displacement");
   this->allocNodalField(this->displacement_increment, "displacement_increment");
   this->allocNodalField(this->internal_force, "internal_force");
   this->allocNodalField(this->external_force, "external_force");
   this->allocNodalField(this->blocked_dofs, "blocked_dofs");
   this->allocNodalField(this->current_position, "current_position");
 
   // initialize the current positions
   this->current_position->copy(this->mesh.getNodes());
 
   /* ------------------------------------------------------------------------ */
   if (!dof_manager.hasDOFs("displacement")) {
     dof_manager.registerDOFs("displacement", *this->displacement, _dst_nodal);
     dof_manager.registerBlockedDOFs("displacement", *this->blocked_dofs);
     dof_manager.registerDOFsIncrement("displacement",
                                       *this->displacement_increment);
     dof_manager.registerDOFsPrevious("displacement",
                                      *this->previous_displacement);
   }
 
   /* ------------------------------------------------------------------------ */
   // for dynamic
   if (time_step_solver_type == _tsst_dynamic ||
       time_step_solver_type == _tsst_dynamic_lumped) {
     this->allocNodalField(this->velocity, "velocity");
     this->allocNodalField(this->acceleration, "acceleration");
 
     if (!dof_manager.hasDOFsDerivatives("displacement", 1)) {
       dof_manager.registerDOFsDerivative("displacement", 1, *this->velocity);
       dof_manager.registerDOFsDerivative("displacement", 2,
                                          *this->acceleration);
     }
   }
 
   if (time_step_solver_type == _tsst_dynamic ||
       time_step_solver_type == _tsst_static) {
     if (!dof_manager.hasMatrix("K")) {
       dof_manager.getNewMatrix("K", _symmetric);
     }
 
     if (!dof_manager.hasMatrix("J")) {
       dof_manager.getNewMatrix("J", "K");
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 // void SolidMechanicsModel::initParallel(MeshPartition & partition,
 //                                        DataAccessor<Element> * data_accessor)
 //                                        {
 //   AKANTU_DEBUG_IN();
 
 //   if (data_accessor == nullptr)
 //     data_accessor = this;
 //   synch_parallel = &createParallelSynch(partition, *data_accessor);
 
 //   synch_registry->registerSynchronizer(*synch_parallel, _gst_material_id);
 //   synch_registry->registerSynchronizer(*synch_parallel, _gst_smm_mass);
 //   synch_registry->registerSynchronizer(*synch_parallel, _gst_smm_stress);
 //   synch_registry->registerSynchronizer(*synch_parallel, _gst_smm_boundary);
 //   synch_registry->registerSynchronizer(*synch_parallel, _gst_for_dump);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initFEEngineBoundary() {
   FEEngine & fem_boundary = getFEEngineBoundary();
   fem_boundary.initShapeFunctions(_not_ghost);
   fem_boundary.initShapeFunctions(_ghost);
 
   fem_boundary.computeNormalsOnIntegrationPoints(_not_ghost);
   fem_boundary.computeNormalsOnIntegrationPoints(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Allocate all the needed vectors. By  default their are not necessarily set to
  * 0
  */
 void SolidMechanicsModel::initArrays() {
   AKANTU_DEBUG_IN();
 
   for (auto ghost_type : ghost_types) {
     for (auto type : mesh.elementTypes(Model::spatial_dimension, ghost_type,
                                        _ek_not_defined)) {
       UInt nb_element = mesh.getNbElement(type, ghost_type);
       this->material_index.alloc(nb_element, 1, type, ghost_type);
       this->material_local_numbering.alloc(nb_element, 1, type, ghost_type);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the model,basically it  pre-compute the shapes, shapes derivatives
  * and jacobian
  *
  */
 void SolidMechanicsModel::initModel() {
   /// \todo add  the current position  as a parameter to  initShapeFunctions for
   /// large deformation
   getFEEngine().initShapeFunctions(_not_ghost);
   getFEEngine().initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 // void SolidMechanicsModel::initPBC() {
 //   Model::initPBC();
 //   registerPBCSynchronizer();
 
 //   // as long as there are ones on the diagonal of the matrix, we can put
 //   // boudandary true for slaves
 //   std::map<UInt, UInt>::iterator it = pbc_pair.begin();
 //   std::map<UInt, UInt>::iterator end = pbc_pair.end();
 //   UInt dim = mesh.getSpatialDimension();
 //   while (it != end) {
 //     for (UInt i = 0; i < dim; ++i)
 //       (*blocked_dofs)((*it).first, i) = true;
 //     ++it;
 //   }
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void SolidMechanicsModel::registerPBCSynchronizer() {
 //   pbc_synch = new PBCSynchronizer(pbc_pair);
 //   synch_registry->registerSynchronizer(*pbc_synch, _gst_smm_uv);
 //   synch_registry->registerSynchronizer(*pbc_synch, _gst_smm_mass);
 //   synch_registry->registerSynchronizer(*pbc_synch, _gst_smm_res);
 //   synch_registry->registerSynchronizer(*pbc_synch, _gst_for_dump);
 //   //  changeLocalEquationNumberForPBC(pbc_pair, mesh.getSpatialDimension());
 // }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   /* ------------------------------------------------------------------------ */
   // computes the internal forces
   this->assembleInternalForces();
 
   /* ------------------------------------------------------------------------ */
   this->getDOFManager().assembleToResidual("displacement",
                                            *this->external_force, 1);
   this->getDOFManager().assembleToResidual("displacement",
                                            *this->internal_force, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleJacobian() {
   this->assembleStiffnessMatrix();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::predictor() { ++displacement_release; }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::corrector() { ++displacement_release; }
 
 /* -------------------------------------------------------------------------- */
 /**
  * This function computes the internal forces as F_{int} = \int_{\Omega} N
  * \sigma d\Omega@f$
  */
 void SolidMechanicsModel::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the internal forces");
 
   this->internal_force->clear();
 
   // compute the stresses of local elements
   AKANTU_DEBUG_INFO("Compute local stresses");
   for (auto & material : materials) {
     material->computeAllStresses(_not_ghost);
   }
 
 #ifdef AKANTU_DAMAGE_NON_LOCAL
   /* ------------------------------------------------------------------------ */
   /* Computation of the non local part */
   if(this->non_local_manager)
     this->non_local_manager->computeAllNonLocalStresses();
 #endif
 
   // communicate the stresses
   AKANTU_DEBUG_INFO("Send data for residual assembly");
   this->asynchronousSynchronize(_gst_smm_stress);
 
   // assemble the forces due to local stresses
   AKANTU_DEBUG_INFO("Assemble residual for local elements");
   for (auto & material : materials) {
     material->assembleInternalForces(_not_ghost);
   }
 
   // finalize communications
   AKANTU_DEBUG_INFO("Wait distant stresses");
   this->waitEndSynchronize(_gst_smm_stress);
 
   // assemble the stresses due to ghost elements
   AKANTU_DEBUG_INFO("Assemble residual for ghost elements");
   for (auto & material : materials) {
     material->assembleInternalForces(_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix.");
 
   // Check if materials need to recompute the matrix
   bool need_to_reassemble = false;
 
   for (auto & material : materials) {
     need_to_reassemble |= material->hasStiffnessMatrixChanged();
   }
 
   if (need_to_reassemble) {
     this->getDOFManager().getMatrix("K").clear();
 
     // call compute stiffness matrix on each local elements
     for (auto & material : materials) {
       material->assembleStiffnessMatrix(_not_ghost);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateCurrentPosition() {
   if (this->current_position_release == this->displacement_release)
     return;
 
   this->current_position->copy(this->mesh.getNodes());
 
   auto cpos_it = this->current_position->begin(Model::spatial_dimension);
   auto cpos_end = this->current_position->end(Model::spatial_dimension);
   auto disp_it = this->displacement->begin(Model::spatial_dimension);
 
   for (; cpos_it != cpos_end; ++cpos_it, ++disp_it) {
     *cpos_it += *disp_it;
   }
 
   this->current_position_release = this->displacement_release;
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & SolidMechanicsModel::getCurrentPosition() {
   this->updateCurrentPosition();
   return *this->current_position;
 }
 
 /* -------------------------------------------------------------------------- */
 // void SolidMechanicsModel::initializeUpdateResidualData() {
 //   AKANTU_DEBUG_IN();
 //   UInt nb_nodes = mesh.getNbNodes();
 //   internal_force->resize(nb_nodes);
 
 //   /// copy the forces in residual for boundary conditions
 //   this->getDOFManager().assembleToResidual("displacement",
 //                                            *this->external_force);
 
 //   // start synchronization
 //   this->asynchronousSynchronize(_gst_smm_uv);
 //   this->waitEndSynchronize(_gst_smm_uv);
 
 //   this->updateCurrentPosition();
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 /* Explicit scheme                                                            */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 // void SolidMechanicsModel::computeStresses() {
 //   if (isExplicit()) {
 //     // start synchronization
 //     this->asynchronousSynchronize(_gst_smm_uv);
 //     this->waitEndSynchronize(_gst_smm_uv);
 
 //     // compute stresses on all local elements for each materials
 //     std::vector<Material *>::iterator mat_it;
 //     for (mat_it = materials.begin(); mat_it != materials.end(); ++mat_it) {
 //       Material & mat = **mat_it;
 //       mat.computeAllStresses(_not_ghost);
 //     }
 
 // #ifdef AKANTU_DAMAGE_NON_LOCAL
 //     /* Computation of the non local part */
 //     this->non_local_manager->computeAllNonLocalStresses();
 // #endif
 //   } else {
 //     std::vector<Material *>::iterator mat_it;
 //     for (mat_it = materials.begin(); mat_it != materials.end(); ++mat_it) {
 //       Material & mat = **mat_it;
 //       mat.computeAllStressesFromTangentModuli(_not_ghost);
 //     }
 //   }
 // }
 
 /* -------------------------------------------------------------------------- */
 /* Implicit scheme                                                            */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 // /**
 //  * Initialize the solver and create the sparse matrices needed.
 //  *
 //  */
 // void SolidMechanicsModel::initSolver(__attribute__((unused))
 //                                      SolverOptions & options) {
 //   UInt nb_global_nodes = mesh.getNbGlobalNodes();
 
 //   jacobian_matrix = &(this->getDOFManager().getNewMatrix("jacobian",
 //   _symmetric));
 
 //   //  jacobian_matrix->buildProfile(mesh, *dof_synchronizer,
 //   spatial_dimension);
 
 //   if (!isExplicit()) {
 //     delete stiffness_matrix;
 //     std::stringstream sstr_sti;
 //     sstr_sti << id << ":stiffness_matrix";
 
 //     stiffness_matrix = &(this->getDOFManager().getNewMatrix("stiffness",
 //     _symmetric));
 //   }
 
 //   if (solver) solver->initialize(options);
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void SolidMechanicsModel::initJacobianMatrix() {
 //   // @todo make it more flexible: this is an ugly patch to treat the case of
 //   non
 //   // fix profile of the K matrix
 //   delete jacobian_matrix;
 
 //   jacobian_matrix = &(this->getDOFManager().getNewMatrix("jacobian",
 //   "stiffness"));
 
 //   std::stringstream sstr_solv; sstr_solv << id << ":solver";
 //   delete solver;
 //   solver = new SolverMumps(*jacobian_matrix, sstr_solv.str());
 //   if(solver)
 //     solver->initialize(_solver_no_options);
 // }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the implicit solver, either for dynamic or static cases,
  *
  * @param dynamic
  */
 // void SolidMechanicsModel::initImplicit(bool dynamic) {
 //   AKANTU_DEBUG_IN();
 
 //   method = dynamic ? _implicit_dynamic : _static;
 
 //   if (!increment)
 //     setIncrementFlagOn();
 
 //   initSolver();
 
 //   // if(method == _implicit_dynamic) {
 //   //   if(integrator) delete integrator;
 //   //   integrator = new TrapezoidalRule2();
 //   // }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 // SparseMatrix & SolidMechanicsModel::initVelocityDampingMatrix() {
 //   return this->getDOFManager().getNewMatrix("velocity_damping", "jacobian");
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void SolidMechanicsModel::implicitPred() {
 //   AKANTU_DEBUG_IN();
 
 //   if(previous_displacement) previous_displacement->copy(*displacement);
 
 //   if(method == _implicit_dynamic)
 //     integrator->integrationSchemePred(time_step,
 //                                    *displacement,
 //                                    *velocity,
 //                                    *acceleration,
 //                                    *blocked_dofs);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 // /* --------------------------------------------------------------------------
 // */
 // void SolidMechanicsModel::implicitCorr() {
 //   AKANTU_DEBUG_IN();
 
 //   if(method == _implicit_dynamic) {
 //     integrator->integrationSchemeCorrDispl(time_step,
 //                                         *displacement,
 //                                         *velocity,
 //                                         *acceleration,
 //                                         *blocked_dofs,
 //                                         *increment);
 //   } else {
-//     UInt nb_nodes = displacement->getSize();
+//     UInt nb_nodes = displacement->size();
 //     UInt nb_degree_of_freedom = displacement->getNbComponent() * nb_nodes;
 
 //     Real * incr_val = increment->storage();
 //     Real * disp_val = displacement->storage();
 //     bool * boun_val = blocked_dofs->storage();
 
 //     for (UInt j = 0; j < nb_degree_of_freedom; ++j, ++disp_val, ++incr_val,
 //     ++boun_val){
 //       *incr_val *= (1. - *boun_val);
 //       *disp_val += *incr_val;
 //     }
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 // void SolidMechanicsModel::updateIncrement() {
 //   AKANTU_DEBUG_IN();
 
 //   auto incr_it = this->displacement_increment->begin(spatial_dimension);
 //   auto incr_end = this->displacement_increment->end(spatial_dimension);
 //   auto disp_it = this->displacement->begin(spatial_dimension);
 //   auto prev_disp_it = this->previous_displacement->begin(spatial_dimension);
 
 //   for (; incr_it != incr_end; ++incr_it) {
 //     *incr_it = *disp_it;
 //     *incr_it -= *prev_disp_it;
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 // /* --------------------------------------------------------------------------
 // */ void SolidMechanicsModel::updatePreviousDisplacement() {
 //   AKANTU_DEBUG_IN();
 
 //   AKANTU_DEBUG_ASSERT(
 //       previous_displacement,
 //       "The previous displacement has to be initialized."
 //           << " Are you working with Finite or Ineslactic deformations?");
 
 //   previous_displacement->copy(*displacement);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateDataForNonLocalCriterion(
     ElementTypeMapReal & criterion) {
   const ID field_name = criterion.getName();
   for (auto & material : materials) {
     if (!material->isInternal<Real>(field_name, _ek_regular))
       continue;
 
     for (auto ghost_type : ghost_types) {
       material->flattenInternal(field_name, criterion, ghost_type, _ek_regular);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /* Information                                                                */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 // void SolidMechanicsModel::synchronizeBoundaries() {
 //   AKANTU_DEBUG_IN();
 //   this->synchronize(_gst_smm_boundary);
 //   AKANTU_DEBUG_OUT();
 // }
 
 // /* --------------------------------------------------------------------------
 // */ void SolidMechanicsModel::synchronizeResidual() {
 //   AKANTU_DEBUG_IN();
 //   this->synchronize(_gst_smm_res);
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 // void SolidMechanicsModel::setIncrementFlagOn() {
 //   AKANTU_DEBUG_IN();
 
 //   if (!displacement_increment) {
 //     this->allocNodalField(displacement_increment, spatial_dimension,
 //                           "displacement_increment");
 
 //     this->getDOFManager().registerDOFsIncrement("displacement",
 //                                                 *this->displacement_increment);
 //   }
 
 //   increment_flag = true;
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getStableTimeStep() {
   AKANTU_DEBUG_IN();
 
   Real min_dt = getStableTimeStep(_not_ghost);
 
   /// reduction min over all processors
   StaticCommunicator::getStaticCommunicator().allReduce(min_dt, _so_min);
 
   AKANTU_DEBUG_OUT();
   return min_dt;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getStableTimeStep(const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   Real min_dt = std::numeric_limits<Real>::max();
 
   this->updateCurrentPosition();
 
   Element elem;
   elem.ghost_type = ghost_type;
   elem.kind = _ek_regular;
 
   for (auto type :
        mesh.elementTypes(Model::spatial_dimension, ghost_type, _ek_regular)) {
     elem.type = type;
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
     UInt nb_element = mesh.getNbElement(type);
 
     auto mat_indexes = material_index(type, ghost_type).begin();
     auto mat_loc_num = material_local_numbering(type, ghost_type).begin();
 
     Array<Real> X(0, nb_nodes_per_element * Model::spatial_dimension);
     FEEngine::extractNodalToElementField(mesh, *current_position, X, type,
                                          _not_ghost);
 
     auto X_el = X.begin(Model::spatial_dimension, nb_nodes_per_element);
 
     for (UInt el = 0; el < nb_element;
          ++el, ++X_el, ++mat_indexes, ++mat_loc_num) {
       elem.element = *mat_loc_num;
       Real el_h = getFEEngine().getElementInradius(*X_el, type);
       Real el_c = this->materials[*mat_indexes]->getCelerity(elem);
       Real el_dt = el_h / el_c;
 
       min_dt = std::min(min_dt, el_dt);
     }
   }
 
   AKANTU_DEBUG_OUT();
   return min_dt;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getKineticEnergy() {
   AKANTU_DEBUG_IN();
 
   Real ekin = 0.;
   UInt nb_nodes = mesh.getNbNodes();
 
   if (this->getDOFManager().hasLumpedMatrix("M")) {
     auto m_it = this->mass->begin(Model::spatial_dimension);
     auto m_end = this->mass->end(Model::spatial_dimension);
     auto v_it = this->velocity->begin(Model::spatial_dimension);
 
     for (UInt n = 0; m_it != m_end; ++n, ++m_it, ++v_it) {
       const Vector<Real> & v = *v_it;
       const Vector<Real> & m = *m_it;
 
       Real mv2 = 0;
       bool is_local_node = mesh.isLocalOrMasterNode(n);
       // bool is_not_pbc_slave_node = !isPBCSlaveNode(n);
       bool count_node = is_local_node; // && is_not_pbc_slave_node;
       if (count_node) {
         for (UInt i = 0; i < Model::spatial_dimension; ++i) {
           if (m(i) > std::numeric_limits<Real>::epsilon())
             mv2 += v(i) * v(i) * m(i);
         }
       }
 
       ekin += mv2;
     }
   } else if (this->getDOFManager().hasMatrix("M")) {
     Array<Real> Mv(nb_nodes, Model::spatial_dimension);
     this->getDOFManager().getMatrix("M").matVecMul(*this->velocity, Mv);
 
     auto mv_it = Mv.begin(Model::spatial_dimension);
     auto mv_end = Mv.end(Model::spatial_dimension);
     auto v_it = this->velocity->begin(Model::spatial_dimension);
 
     for (; mv_it != mv_end; ++mv_it, ++v_it) {
       ekin += v_it->dot(*mv_it);
     }
   } else {
     AKANTU_DEBUG_ERROR("No function called to assemble the mass matrix.");
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(ekin, _so_sum);
 
   AKANTU_DEBUG_OUT();
   return ekin * .5;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getKineticEnergy(const ElementType & type,
                                            UInt index) {
   AKANTU_DEBUG_IN();
 
   UInt nb_quadrature_points = getFEEngine().getNbIntegrationPoints(type);
 
   Array<Real> vel_on_quad(nb_quadrature_points, Model::spatial_dimension);
   Array<UInt> filter_element(1, 1, index);
 
   getFEEngine().interpolateOnIntegrationPoints(*velocity, vel_on_quad,
                                                Model::spatial_dimension, type,
                                                _not_ghost, filter_element);
 
   Array<Real>::vector_iterator vit =
       vel_on_quad.begin(Model::spatial_dimension);
   Array<Real>::vector_iterator vend = vel_on_quad.end(Model::spatial_dimension);
 
   Vector<Real> rho_v2(nb_quadrature_points);
 
   Real rho = materials[material_index(type)(index)]->getRho();
 
   for (UInt q = 0; vit != vend; ++vit, ++q) {
     rho_v2(q) = rho * vit->dot(*vit);
   }
 
   AKANTU_DEBUG_OUT();
 
   return .5 * getFEEngine().integrate(rho_v2, type, index);
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getExternalWork() {
   AKANTU_DEBUG_IN();
 
   auto incr_or_velo_it = this->velocity->begin(Model::spatial_dimension);
   if (this->method == _static) {
     incr_or_velo_it =
         this->displacement_increment->begin(Model::spatial_dimension);
   }
 
   auto ext_force_it = external_force->begin(Model::spatial_dimension);
   auto int_force_it = internal_force->begin(Model::spatial_dimension);
   auto boun_it = blocked_dofs->begin(Model::spatial_dimension);
 
   Real work = 0.;
 
   UInt nb_nodes = this->mesh.getNbNodes();
 
   for (UInt n = 0; n < nb_nodes;
        ++n, ++ext_force_it, ++int_force_it, ++boun_it, ++incr_or_velo_it) {
     const auto & int_force = *int_force_it;
     const auto & ext_force = *ext_force_it;
     const auto & boun = *boun_it;
     const auto & incr_or_velo = *incr_or_velo_it;
 
     bool is_local_node = this->mesh.isLocalOrMasterNode(n);
     // bool is_not_pbc_slave_node = !this->isPBCSlaveNode(n);
     bool count_node = is_local_node; // && is_not_pbc_slave_node;
 
     if (count_node) {
       for (UInt i = 0; i < Model::spatial_dimension; ++i) {
         if (boun(i))
           work -= int_force(i) * incr_or_velo(i);
         else
           work += ext_force(i) * incr_or_velo(i);
       }
     }
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(work, _so_sum);
 
   if (this->method != _static)
     work *= this->getTimeStep();
   AKANTU_DEBUG_OUT();
   return work;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getEnergy(const std::string & energy_id) {
   AKANTU_DEBUG_IN();
 
   if (energy_id == "kinetic") {
     return getKineticEnergy();
   } else if (energy_id == "external work") {
     return getExternalWork();
   }
 
   Real energy = 0.;
   for (auto & material : materials)
     energy += material->getEnergy(energy_id);
 
   /// reduction sum over all processors
   StaticCommunicator::getStaticCommunicator().allReduce(energy, _so_sum);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getEnergy(const std::string & energy_id,
                                     const ElementType & type, UInt index) {
   AKANTU_DEBUG_IN();
 
   if (energy_id == "kinetic") {
     return getKineticEnergy(type, index);
   }
 
   UInt mat_index = this->material_index(type, _not_ghost)(index);
   UInt mat_loc_num = this->material_local_numbering(type, _not_ghost)(index);
   Real energy =
       this->materials[mat_index]->getEnergy(energy_id, type, mat_loc_num);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onElementsAdded(const Array<Element> & element_list,
                                           const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   for (auto ghost_type : ghost_types) {
     for (auto type : mesh.elementTypes(Model::spatial_dimension, ghost_type,
                                        _ek_not_defined)) {
       UInt nb_element = this->mesh.getNbElement(type, ghost_type);
 
       if (!material_index.exists(type, ghost_type)) {
         this->material_index.alloc(nb_element, 1, type, ghost_type);
         this->material_local_numbering.alloc(nb_element, 1, type, ghost_type);
       } else {
         this->material_index(type, ghost_type).resize(nb_element);
         this->material_local_numbering(type, ghost_type).resize(nb_element);
       }
     }
   }
 
   ElementTypeMapArray<UInt> filter("new_element_filter", this->getID(),
                                    this->getMemoryID());
 
   for (auto & elem : element_list) {
     if (!filter.exists(elem.type, elem.ghost_type))
       filter.alloc(0, 1, elem.type, elem.ghost_type);
 
     filter(elem.type, elem.ghost_type).push_back(elem.element);
   }
 
   this->assignMaterialToElements(&filter);
 
   for (auto & material : materials)
     material->onElementsAdded(element_list, event);
 
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onElementsRemoved(
     __attribute__((unused)) const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     const RemovedElementsEvent & event) {
   this->getFEEngine().initShapeFunctions(_not_ghost);
   this->getFEEngine().initShapeFunctions(_ghost);
 
   for (auto & material : materials) {
     material->onElementsRemoved(element_list, new_numbering, event);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onNodesAdded(const Array<UInt> & nodes_list,
                                        __attribute__((unused))
                                        const NewNodesEvent & event) {
   AKANTU_DEBUG_IN();
   UInt nb_nodes = mesh.getNbNodes();
 
   if (displacement) {
     displacement->resize(nb_nodes, 0.);
     ++displacement_release;
   }
   if (mass)
     mass->resize(nb_nodes, 0.);
   if (velocity)
     velocity->resize(nb_nodes, 0.);
   if (acceleration)
     acceleration->resize(nb_nodes, 0.);
   if (external_force)
     external_force->resize(nb_nodes, 0.);
   if (internal_force)
     internal_force->resize(nb_nodes, 0.);
   if (blocked_dofs)
     blocked_dofs->resize(nb_nodes, 0.);
   if (current_position)
     current_position->resize(nb_nodes, 0.);
 
   if (previous_displacement)
     previous_displacement->resize(nb_nodes, 0.);
   if (displacement_increment)
     displacement_increment->resize(nb_nodes, 0.);
 
   for (auto & material : materials) {
     material->onNodesAdded(nodes_list, event);
   }
 
   if(this->getDOFManager().hasMatrix("M")) {
     this->assembleMass(nodes_list);
   }
 
   if(this->getDOFManager().hasLumpedMatrix("M")) {
     this->assembleMassLumped(nodes_list);
   }
 
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onNodesRemoved(__attribute__((unused))
                                          const Array<UInt> & element_list,
                                          const Array<UInt> & new_numbering,
                                          __attribute__((unused))
                                          const RemovedNodesEvent & event) {
   if (displacement) {
     mesh.removeNodesFromArray(*displacement, new_numbering);
     ++displacement_release;
   }
   if (mass)
     mesh.removeNodesFromArray(*mass, new_numbering);
   if (velocity)
     mesh.removeNodesFromArray(*velocity, new_numbering);
   if (acceleration)
     mesh.removeNodesFromArray(*acceleration, new_numbering);
   if (internal_force)
     mesh.removeNodesFromArray(*internal_force, new_numbering);
   if (external_force)
     mesh.removeNodesFromArray(*external_force, new_numbering);
   if (blocked_dofs)
     mesh.removeNodesFromArray(*blocked_dofs, new_numbering);
 
   // if (increment_acceleration)
   //   mesh.removeNodesFromArray(*increment_acceleration, new_numbering);
   if (displacement_increment)
     mesh.removeNodesFromArray(*displacement_increment, new_numbering);
 
   if (previous_displacement)
     mesh.removeNodesFromArray(*previous_displacement, new_numbering);
 
   // if (method != _explicit_lumped_mass) {
   //   this->initSolver();
   // }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "Solid Mechanics Model [" << std::endl;
   stream << space << " + id                : " << id << std::endl;
   stream << space << " + spatial dimension : " << Model::spatial_dimension
          << std::endl;
   stream << space << " + fem [" << std::endl;
   getFEEngine().printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
   stream << space << " + nodals information [" << std::endl;
   displacement->printself(stream, indent + 2);
   mass->printself(stream, indent + 2);
   velocity->printself(stream, indent + 2);
   acceleration->printself(stream, indent + 2);
   external_force->printself(stream, indent + 2);
   internal_force->printself(stream, indent + 2);
   blocked_dofs->printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << " + material information [" << std::endl;
   material_index.printself(stream, indent + 2);
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << " + materials [" << std::endl;
   for (auto & material : materials) {
     material->printself(stream, indent + 1);
   }
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::insertIntegrationPointsInNeighborhoods(
     const GhostType & ghost_type) {
   for (auto & mat : materials) {
     try {
       ElementTypeMapArray<Real> quadrature_points_coordinates(
           "quadrature_points_coordinates_tmp_nl", this->id, this->memory_id);
       quadrature_points_coordinates.initialize(
           this->getFEEngine(), _spatial_dimension = Model::spatial_dimension,
           _nb_component = Model::spatial_dimension, _ghost_type = ghost_type);
       for (auto & type : quadrature_points_coordinates.elementTypes(
                Model::spatial_dimension, ghost_type)) {
         this->getFEEngine().computeIntegrationPointsCoordinates(
             quadrature_points_coordinates(type, ghost_type), type, ghost_type);
       }
 
       auto & mat_non_local = dynamic_cast<MaterialNonLocalInterface &>(*mat);
       mat_non_local.insertIntegrationPointsInNeighborhoods(
           ghost_type, quadrature_points_coordinates);
     } catch (std::bad_cast &) {
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::computeNonLocalStresses(
     const GhostType & ghost_type) {
   for (auto & mat : materials) {
     try {
       auto & mat_non_local = dynamic_cast<MaterialNonLocalInterface &>(*mat);
       mat_non_local.computeNonLocalStresses(ghost_type);
     } catch (std::bad_cast &) {
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateLocalInternal(
     ElementTypeMapReal & internal_flat, const GhostType & ghost_type,
     const ElementKind & kind) {
   const ID field_name = internal_flat.getName();
   for (auto & material : materials) {
     if (material->isInternal<Real>(field_name, kind))
       material->flattenInternal(field_name, internal_flat, ghost_type, kind);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateNonLocalInternal(
     ElementTypeMapReal & internal_flat, const GhostType & ghost_type,
     const ElementKind & kind) {
 
   const ID field_name = internal_flat.getName();
 
   for (auto & mat : materials) {
     try {
       auto & mat_non_local = dynamic_cast<MaterialNonLocalInterface &>(*mat);
       mat_non_local.updateNonLocalInternals(internal_flat, field_name,
                                             ghost_type, kind);
     } catch (std::bad_cast &) {
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & SolidMechanicsModel::getFEEngineBoundary(const ID & name) {
   return dynamic_cast<FEEngine &>(
       getFEEngineClassBoundary<MyFEEngineType>(name));
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/fragment_manager.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/fragment_manager.cc
index 979a6c0f4..daf1d456b 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/fragment_manager.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/fragment_manager.cc
@@ -1,615 +1,615 @@
 /**
  * @file   fragment_manager.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Thu Jan 23 2014
  * @date last modification: Mon Dec 14 2015
  *
  * @brief  Group manager to handle fragments
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fragment_manager.hh"
 #include "aka_iterators.hh"
 #include "material_cohesive.hh"
 #include "mesh_iterators.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <functional>
 #include <numeric>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 FragmentManager::FragmentManager(SolidMechanicsModelCohesive & model,
                                  bool dump_data, const ID & id,
                                  const MemoryID & memory_id)
     : GroupManager(model.getMesh(), id, memory_id), model(model),
       mass_center(0, model.getSpatialDimension(), "mass_center"),
       mass(0, model.getSpatialDimension(), "mass"),
       velocity(0, model.getSpatialDimension(), "velocity"),
       inertia_moments(0, model.getSpatialDimension(), "inertia_moments"),
       principal_directions(
           0, model.getSpatialDimension() * model.getSpatialDimension(),
           "principal_directions"),
       quad_coordinates("quad_coordinates", id),
       mass_density("mass_density", id),
       nb_elements_per_fragment(0, 1, "nb_elements_per_fragment"),
       dump_data(dump_data) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   /// compute quadrature points' coordinates
   quad_coordinates.initialize(mesh, _nb_component = spatial_dimension,
                               _spatial_dimension = spatial_dimension,
                               _ghost_type = _not_ghost);
   // mesh.initElementTypeMapArray(quad_coordinates, spatial_dimension,
   //                              spatial_dimension, _not_ghost);
 
   model.getFEEngine().interpolateOnIntegrationPoints(model.getMesh().getNodes(),
                                                      quad_coordinates);
 
   /// store mass density per quadrature point
   mass_density.initialize(mesh, _spatial_dimension = spatial_dimension,
                           _ghost_type = _not_ghost);
   // mesh.initElementTypeMapArray(mass_density, 1, spatial_dimension,
   // _not_ghost);
 
   storeMassDensityPerIntegrationPoint();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 class CohesiveElementFilter : public GroupManager::ClusteringFilter {
 public:
   CohesiveElementFilter(const SolidMechanicsModelCohesive & model,
                         const Real max_damage = 1.)
       : model(model), is_unbroken(max_damage) {}
 
   bool operator()(const Element & el) const {
     if (el.kind == _ek_regular)
       return true;
 
     const Array<UInt> & mat_indexes =
         model.getMaterialByElement(el.type, el.ghost_type);
     const Array<UInt> & mat_loc_num =
         model.getMaterialLocalNumbering(el.type, el.ghost_type);
 
     const MaterialCohesive & mat = static_cast<const MaterialCohesive &>(
         model.getMaterial(mat_indexes(el.element)));
 
     UInt el_index = mat_loc_num(el.element);
     UInt nb_quad_per_element =
         model.getFEEngine("CohesiveFEEngine")
             .getNbIntegrationPoints(el.type, el.ghost_type);
 
     const Array<Real> & damage_array = mat.getDamage(el.type, el.ghost_type);
 
-    AKANTU_DEBUG_ASSERT(nb_quad_per_element * el_index < damage_array.getSize(),
+    AKANTU_DEBUG_ASSERT(nb_quad_per_element * el_index < damage_array.size(),
                         "This quadrature point is out of range");
 
     const Real * element_damage =
         damage_array.storage() + nb_quad_per_element * el_index;
 
     UInt unbroken_quads = std::count_if(
         element_damage, element_damage + nb_quad_per_element, is_unbroken);
 
     if (unbroken_quads > 0)
       return true;
     return false;
   }
 
 private:
   struct IsUnbrokenFunctor {
     IsUnbrokenFunctor(const Real & max_damage) : max_damage(max_damage) {}
     bool operator()(const Real & x) { return x < max_damage; }
     const Real max_damage;
   };
 
   const SolidMechanicsModelCohesive & model;
   const IsUnbrokenFunctor is_unbroken;
 };
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::buildFragments(Real damage_limit) {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   ElementSynchronizer * cohesive_synchronizer =
       const_cast<ElementSynchronizer *>(model.getCohesiveSynchronizer());
 
   if (cohesive_synchronizer) {
     cohesive_synchronizer->computeBufferSize(model, _gst_smmc_damage);
     cohesive_synchronizer->asynchronousSynchronize(model, _gst_smmc_damage);
     cohesive_synchronizer->waitEndSynchronize(model, _gst_smmc_damage);
   }
 #endif
 
   auto & mesh_facets = const_cast<Mesh &>(mesh.getMeshFacets());
 
   UInt spatial_dimension = model.getSpatialDimension();
   std::string fragment_prefix("fragment");
 
   /// generate fragments
   global_nb_fragment =
       createClusters(spatial_dimension, mesh_facets, fragment_prefix,
                      CohesiveElementFilter(model, damage_limit));
 
   nb_fragment = getNbElementGroups(spatial_dimension);
   fragment_index.resize(nb_fragment);
 
   UInt * fragment_index_it = fragment_index.storage();
 
   /// loop over fragments
   for (const_element_group_iterator it(element_group_begin());
        it != element_group_end(); ++it, ++fragment_index_it) {
 
     /// get fragment index
     std::string fragment_index_string =
         it->first.substr(fragment_prefix.size() + 1);
     std::stringstream sstr(fragment_index_string.c_str());
     sstr >> *fragment_index_it;
 
     AKANTU_DEBUG_ASSERT(!sstr.fail(), "fragment_index is not an integer");
   }
 
   /// compute fragments' mass
   computeMass();
 
   if (dump_data) {
     createDumpDataArray(fragment_index, "fragments", true);
     createDumpDataArray(mass, "fragments mass");
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::computeMass() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   /// create a unit field per quadrature point, since to compute mass
   /// it's neccessary to integrate only density
   ElementTypeMapArray<Real> unit_field("unit_field", id);
   unit_field.initialize(model.getFEEngine(), _nb_component = spatial_dimension,
                         _spatial_dimension = spatial_dimension,
                         _ghost_type = _not_ghost, _default_value = 1.);
   // mesh.initElementTypeMapArray(unit_field, spatial_dimension,
   // spatial_dimension,
   //                              _not_ghost);
 
   // ElementTypeMapArray<Real>::type_iterator it =
   //     unit_field.firstType(spatial_dimension, _not_ghost, _ek_regular);
   // ElementTypeMapArray<Real>::type_iterator end =
   //     unit_field.lastType(spatial_dimension, _not_ghost, _ek_regular);
 
   // for (; it != end; ++it) {
   //   ElementType type = *it;
   //   Array<Real> & field_array = unit_field(type);
   //   UInt nb_element = mesh.getNbElement(type);
   //   UInt nb_quad_per_element =
   //   model.getFEEngine().getNbIntegrationPoints(type);
 
   //   field_array.resize(nb_element * nb_quad_per_element);
   //   field_array.set(1.);
   // }
 
   integrateFieldOnFragments(unit_field, mass);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::computeCenterOfMass() {
   AKANTU_DEBUG_IN();
 
   /// integrate position multiplied by density
   integrateFieldOnFragments(quad_coordinates, mass_center);
 
   /// divide it by the fragments' mass
   Real * mass_storage = mass.storage();
   Real * mass_center_storage = mass_center.storage();
 
-  UInt total_components = mass_center.getSize() * mass_center.getNbComponent();
+  UInt total_components = mass_center.size() * mass_center.getNbComponent();
 
   for (UInt i = 0; i < total_components; ++i)
     mass_center_storage[i] /= mass_storage[i];
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::computeVelocity() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   /// compute velocity per quadrature point
   ElementTypeMapArray<Real> velocity_field("velocity_field", id);
   velocity_field.initialize(
       model.getFEEngine(), _nb_component = spatial_dimension,
       _spatial_dimension = spatial_dimension, _ghost_type = _not_ghost);
 
   // mesh.initElementTypeMapArray(velocity_field, spatial_dimension,
   //                              spatial_dimension, _not_ghost);
 
   model.getFEEngine().interpolateOnIntegrationPoints(model.getVelocity(),
                                                      velocity_field);
 
   /// integrate on fragments
   integrateFieldOnFragments(velocity_field, velocity);
 
   /// divide it by the fragments' mass
   Real * mass_storage = mass.storage();
   Real * velocity_storage = velocity.storage();
 
-  UInt total_components = velocity.getSize() * velocity.getNbComponent();
+  UInt total_components = velocity.size() * velocity.getNbComponent();
 
   for (UInt i = 0; i < total_components; ++i)
     velocity_storage[i] /= mass_storage[i];
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Given the distance @f$ \mathbf{r} @f$ between a quadrature point
  * and its center of mass, the moment of inertia is computed as \f[
  * I_\mathrm{CM} = \mathrm{tr}(\mathbf{r}\mathbf{r}^\mathrm{T})
  * \mathbf{I} - \mathbf{r}\mathbf{r}^\mathrm{T} \f] for more
  * information check Wikipedia
  * (http://en.wikipedia.org/wiki/Moment_of_inertia#Identities_for_a_skew-symmetric_matrix)
  *
  */
 
 void FragmentManager::computeInertiaMoments() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   computeCenterOfMass();
 
   /// compute local coordinates products with respect to the center of match
   ElementTypeMapArray<Real> moments_coords("moments_coords", id);
   moments_coords.initialize(model.getFEEngine(),
                             _nb_component =
                                 spatial_dimension * spatial_dimension,
                             _spatial_dimension = spatial_dimension,
                             _ghost_type = _not_ghost, _default_value = 1.);
 
   // mesh.initElementTypeMapArray(moments_coords,
   //                              spatial_dimension * spatial_dimension,
   //                              spatial_dimension, _not_ghost);
 
   // /// resize the by element type
   // ElementTypeMapArray<Real>::type_iterator it =
   //     moments_coords.firstType(spatial_dimension, _not_ghost, _ek_regular);
   // ElementTypeMapArray<Real>::type_iterator end =
   //     moments_coords.lastType(spatial_dimension, _not_ghost, _ek_regular);
 
   // for (; it != end; ++it) {
   //   ElementType type = *it;
   //   Array<Real> & field_array = moments_coords(type);
   //   UInt nb_element = mesh.getNbElement(type);
   //   UInt nb_quad_per_element =
   //   model.getFEEngine().getNbIntegrationPoints(type);
 
   //   field_array.resize(nb_element * nb_quad_per_element);
   // }
 
   /// compute coordinates
   Array<Real>::const_vector_iterator mass_center_it =
       mass_center.begin(spatial_dimension);
 
   /// loop over fragments
   for (const_element_group_iterator it(element_group_begin());
        it != element_group_end(); ++it, ++mass_center_it) {
 
     const ElementTypeMapArray<UInt> & el_list = it->second->getElements();
     /// loop over elements of the fragment
     for (auto type :
          el_list.elementTypes(spatial_dimension, _not_ghost, _ek_regular)) {
       UInt nb_quad_per_element =
           model.getFEEngine().getNbIntegrationPoints(type);
 
       Array<Real> & moments_coords_array = moments_coords(type);
       const Array<Real> & quad_coordinates_array = quad_coordinates(type);
       const Array<UInt> & el_list_array = el_list(type);
 
       Array<Real>::matrix_iterator moments_begin =
           moments_coords_array.begin(spatial_dimension, spatial_dimension);
       Array<Real>::const_vector_iterator quad_coordinates_begin =
           quad_coordinates_array.begin(spatial_dimension);
 
       Vector<Real> relative_coords(spatial_dimension);
 
-      for (UInt el = 0; el < el_list_array.getSize(); ++el) {
+      for (UInt el = 0; el < el_list_array.size(); ++el) {
         UInt global_el = el_list_array(el);
 
         /// loop over quadrature points
         for (UInt q = 0; q < nb_quad_per_element; ++q) {
           UInt global_q = global_el * nb_quad_per_element + q;
           Matrix<Real> moments_matrix = moments_begin[global_q];
           const Vector<Real> & quad_coord_vector =
               quad_coordinates_begin[global_q];
 
           /// to understand this read the documentation written just
           /// before this function
           relative_coords = quad_coord_vector;
           relative_coords -= *mass_center_it;
 
           moments_matrix.outerProduct(relative_coords, relative_coords);
           Real trace = moments_matrix.trace();
           moments_matrix *= -1.;
           moments_matrix += Matrix<Real>::eye(spatial_dimension, trace);
         }
       }
     }
   }
 
   /// integrate moments
   Array<Real> integrated_moments(global_nb_fragment,
                                  spatial_dimension * spatial_dimension);
 
   integrateFieldOnFragments(moments_coords, integrated_moments);
 
   /// compute and store principal moments
   inertia_moments.resize(global_nb_fragment);
   principal_directions.resize(global_nb_fragment);
 
   Array<Real>::matrix_iterator integrated_moments_it =
       integrated_moments.begin(spatial_dimension, spatial_dimension);
   Array<Real>::vector_iterator inertia_moments_it =
       inertia_moments.begin(spatial_dimension);
   Array<Real>::matrix_iterator principal_directions_it =
       principal_directions.begin(spatial_dimension, spatial_dimension);
 
   for (UInt frag = 0; frag < global_nb_fragment; ++frag,
             ++integrated_moments_it, ++inertia_moments_it,
             ++principal_directions_it) {
     integrated_moments_it->eig(*inertia_moments_it, *principal_directions_it);
   }
 
   if (dump_data)
     createDumpDataArray(inertia_moments, "moments of inertia");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::computeAllData() {
   AKANTU_DEBUG_IN();
 
   buildFragments();
   computeVelocity();
   computeInertiaMoments();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::storeMassDensityPerIntegrationPoint() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension);
 
   for (; it != end; ++it) {
     ElementType type = *it;
 
     Array<Real> & mass_density_array = mass_density(type);
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_quad_per_element = model.getFEEngine().getNbIntegrationPoints(type);
     mass_density_array.resize(nb_element * nb_quad_per_element);
 
     const Array<UInt> & mat_indexes = model.getMaterialByElement(type);
 
     Real * mass_density_it = mass_density_array.storage();
 
     /// store mass_density for each element and quadrature point
     for (UInt el = 0; el < nb_element; ++el) {
       Material & mat = model.getMaterial(mat_indexes(el));
 
       for (UInt q = 0; q < nb_quad_per_element; ++q, ++mass_density_it)
         *mass_density_it = mat.getRho();
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::integrateFieldOnFragments(
     ElementTypeMapArray<Real> & field, Array<Real> & output) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
   UInt nb_component = output.getNbComponent();
 
   /// integration part
   output.resize(global_nb_fragment);
   output.clear();
 
   UInt * fragment_index_it = fragment_index.storage();
   Array<Real>::vector_iterator output_begin = output.begin(nb_component);
 
   /// loop over fragments
   for (const_element_group_iterator it(element_group_begin());
        it != element_group_end(); ++it, ++fragment_index_it) {
 
     const ElementTypeMapArray<UInt> & el_list = it->second->getElements();
 
     /// loop over elements of the fragment
     for (auto type :
          el_list.elementTypes(spatial_dimension, _not_ghost, _ek_regular)) {
 
       UInt nb_quad_per_element =
           model.getFEEngine().getNbIntegrationPoints(type);
 
       const Array<Real> & density_array = mass_density(type);
       Array<Real> & field_array = field(type);
       const Array<UInt> & elements = el_list(type);
-      UInt nb_element = elements.getSize();
+      UInt nb_element = elements.size();
 
       /// generate array to be integrated by filtering fragment's elements
-      Array<Real> integration_array(elements.getSize() * nb_quad_per_element,
+      Array<Real> integration_array(elements.size() * nb_quad_per_element,
                                     nb_component);
 
       Array<Real>::matrix_iterator int_array_it =
           integration_array.begin_reinterpret(nb_quad_per_element, nb_component,
                                               nb_element);
       Array<Real>::matrix_iterator int_array_end =
           integration_array.end_reinterpret(nb_quad_per_element, nb_component,
                                             nb_element);
       Array<Real>::matrix_iterator field_array_begin =
           field_array.begin_reinterpret(nb_quad_per_element, nb_component,
-                                        field_array.getSize() /
+                                        field_array.size() /
                                             nb_quad_per_element);
       Array<Real>::const_vector_iterator density_array_begin =
           density_array.begin_reinterpret(nb_quad_per_element,
-                                          density_array.getSize() /
+                                          density_array.size() /
                                               nb_quad_per_element);
 
       for (UInt el = 0; int_array_it != int_array_end; ++int_array_it, ++el) {
         UInt global_el = elements(el);
         *int_array_it = field_array_begin[global_el];
 
         /// multiply field by density
         const Vector<Real> & density_vector = density_array_begin[global_el];
 
         for (UInt i = 0; i < nb_quad_per_element; ++i) {
           for (UInt j = 0; j < nb_component; ++j) {
             (*int_array_it)(i, j) *= density_vector(i);
           }
         }
       }
 
       /// integrate the field over the fragment
-      Array<Real> integrated_array(elements.getSize(), nb_component);
+      Array<Real> integrated_array(elements.size(), nb_component);
       model.getFEEngine().integrate(integration_array, integrated_array,
                                     nb_component, type, _not_ghost, elements);
 
       /// sum over all elements and store the result
       Vector<Real> output_tmp(output_begin[*fragment_index_it]);
       output_tmp += std::accumulate(integrated_array.begin(nb_component),
                                     integrated_array.end(nb_component),
                                     Vector<Real>(nb_component));
     }
   }
 
   /// sum output over all processors
   const StaticCommunicator & comm = mesh.getCommunicator();
   comm.allReduce(output, _so_sum);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FragmentManager::computeNbElementsPerFragment() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = model.getSpatialDimension();
   nb_elements_per_fragment.resize(global_nb_fragment);
   nb_elements_per_fragment.clear();
 
   UInt * fragment_index_it = fragment_index.storage();
 
   /// loop over fragments
   for (const_element_group_iterator it(element_group_begin());
        it != element_group_end(); ++it, ++fragment_index_it) {
 
     const ElementTypeMapArray<UInt> & el_list = it->second->getElements();
 
     /// loop over elements of the fragment
     for (auto type :
          el_list.elementTypes(spatial_dimension, _not_ghost, _ek_regular)) {
-      UInt nb_element = el_list(type).getSize();
+      UInt nb_element = el_list(type).size();
 
       nb_elements_per_fragment(*fragment_index_it) += nb_element;
     }
   }
 
   /// sum values over all processors
   const auto & comm = mesh.getCommunicator();
   comm.allReduce(nb_elements_per_fragment, _so_sum);
 
   if (dump_data)
     createDumpDataArray(nb_elements_per_fragment, "elements per fragment");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void FragmentManager::createDumpDataArray(Array<T> & data, std::string name,
                                           bool fragment_index_output) {
   AKANTU_DEBUG_IN();
 
-  if (data.getSize() == 0)
+  if (data.size() == 0)
     return;
 
   auto & mesh_not_const = const_cast<Mesh &>(mesh);
 
   auto && spatial_dimension = mesh.getSpatialDimension();
   auto && nb_component = data.getNbComponent();
   auto && data_begin = data.begin(nb_component);
   auto fragment_index_it = fragment_index.begin();
 
   /// loop over fragments
   for (const auto & fragment : ElementGroupsIterable(*this)) {
     const auto & fragment_idx = *fragment_index_it;
 
     /// loop over cluster types
     for (auto & type : fragment.elementTypes(spatial_dimension)) {
       /// init mesh data
       auto & mesh_data = mesh_not_const.getDataPointer<T>(
           name, type, _not_ghost, nb_component);
 
       auto mesh_data_begin = mesh_data.begin(nb_component);
 
       /// fill mesh data
       for (const auto & elem : fragment.getElements(type)) {
         Vector<T> md_tmp = mesh_data_begin[elem];
         if (fragment_index_output) {
           md_tmp(0) = fragment_idx;
         } else {
           md_tmp = data_begin[fragment_idx];
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
index f4fc4eb29..06e8d6139 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
@@ -1,788 +1,788 @@
 /**
  * @file   solid_mechanics_model_cohesive.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Wed Jan 13 2016
  *
  * @brief  Solid mechanics model for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model_cohesive.hh"
 #include "aka_iterators.hh"
 #include "dumpable_inline_impl.hh"
 #include "material_cohesive.hh"
 #include "shape_cohesive.hh"
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_paraview.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 const SolidMechanicsModelCohesiveOptions
     default_solid_mechanics_model_cohesive_options(_explicit_lumped_mass,
                                                    false);
 
 /* -------------------------------------------------------------------------- */
 
 SolidMechanicsModelCohesive::SolidMechanicsModelCohesive(
     Mesh & mesh, UInt dim, const ID & id, const MemoryID & memory_id)
     : SolidMechanicsModel(mesh, dim, id, memory_id), tangents("tangents", id),
       facet_stress("facet_stress", id), facet_material("facet_material", id) {
   AKANTU_DEBUG_IN();
 
   inserter = NULL;
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   facet_synchronizer = NULL;
   facet_stress_synchronizer = NULL;
   cohesive_element_synchronizer = NULL;
   global_connectivity = NULL;
 #endif
 
   delete material_selector;
   material_selector = new DefaultMaterialCohesiveSelector(*this);
 
   this->registerEventHandler(*this, _ehp_solid_mechanics_model_cohesive);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("cohesive elements", id);
   this->mesh.addDumpMeshToDumper("cohesive elements", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_cohesive);
 #endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelCohesive::~SolidMechanicsModelCohesive() {
   AKANTU_DEBUG_IN();
 
   delete inserter;
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   delete cohesive_element_synchronizer;
   delete facet_synchronizer;
   delete facet_stress_synchronizer;
 #endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::setTimeStep(Real time_step) {
   SolidMechanicsModel::setTimeStep(time_step);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper("cohesive elements").setTimeStep(time_step);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initFull(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
   const SolidMechanicsModelCohesiveOptions & smmc_options =
       dynamic_cast<const SolidMechanicsModelCohesiveOptions &>(options);
 
   this->is_extrinsic = smmc_options.extrinsic;
 
   if (!inserter)
     inserter = new CohesiveElementInserter(mesh, is_extrinsic,
                                            id + ":cohesive_element_inserter");
 
   SolidMechanicsModel::initFull(options);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initMaterials() {
   AKANTU_DEBUG_IN();
 
   // make sure the material are instantiated
   if (!are_materials_instantiated)
     instantiateMaterials();
 
   /// find the first cohesive material
   UInt cohesive_index = 0;
 
   while ((dynamic_cast<MaterialCohesive *>(materials[cohesive_index].get()) ==
           nullptr) &&
          cohesive_index <= materials.size())
     ++cohesive_index;
 
   AKANTU_DEBUG_ASSERT(cohesive_index != materials.size(),
                       "No cohesive materials in the material input file");
 
   material_selector->setFallback(cohesive_index);
 
   // set the facet information in the material in case of dynamic insertion
   if (is_extrinsic) {
     const Mesh & mesh_facets = inserter->getMeshFacets();
     facet_material.initialize(mesh_facets, _spatial_dimension =
                                                Model::spatial_dimension - 1);
     // mesh_facets.initElementTypeMapArray(facet_material, 1,
     //                                     spatial_dimension - 1);
 
     Element element;
     for (auto ghost_type : ghost_types) {
       element.ghost_type = ghost_type;
       for (auto & type :
            mesh_facets.elementTypes(Model::spatial_dimension - 1, ghost_type)) {
         element.type = type;
         Array<UInt> & f_material = facet_material(type, ghost_type);
         UInt nb_element = mesh_facets.getNbElement(type, ghost_type);
         f_material.resize(nb_element);
         f_material.set(cohesive_index);
         for (UInt el = 0; el < nb_element; ++el) {
           element.element = el;
           UInt mat_index = (*material_selector)(element);
           f_material(el) = mat_index;
           MaterialCohesive & mat =
               dynamic_cast<MaterialCohesive &>(*materials[mat_index]);
           mat.addFacet(element);
         }
       }
     }
     SolidMechanicsModel::initMaterials();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
     if (facet_synchronizer != NULL)
       inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //      inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
     initAutomaticInsertion();
   } else {
     // TODO think of something a bit mor consistant than just coding the first
     // thing that comes in Fabian's head....
     typedef ParserSection::const_section_iterator const_section_iterator;
     std::pair<const_section_iterator, const_section_iterator> sub_sections =
         this->parser->getSubSections(_st_mesh);
 
     if (sub_sections.first != sub_sections.second) {
       std::string cohesive_surfaces =
           sub_sections.first->getParameter("cohesive_surfaces");
       this->initIntrinsicCohesiveMaterials(cohesive_surfaces);
     } else {
       this->initIntrinsicCohesiveMaterials(cohesive_index);
     }
   }
 
   AKANTU_DEBUG_OUT();
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initIntrinsicCohesiveMaterials(
     std::string cohesive_surfaces) {
 
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != NULL)
     inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //    inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
   std::istringstream split(cohesive_surfaces);
   std::string physname;
   while (std::getline(split, physname, ',')) {
     AKANTU_DEBUG_INFO(
         "Pre-inserting cohesive elements along facets from physical surface: "
         << physname);
     insertElementsFromMeshData(physname);
   }
 
   synchronizeInsertionData();
 
   SolidMechanicsModel::initMaterials();
 
   if (is_default_material_selector)
     delete material_selector;
   material_selector = new MeshDataMaterialCohesiveSelector(*this);
 
   // UInt nb_new_elements =
   inserter->insertElements();
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::synchronizeInsertionData() {
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != NULL) {
     facet_synchronizer->asynchronousSynchronize(*inserter, _gst_ce_groups);
     facet_synchronizer->waitEndSynchronize(*inserter, _gst_ce_groups);
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initIntrinsicCohesiveMaterials(
     UInt cohesive_index) {
 
   AKANTU_DEBUG_IN();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     Mesh::type_iterator first =
         mesh.firstType(Model::spatial_dimension, *gt, _ek_cohesive);
     Mesh::type_iterator last =
         mesh.lastType(Model::spatial_dimension, *gt, _ek_cohesive);
 
     for (; first != last; ++first) {
       Array<UInt> & mat_indexes = this->material_index(*first, *gt);
       Array<UInt> & mat_loc_num = this->material_local_numbering(*first, *gt);
       mat_indexes.set(cohesive_index);
       mat_loc_num.clear();
     }
   }
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != NULL)
     inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //    inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
 
   SolidMechanicsModel::initMaterials();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the model,basically it  pre-compute the shapes, shapes derivatives
  * and jacobian
  *
  */
 void SolidMechanicsModelCohesive::initModel() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel::initModel();
 
   registerFEEngineObject<MyFEEngineCohesiveType>("CohesiveFEEngine", mesh,
                                                  Model::spatial_dimension);
 
   /// add cohesive type connectivity
   ElementType type = _not_defined;
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType type_ghost = *gt;
 
     Mesh::type_iterator it =
         mesh.firstType(Model::spatial_dimension, type_ghost);
     Mesh::type_iterator last =
         mesh.lastType(Model::spatial_dimension, type_ghost);
 
     for (; it != last; ++it) {
       const Array<UInt> & connectivity = mesh.getConnectivity(*it, type_ghost);
-      if (connectivity.getSize() != 0) {
+      if (connectivity.size() != 0) {
         type = *it;
         ElementType type_facet = Mesh::getFacetType(type);
         ElementType type_cohesive =
             FEEngine::getCohesiveElementType(type_facet);
         mesh.addConnectivityType(type_cohesive, type_ghost);
       }
     }
   }
 
   AKANTU_DEBUG_ASSERT(type != _not_defined, "No elements in the mesh");
 
   getFEEngine("CohesiveFEEngine").initShapeFunctions(_not_ghost);
   getFEEngine("CohesiveFEEngine").initShapeFunctions(_ghost);
 
   registerFEEngineObject<MyFEEngineFacetType>(
       "FacetsFEEngine", mesh.getMeshFacets(), Model::spatial_dimension - 1);
 
   if (is_extrinsic) {
     getFEEngine("FacetsFEEngine").initShapeFunctions(_not_ghost);
     getFEEngine("FacetsFEEngine").initShapeFunctions(_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::limitInsertion(BC::Axis axis,
                                                  Real first_limit,
                                                  Real second_limit) {
   AKANTU_DEBUG_IN();
   inserter->setLimit(axis, first_limit, second_limit);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::insertIntrinsicElements() {
   AKANTU_DEBUG_IN();
   // UInt nb_new_elements =
   inserter->insertIntrinsicElements();
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::insertElementsFromMeshData(
     std::string physname) {
   AKANTU_DEBUG_IN();
 
   UInt material_index = SolidMechanicsModel::getMaterialIndex(physname);
   inserter->insertIntrinsicElements(physname, material_index);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_stress_synchronizer != NULL) {
     DataAccessor * data_accessor = this;
     const ElementTypeMapArray<UInt> & rank_to_element =
         synch_parallel->getPrankToElement();
 
     facet_stress_synchronizer->updateFacetStressSynchronizer(
         *inserter, rank_to_element, *data_accessor);
   }
 #endif
 
   facet_stress.initialize(inserter->getMeshFacets(),
                           _nb_component = 2 * Model::spatial_dimension *
                                           Model::spatial_dimension,
                           _spatial_dimension = Model::spatial_dimension - 1);
 
   // inserter->getMeshFacets().initElementTypeMapArray(
   //     facet_stress, 2 * spatial_dimension * spatial_dimension,
   //     spatial_dimension - 1);
 
   resizeFacetStress();
 
   /// compute normals on facets
   computeNormals();
 
   initStressInterpolation();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::updateAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
   inserter->limitCheckFacets();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_stress_synchronizer != NULL) {
     DataAccessor * data_accessor = this;
     const ElementTypeMapArray<UInt> & rank_to_element =
         synch_parallel->getPrankToElement();
 
     facet_stress_synchronizer->updateFacetStressSynchronizer(
         *inserter, rank_to_element, *data_accessor);
   }
 #endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initStressInterpolation() {
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   /// compute quadrature points coordinates on facets
   Array<Real> & position = mesh.getNodes();
 
   ElementTypeMapArray<Real> quad_facets("quad_facets", id);
   quad_facets.initialize(mesh_facets, _nb_component = Model::spatial_dimension,
                          _spatial_dimension = Model::spatial_dimension - 1);
   // mesh_facets.initElementTypeMapArray(quad_facets, Model::spatial_dimension,
   //                                     Model::spatial_dimension - 1);
 
   getFEEngine("FacetsFEEngine")
       .interpolateOnIntegrationPoints(position, quad_facets);
 
   /// compute elements quadrature point positions and build
   /// element-facet quadrature points data structure
   ElementTypeMapArray<Real> elements_quad_facets("elements_quad_facets", id);
 
   elements_quad_facets.initialize(
       mesh, _nb_component = Model::spatial_dimension,
       _spatial_dimension = Model::spatial_dimension);
   // mesh.initElementTypeMapArray(elements_quad_facets,
   // Model::spatial_dimension,
   //                              Model::spatial_dimension);
 
   for (auto elem_gt : ghost_types) {
     for (auto & type : mesh.elementTypes(Model::spatial_dimension, elem_gt)) {
       UInt nb_element = mesh.getNbElement(type, elem_gt);
       if (nb_element == 0)
         continue;
 
       /// compute elements' quadrature points and list of facet
       /// quadrature points positions by element
       Array<Element> & facet_to_element =
           mesh_facets.getSubelementToElement(type, elem_gt);
       UInt nb_facet_per_elem = facet_to_element.getNbComponent();
 
       Array<Real> & el_q_facet = elements_quad_facets(type, elem_gt);
 
       ElementType facet_type = Mesh::getFacetType(type);
 
       UInt nb_quad_per_facet =
           getFEEngine("FacetsFEEngine").getNbIntegrationPoints(facet_type);
 
       el_q_facet.resize(nb_element * nb_facet_per_elem * nb_quad_per_facet);
 
       for (UInt el = 0; el < nb_element; ++el) {
         for (UInt f = 0; f < nb_facet_per_elem; ++f) {
           Element global_facet_elem = facet_to_element(el, f);
           UInt global_facet = global_facet_elem.element;
           GhostType facet_gt = global_facet_elem.ghost_type;
           const Array<Real> & quad_f = quad_facets(facet_type, facet_gt);
 
           for (UInt q = 0; q < nb_quad_per_facet; ++q) {
             for (UInt s = 0; s < Model::spatial_dimension; ++s) {
               el_q_facet(el * nb_facet_per_elem * nb_quad_per_facet +
                              f * nb_quad_per_facet + q,
                          s) = quad_f(global_facet * nb_quad_per_facet + q, s);
             }
           }
         }
       }
     }
   }
 
   /// loop over non cohesive materials
   for (UInt m = 0; m < materials.size(); ++m) {
     try {
       MaterialCohesive & mat __attribute__((unused)) =
           dynamic_cast<MaterialCohesive &>(*materials[m]);
     } catch (std::bad_cast &) {
       /// initialize the interpolation function
       materials[m]->initElementalFieldInterpolation(elements_quad_facets);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   // f_int += f_int_cohe
   for (auto & material : this->materials) {
     try {
       MaterialCohesive & mat = dynamic_cast<MaterialCohesive &>(*material);
       mat.computeTraction(_not_ghost);
     } catch (std::bad_cast & bce) {
     }
   }
 
   SolidMechanicsModel::assembleInternalForces();
 
   if (isDefaultSolverExplicit()) {
     for (auto & material : materials) {
       try {
         MaterialCohesive & mat = dynamic_cast<MaterialCohesive &>(*material);
         mat.computeEnergies();
       } catch (std::bad_cast & bce) {
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::computeNormals() {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh_facets = this->inserter->getMeshFacets();
   this->getFEEngine("FacetsFEEngine")
       .computeNormalsOnIntegrationPoints(_not_ghost);
 
   /**
    *  @todo store tangents while computing normals instead of
    *  recomputing them as follows:
    */
   /* ------------------------------------------------------------------------ */
   UInt tangent_components =
       Model::spatial_dimension * (Model::spatial_dimension - 1);
 
   tangents.initialize(mesh_facets, _nb_component = tangent_components,
                       _spatial_dimension = Model::spatial_dimension - 1);
   // mesh_facets.initElementTypeMapArray(tangents, tangent_components,
   //                                     Model::spatial_dimension - 1);
 
   for (auto facet_type :
        mesh_facets.elementTypes(Model::spatial_dimension - 1)) {
     const Array<Real> & normals =
         this->getFEEngine("FacetsFEEngine")
             .getNormalsOnIntegrationPoints(facet_type);
 
     Array<Real> & tangents = this->tangents(facet_type);
 
     Math::compute_tangents(normals, tangents);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::interpolateStress() {
 
   ElementTypeMapArray<Real> by_elem_result("temporary_stress_by_facets", id);
 
   for (auto & material : materials) {
     try {
       MaterialCohesive & mat __attribute__((unused)) =
           dynamic_cast<MaterialCohesive &>(*material);
     } catch (std::bad_cast &) {
       /// interpolate stress on facet quadrature points positions
       material->interpolateStressOnFacets(facet_stress, by_elem_result);
     }
   }
 
 #if defined(AKANTU_DEBUG_TOOLS)
   debug::element_manager.printData(
       debug::_dm_model_cohesive, "Interpolated stresses before", facet_stress);
 #endif
 
   this->synchronize(_gst_smmc_facets_stress);
 
 #if defined(AKANTU_DEBUG_TOOLS)
   debug::element_manager.printData(debug::_dm_model_cohesive,
                                    "Interpolated stresses", facet_stress);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModelCohesive::checkCohesiveStress() {
   interpolateStress();
 
   for (auto & mat : materials) {
     try {
       MaterialCohesive & mat_cohesive = dynamic_cast<MaterialCohesive &>(*mat);
       /// check which not ghost cohesive elements are to be created
       mat_cohesive.checkInsertion();
     } catch (std::bad_cast &) {
     }
   }
 
   /// communicate data among processors
   this->synchronize(_gst_smmc_facets);
 
   /// insert cohesive elements
   UInt nb_new_elements = inserter->insertElements();
 
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
 
   return nb_new_elements;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onElementsAdded(
     const Array<Element> & element_list, const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   updateCohesiveSynchronizers();
 #endif
 
   SolidMechanicsModel::onElementsAdded(element_list, event);
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (cohesive_element_synchronizer != NULL)
     cohesive_element_synchronizer->computeAllBufferSizes(*this);
 #endif
 
   if (is_extrinsic)
     resizeFacetStress();
 
   ///  if (method != _explicit_lumped_mass) {
   ///    this->initSolver();
   ///  }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onNodesAdded(const Array<UInt> & new_nodes,
                                                const NewNodesEvent & event) {
   AKANTU_DEBUG_IN();
 
   // Array<UInt> nodes_list(nb_new_nodes);
 
   // for (UInt n = 0; n < nb_new_nodes; ++n)
   //   nodes_list(n) = doubled_nodes(n, 1);
   SolidMechanicsModel::onNodesAdded(new_nodes, event);
 
   UInt new_node, old_node;
 
   try {
     const auto & cohesive_event =
         dynamic_cast<const CohesiveNewNodesEvent &>(event);
     const auto & old_nodes = cohesive_event.getOldNodesList();
 
     auto copy = [this, &new_node, &old_node](auto & arr) {
       for (UInt s = 0; s < spatial_dimension; ++s) {
         arr(new_node, s) = arr(old_node, s);
       }
     };
 
     for (auto && pair : zip(new_nodes, old_nodes)) {
       std::tie(new_node, old_node) = pair;
 
       copy(*displacement);
       copy(*velocity);
       copy(*acceleration);
       copy(*blocked_dofs);
 
       if (current_position)
         copy(*current_position);
 
       if (previous_displacement)
         copy(*previous_displacement);
     }
 
     // if (this->getDOFManager().hasMatrix("M")) {
     //   this->assembleMass(old_nodes);
     // }
 
     // if (this->getDOFManager().hasLumpedMatrix("M")) {
     //   this->assembleMassLumped(old_nodes);
     // }
 
   } catch (std::bad_cast &) {
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onEndSolveStep(const AnalysisMethod &) {
 
   AKANTU_DEBUG_IN();
 
   /*
    * This is required because the Cauchy stress is the stress measure that
    * is used to check the insertion of cohesive elements
    */
   for (auto & mat : materials) {
     if (mat->isFiniteDeformation())
       mat->computeAllCauchyStresses(_not_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::printself(std::ostream & stream,
                                             int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "SolidMechanicsModelCohesive [" << std::endl;
 
   SolidMechanicsModel::printself(stream, indent + 1);
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::resizeFacetStress() {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
 
     Mesh::type_iterator it =
         mesh_facets.firstType(Model::spatial_dimension - 1, ghost_type);
     Mesh::type_iterator end =
         mesh_facets.lastType(Model::spatial_dimension - 1, ghost_type);
     for (; it != end; ++it) {
       ElementType type = *it;
 
       UInt nb_facet = mesh_facets.getNbElement(type, ghost_type);
 
       UInt nb_quadrature_points = getFEEngine("FacetsFEEngine")
                                       .getNbIntegrationPoints(type, ghost_type);
 
       UInt new_size = nb_facet * nb_quadrature_points;
 
       facet_stress(type, ghost_type).resize(new_size);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::addDumpGroupFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const std::string & group_name, const ElementKind & element_kind,
     bool padding_flag) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = Model::spatial_dimension;
   ElementKind _element_kind = element_kind;
   if (dumper_name == "cohesive elements") {
     _element_kind = _ek_cohesive;
   } else if (dumper_name == "facets") {
     spatial_dimension = Model::spatial_dimension - 1;
   }
   SolidMechanicsModel::addDumpGroupFieldToDumper(dumper_name, field_id,
                                                  group_name, spatial_dimension,
                                                  _element_kind, padding_flag);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 void SolidMechanicsModelCohesive::onDump() {
   this->flattenAllRegisteredInternals(_ek_cohesive);
   SolidMechanicsModel::onDump();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc b/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
index 24f214852..9ab911c71 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
@@ -1,421 +1,421 @@
 /**
  * @file   solid_mechanics_model_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 04 2010
  * @date last modification: Wed Nov 18 2015
  *
  * @brief  Implementation of the inline functions of the SolidMechanicsModel
  * class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_named_argument.hh"
 #include "material_selector.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_INLINE_IMPL_CC__
 #define __AKANTU_SOLID_MECHANICS_MODEL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline SolidMechanicsModelOptions::SolidMechanicsModelOptions(
     AnalysisMethod analysis_method)
     : analysis_method(analysis_method) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename... pack>
 SolidMechanicsModelOptions::SolidMechanicsModelOptions(use_named_args_t,
                                                        pack &&... _pack)
     : SolidMechanicsModelOptions(
           OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass)) {}
 
 /* -------------------------------------------------------------------------- */
 inline Material & SolidMechanicsModel::getMaterial(UInt mat_index) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(mat_index < materials.size(),
                       "The model " << id << " has no material no "
                                    << mat_index);
   AKANTU_DEBUG_OUT();
   return *materials[mat_index];
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Material & SolidMechanicsModel::getMaterial(UInt mat_index) const {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(mat_index < materials.size(),
                       "The model " << id << " has no material no "
                                    << mat_index);
   AKANTU_DEBUG_OUT();
   return *materials[mat_index];
 }
 
 /* -------------------------------------------------------------------------- */
 inline Material & SolidMechanicsModel::getMaterial(const std::string & name) {
   AKANTU_DEBUG_IN();
   std::map<std::string, UInt>::const_iterator it =
       materials_names_to_id.find(name);
   AKANTU_DEBUG_ASSERT(it != materials_names_to_id.end(),
                       "The model " << id << " has no material named " << name);
   AKANTU_DEBUG_OUT();
   return *materials[it->second];
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt
 SolidMechanicsModel::getMaterialIndex(const std::string & name) const {
   AKANTU_DEBUG_IN();
   std::map<std::string, UInt>::const_iterator it =
       materials_names_to_id.find(name);
   AKANTU_DEBUG_ASSERT(it != materials_names_to_id.end(),
                       "The model " << id << " has no material named " << name);
   AKANTU_DEBUG_OUT();
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Material &
 SolidMechanicsModel::getMaterial(const std::string & name) const {
   AKANTU_DEBUG_IN();
   std::map<std::string, UInt>::const_iterator it =
       materials_names_to_id.find(name);
   AKANTU_DEBUG_ASSERT(it != materials_names_to_id.end(),
                       "The model " << id << " has no material named " << name);
   AKANTU_DEBUG_OUT();
   return *materials[it->second];
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 SolidMechanicsModel::setMaterialSelector(MaterialSelector & selector) {
   if (is_default_material_selector)
     delete material_selector;
   material_selector = &selector;
   is_default_material_selector = false;
 }
 
 
 /* -------------------------------------------------------------------------- */
 inline void SolidMechanicsModel::splitElementByMaterial(
     const Array<Element> & elements, Array<Element> * elements_per_mat) const {
   ElementType current_element_type = _not_defined;
   GhostType current_ghost_type = _casper;
   const Array<UInt> * mat_indexes = NULL;
   const Array<UInt> * mat_loc_num = NULL;
 
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     Element el = *it;
 
     if (el.type != current_element_type ||
         el.ghost_type != current_ghost_type) {
       current_element_type = el.type;
       current_ghost_type = el.ghost_type;
       mat_indexes = &(this->material_index(el.type, el.ghost_type));
       mat_loc_num = &(this->material_local_numbering(el.type, el.ghost_type));
     }
 
     UInt old_id = el.element;
     el.element = (*mat_loc_num)(old_id);
     elements_per_mat[(*mat_indexes)(old_id)].push_back(el);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt
 SolidMechanicsModel::getNbData(const Array<Element> & elements,
                                const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes_per_element = 0;
 
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
   }
 
   switch (tag) {
   case _gst_material_id: {
-    size += elements.getSize() * sizeof(UInt);
+    size += elements.size() * sizeof(UInt);
     break;
   }
   case _gst_smm_mass: {
     size += nb_nodes_per_element * sizeof(Real) *
             Model::spatial_dimension; // mass vector
     break;
   }
   case _gst_smm_for_gradu: {
     size += nb_nodes_per_element * Model::spatial_dimension *
             sizeof(Real); // displacement
     break;
   }
   case _gst_smm_boundary: {
     // force, displacement, boundary
     size += nb_nodes_per_element * Model::spatial_dimension *
             (2 * sizeof(Real) + sizeof(bool));
     break;
   }
   case _gst_for_dump: {
     // displacement, velocity, acceleration, residual, force
     size += nb_nodes_per_element * Model::spatial_dimension * sizeof(Real) * 5;
     break;
   }
   default: {}
   }
 
   if (tag != _gst_material_id) {
     Array<Element> * elements_per_mat = new Array<Element>[materials.size()];
     this->splitElementByMaterial(elements, elements_per_mat);
 
     for (UInt i = 0; i < materials.size(); ++i) {
       size += materials[i]->getNbData(elements_per_mat[i], tag);
     }
     delete[] elements_per_mat;
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 SolidMechanicsModel::packData(CommunicationBuffer & buffer,
                               const Array<Element> & elements,
                               const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_material_id: {
     this->packElementalDataHelper(material_index, buffer, elements, false,
                                   getFEEngine());
     break;
   }
   case _gst_smm_mass: {
     packNodalDataHelper(*mass, buffer, elements, mesh);
     break;
   }
   case _gst_smm_for_gradu: {
     packNodalDataHelper(*displacement, buffer, elements, mesh);
     break;
   }
   case _gst_for_dump: {
     packNodalDataHelper(*displacement, buffer, elements, mesh);
     packNodalDataHelper(*velocity, buffer, elements, mesh);
     packNodalDataHelper(*acceleration, buffer, elements, mesh);
     packNodalDataHelper(*internal_force, buffer, elements, mesh);
     packNodalDataHelper(*external_force, buffer, elements, mesh);
     break;
   }
   case _gst_smm_boundary: {
     packNodalDataHelper(*external_force, buffer, elements, mesh);
     packNodalDataHelper(*velocity, buffer, elements, mesh);
     packNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
     break;
   }
   default: {}
   }
 
   if (tag != _gst_material_id) {
     Array<Element> * elements_per_mat = new Array<Element>[materials.size()];
     splitElementByMaterial(elements, elements_per_mat);
 
     for (UInt i = 0; i < materials.size(); ++i) {
       materials[i]->packData(buffer, elements_per_mat[i], tag);
     }
 
     delete[] elements_per_mat;
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SolidMechanicsModel::unpackData(CommunicationBuffer & buffer,
                                             const Array<Element> & elements,
                                             const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_material_id: {
     unpackElementalDataHelper(material_index, buffer, elements, false,
                               getFEEngine());
     break;
   }
   case _gst_smm_mass: {
     unpackNodalDataHelper(*mass, buffer, elements, mesh);
     break;
   }
   case _gst_smm_for_gradu: {
     unpackNodalDataHelper(*displacement, buffer, elements, mesh);
     break;
   }
   case _gst_for_dump: {
     unpackNodalDataHelper(*displacement, buffer, elements, mesh);
     unpackNodalDataHelper(*velocity, buffer, elements, mesh);
     unpackNodalDataHelper(*acceleration, buffer, elements, mesh);
     unpackNodalDataHelper(*internal_force, buffer, elements, mesh);
     unpackNodalDataHelper(*external_force, buffer, elements, mesh);
     break;
   }
   case _gst_smm_boundary: {
     unpackNodalDataHelper(*external_force, buffer, elements, mesh);
     unpackNodalDataHelper(*velocity, buffer, elements, mesh);
     unpackNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
     break;
   }
   default: {}
   }
 
   if (tag != _gst_material_id) {
     Array<Element> * elements_per_mat = new Array<Element>[materials.size()];
     splitElementByMaterial(elements, elements_per_mat);
 
     for (UInt i = 0; i < materials.size(); ++i) {
       materials[i]->unpackData(buffer, elements_per_mat[i], tag);
     }
 
     delete[] elements_per_mat;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt
 SolidMechanicsModel::getNbData(const Array<UInt> & dofs,
                                const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   //  UInt nb_nodes = mesh.getNbNodes();
 
   switch (tag) {
   case _gst_smm_uv: {
     size += sizeof(Real) * Model::spatial_dimension * 2;
     break;
   }
   case _gst_smm_res: {
     size += sizeof(Real) * Model::spatial_dimension;
     break;
   }
   case _gst_smm_mass: {
     size += sizeof(Real) * Model::spatial_dimension;
     break;
   }
   case _gst_for_dump: {
     size += sizeof(Real) * Model::spatial_dimension * 5;
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
-  return size * dofs.getSize();
+  return size * dofs.size();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 SolidMechanicsModel::packData(CommunicationBuffer & buffer,
                               const Array<UInt> & dofs,
                               const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_smm_uv: {
     packDOFDataHelper(*displacement, buffer, dofs);
     packDOFDataHelper(*velocity, buffer, dofs);
     break;
   }
   case _gst_smm_res: {
     packDOFDataHelper(*internal_force, buffer, dofs);
     break;
   }
   case _gst_smm_mass: {
     packDOFDataHelper(*mass, buffer, dofs);
     break;
   }
   case _gst_for_dump: {
     packDOFDataHelper(*displacement, buffer, dofs);
     packDOFDataHelper(*velocity, buffer, dofs);
     packDOFDataHelper(*acceleration, buffer, dofs);
     packDOFDataHelper(*internal_force, buffer, dofs);
     packDOFDataHelper(*external_force, buffer, dofs);
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SolidMechanicsModel::unpackData(CommunicationBuffer & buffer,
                                             const Array<UInt> & dofs,
                                             const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_smm_uv: {
     unpackDOFDataHelper(*displacement, buffer, dofs);
     unpackDOFDataHelper(*velocity, buffer, dofs);
     break;
   }
   case _gst_smm_res: {
     unpackDOFDataHelper(*internal_force, buffer, dofs);
     break;
   }
   case _gst_smm_mass: {
     unpackDOFDataHelper(*mass, buffer, dofs);
     break;
   }
   case _gst_for_dump: {
     unpackDOFDataHelper(*displacement, buffer, dofs);
     unpackDOFDataHelper(*velocity, buffer, dofs);
     unpackDOFDataHelper(*acceleration, buffer, dofs);
     unpackDOFDataHelper(*internal_force, buffer, dofs);
     unpackDOFDataHelper(*external_force, buffer, dofs);
     break;
   }
   default: {
     AKANTU_DEBUG_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_INLINE_IMPL_CC__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_mass.cc b/src/model/solid_mechanics/solid_mechanics_model_mass.cc
index fa5fcca40..e22deb073 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_mass.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_mass.cc
@@ -1,172 +1,172 @@
 /**
  * @file   solid_mechanics_model_mass.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Oct 05 2010
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  function handling mass computation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "integrator_gauss.hh"
 #include "material.hh"
 #include "model_solver.hh"
 #include "shape_lagrange.hh"
 #include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class ComputeRhoFunctor {
 public:
   explicit ComputeRhoFunctor(const SolidMechanicsModel & model)
       : model(model){};
 
   void operator()(Matrix<Real> & rho, const Element & element) const {
     const Array<UInt> & mat_indexes =
         model.getMaterialByElement(element.type, element.ghost_type);
     Real mat_rho =
         model.getMaterial(mat_indexes(element.element)).getParam("rho");
     rho.set(mat_rho);
   }
 
 private:
   const SolidMechanicsModel & model;
 };
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMassLumped() {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = mesh.getNbNodes();
 
   if (this->mass == NULL) {
     std::stringstream sstr_mass;
     sstr_mass << id << ":mass";
     mass =
         &(alloc<Real>(sstr_mass.str(), nb_nodes, Model::spatial_dimension, 0));
   } else {
     mass->clear();
   }
 
   if (!this->getDOFManager().hasLumpedMatrix("M")) {
     this->getDOFManager().getNewLumpedMatrix("M");
   }
 
   this->getDOFManager().clearLumpedMatrix("M");
 
   assembleMassLumped(_not_ghost);
   assembleMassLumped(_ghost);
 
   this->getDOFManager().getLumpedMatrixPerDOFs("displacement", "M",
                                                *(this->mass));
 
 /// for not connected nodes put mass to one in order to avoid
 #if !defined(AKANTU_NDEBUG)
   bool has_unconnected_nodes = false;
   auto mass_it =
-      mass->begin_reinterpret(mass->getSize() * mass->getNbComponent());
+      mass->begin_reinterpret(mass->size() * mass->getNbComponent());
   auto mass_end =
-      mass->end_reinterpret(mass->getSize() * mass->getNbComponent());
+      mass->end_reinterpret(mass->size() * mass->getNbComponent());
   for (; mass_it != mass_end; ++mass_it) {
     if (std::abs(*mass_it) < std::numeric_limits<Real>::epsilon() ||
         Math::isnan(*mass_it)) {
       has_unconnected_nodes = true;
       break;
     }
   }
 
   if (has_unconnected_nodes)
     AKANTU_DEBUG_WARNING("There are nodes that seem to not be connected to any "
                          "elements, beware that they have lumped mass of 0.");
 #endif
 
   this->synchronize(_gst_smm_mass);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMass() {
   AKANTU_DEBUG_IN();
 
   if (!this->getDOFManager().hasMatrix("M")) {
     this->getDOFManager().getNewMatrix("M", "J");
   }
 
   this->getDOFManager().clearMatrix("M");
   assembleMass(_not_ghost);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMassLumped(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
   ComputeRhoFunctor compute_rho(*this);
 
   for (auto type : mesh.elementTypes(Model::spatial_dimension, ghost_type)) {
     fem.assembleFieldLumped(compute_rho, "M", "displacement",
                             this->getDOFManager(), type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMass(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
   ComputeRhoFunctor compute_rho(*this);
 
   for (auto type : mesh.elementTypes(Model::spatial_dimension, ghost_type)) {
     fem.assembleFieldMatrix(compute_rho, "M", "displacement",
                             this->getDOFManager(), type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMassLumped(const Array<UInt> &) {
   AKANTU_DEBUG_IN();
 
   assembleMassLumped();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMass(const Array<UInt> &) {
   AKANTU_DEBUG_IN();
 
   assembleMass();
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_material.cc b/src/model/solid_mechanics/solid_mechanics_model_material.cc
index fdf3688d2..a14f37514 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_material.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_material.cc
@@ -1,318 +1,318 @@
 /**
  * @file   solid_mechanics_model_material.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Nov 26 2010
  * @date last modification: Mon Nov 16 2015
  *
  * @brief  instatiation of materials
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_factory.hh"
 #include "aka_math.hh"
 #include "material_non_local.hh"
 #include "solid_mechanics_model.hh"
 #ifdef AKANTU_DAMAGE_NON_LOCAL
 #include "non_local_manager.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Material &
 SolidMechanicsModel::registerNewMaterial(const ParserSection & section) {
   std::string mat_name;
   std::string mat_type = section.getName();
   std::string opt_param = section.getOption();
 
   try {
     std::string tmp = section.getParameter("name");
     mat_name = tmp; /** this can seam weird, but there is an ambiguous operator
                      * overload that i couldn't solve. @todo remove the
                      * weirdness of this code
                      */
   } catch (debug::Exception &) {
     AKANTU_DEBUG_ERROR(
         "A material of type \'"
         << mat_type << "\' in the input file has been defined without a name!");
   }
   Material & mat = this->registerNewMaterial(mat_name, mat_type, opt_param);
 
   mat.parseSection(section);
 
   return mat;
 }
 
 /* -------------------------------------------------------------------------- */
 Material & SolidMechanicsModel::registerNewMaterial(const ID & mat_name,
                                                     const ID & mat_type,
                                                     const ID & opt_param) {
   AKANTU_DEBUG_ASSERT(materials_names_to_id.find(mat_name) ==
                           materials_names_to_id.end(),
                       "A material with this name '"
                           << mat_name << "' has already been registered. "
                           << "Please use unique names for materials");
 
   UInt mat_count = materials.size();
   materials_names_to_id[mat_name] = mat_count;
 
   std::stringstream sstr_mat;
   sstr_mat << this->id << ":" << mat_count << ":" << mat_type;
   ID mat_id = sstr_mat.str();
 
   std::unique_ptr<Material> material = MaterialFactory::getInstance().allocate(
       mat_type, Model::spatial_dimension, opt_param, *this, mat_id);
 
   materials.push_back(std::move(material));
 
   return *(materials.back());
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::instantiateMaterials() {
   std::pair<Parser::const_section_iterator, Parser::const_section_iterator>
       sub_sect = this->parser->getSubSections(_st_material);
 
   Parser::const_section_iterator it = sub_sect.first;
   for (; it != sub_sect.second; ++it) {
     const ParserSection & section = *it;
     registerNewMaterial(section);
   }
 
   are_materials_instantiated = true;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assignMaterialToElements(
     const ElementTypeMapArray<UInt> * filter) {
 
   Element element;
   element.ghost_type = _not_ghost;
 
   auto element_types =
       mesh.elementTypes(Model::spatial_dimension, _not_ghost, _ek_not_defined);
   if (filter != NULL) {
     element_types = filter->elementTypes(Model::spatial_dimension, _not_ghost,
                                          _ek_not_defined);
   }
 
   // Fill the element material array from the material selector
   for (auto type : element_types) {
     UInt nb_element = mesh.getNbElement(type, _not_ghost);
 
     const Array<UInt> * filter_array = NULL;
     if (filter != NULL) {
       filter_array = &((*filter)(type, _not_ghost));
-      nb_element = filter_array->getSize();
+      nb_element = filter_array->size();
     }
 
     element.type = type;
     element.kind = mesh.getKind(element.type);
     Array<UInt> & mat_indexes = material_index(type, _not_ghost);
     for (UInt el = 0; el < nb_element; ++el) {
       if (filter != NULL)
         element.element = (*filter_array)(el);
       else
         element.element = el;
 
       UInt mat_index = (*material_selector)(element);
       AKANTU_DEBUG_ASSERT(
           mat_index < materials.size(),
           "The material selector returned an index that does not exists");
       mat_indexes(element.element) = mat_index;
     }
   }
 
   // synchronize the element material arrays
   this->synchronize(_gst_material_id);
 
   /// fill the element filters of the materials using the element_material
   /// arrays
   for (auto ghost_type : ghost_types) {
     element_types = mesh.elementTypes(Model::spatial_dimension, ghost_type,
                                       _ek_not_defined);
 
     if (filter != NULL) {
       element_types = filter->elementTypes(Model::spatial_dimension, ghost_type,
                                            _ek_not_defined);
     }
 
     for (auto type : element_types) {
       UInt nb_element = mesh.getNbElement(type, ghost_type);
 
       const Array<UInt> * filter_array = NULL;
       if (filter != NULL) {
         filter_array = &((*filter)(type, ghost_type));
-        nb_element = filter_array->getSize();
+        nb_element = filter_array->size();
       }
 
       Array<UInt> & mat_indexes = material_index(type, ghost_type);
       Array<UInt> & mat_local_num = material_local_numbering(type, ghost_type);
       for (UInt el = 0; el < nb_element; ++el) {
         UInt element;
 
         if (filter != NULL)
           element = (*filter_array)(el);
         else
           element = el;
 
         UInt mat_index = mat_indexes(element);
         UInt index =
             materials[mat_index]->addElement(type, element, ghost_type);
         mat_local_num(element) = index;
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initMaterials() {
   AKANTU_DEBUG_ASSERT(materials.size() != 0, "No material to initialize !");
 
   if (!are_materials_instantiated)
     instantiateMaterials();
 
   this->assignMaterialToElements();
 
   for (auto & material : materials) {
     /// init internals properties
     material->initMaterial();
   }
 
   this->synchronize(_gst_smm_init_mat);
 
   // initialize mass
   switch (method) {
   case _explicit_lumped_mass:
     assembleMassLumped();
     break;
   case _explicit_consistent_mass:
   case _implicit_dynamic:
     assembleMass();
     break;
   case _static:
     break;
   default:
     AKANTU_EXCEPTION("analysis method not recognised by SolidMechanicsModel");
     break;
   }
 
 #ifdef AKANTU_DAMAGE_NON_LOCAL
   bool has_non_local_materials = false;
   for (auto & material : materials) {
     try {
       dynamic_cast<MaterialNonLocalInterface &>(*material);
       has_non_local_materials = true;
     } catch (std::bad_cast &) {
     }
   }
 
   if (has_non_local_materials) {
     /// initialize the non-local manager for non-local computations
     this->non_local_manager = std::make_unique<NonLocalManager>(
         *this, id + ":non_local_manager", memory_id);
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 Int SolidMechanicsModel::getInternalIndexFromID(const ID & id) const {
   AKANTU_DEBUG_IN();
 
   auto it = materials.begin();
   auto end = materials.end();
 
   for (; it != end; ++it)
     if ((*it)->getID() == id) {
       AKANTU_DEBUG_OUT();
       return (it - materials.begin());
     }
 
   AKANTU_DEBUG_OUT();
   return -1;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::reassignMaterial() {
   AKANTU_DEBUG_IN();
 
   std::vector<Array<Element>> element_to_add(materials.size());
   std::vector<Array<Element>> element_to_remove(materials.size());
 
   Element element;
   for (auto ghost_type : ghost_types) {
     element.ghost_type = ghost_type;
 
     for (auto type : mesh.elementTypes(Model::spatial_dimension, ghost_type,
                                        _ek_not_defined)) {
       element.type = type;
       element.kind = Mesh::getKind(type);
 
       UInt nb_element = mesh.getNbElement(type, ghost_type);
       Array<UInt> & mat_indexes = material_index(type, ghost_type);
 
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = el;
 
         UInt old_material = mat_indexes(el);
         UInt new_material = (*material_selector)(element);
 
         if (old_material != new_material) {
           element_to_add[new_material].push_back(element);
           element_to_remove[old_material].push_back(element);
         }
       }
     }
   }
 
   UInt mat_index = 0;
   for (auto mat_it = materials.begin(); mat_it != materials.end();
        ++mat_it, ++mat_index) {
     (*mat_it)->removeElements(element_to_remove[mat_index]);
     (*mat_it)->addElements(element_to_add[mat_index]);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::applyEigenGradU(
     const Matrix<Real> & prescribed_eigen_grad_u, const ID & material_name,
     const GhostType ghost_type) {
 
   AKANTU_DEBUG_ASSERT(prescribed_eigen_grad_u.size() ==
                           Model::spatial_dimension * Model::spatial_dimension,
                       "The prescribed grad_u is not of the good size");
   for (auto & material : materials) {
     if (material->getName() == material_name)
       material->applyEigenGradU(prescribed_eigen_grad_u, ghost_type);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/structural_mechanics/structural_mechanics_model.cc b/src/model/structural_mechanics/structural_mechanics_model.cc
index 52168fe3c..d9666b590 100644
--- a/src/model/structural_mechanics/structural_mechanics_model.cc
+++ b/src/model/structural_mechanics/structural_mechanics_model.cc
@@ -1,1225 +1,1225 @@
 /**
  * @file   structural_mechanics_model.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Fri Jul 15 2011
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Model implementation for StucturalMechanics elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "structural_mechanics_model.hh"
 #include "group_manager_inline_impl.cc"
 #include "dumpable_inline_impl.hh"
 #include "aka_math.hh"
 #include "integration_scheme_2nd_order.hh"
 #include "static_communicator.hh"
 #include "sparse_matrix.hh"
 #include "solver.hh"
 
 #ifdef AKANTU_USE_MUMPS
 #include "solver_mumps.hh"
 #endif
 
 #ifdef AKANTU_USE_IOHELPER
 #include "dumper_paraview.hh"
 #include "dumper_elemental_field.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 const StructuralMechanicsModelOptions
     default_structural_mechanics_model_options(_static);
 
 /* -------------------------------------------------------------------------- */
 StructuralMechanicsModel::StructuralMechanicsModel(Mesh & mesh, UInt dim,
                                                    const ID & id,
                                                    const MemoryID & memory_id)
     : Model(mesh, dim, id, memory_id), time_step(NAN), f_m2a(1.0),
       stress("stress", id, memory_id),
       element_material("element_material", id, memory_id),
       set_ID("beam sets", id, memory_id), stiffness_matrix(NULL),
       mass_matrix(NULL), velocity_damping_matrix(NULL), jacobian_matrix(NULL),
       solver(NULL), rotation_matrix("rotation_matices", id, memory_id),
       increment_flag(false), integrator(NULL) {
   AKANTU_DEBUG_IN();
 
   registerFEEngineObject<MyFEEngineType>("StructuralMechanicsFEEngine", mesh,
                                          spatial_dimension);
 
   this->displacement_rotation = NULL;
   this->mass = NULL;
   this->velocity = NULL;
   this->acceleration = NULL;
   this->force_momentum = NULL;
   this->residual = NULL;
   this->blocked_dofs = NULL;
   this->increment = NULL;
 
   this->previous_displacement = NULL;
 
   if (spatial_dimension == 2)
     nb_degree_of_freedom = 3;
   else if (spatial_dimension == 3)
     nb_degree_of_freedom = 6;
   else {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   this->mesh.registerDumper<DumperParaview>("paraview_all", id, true);
   this->mesh.addDumpMesh(mesh, spatial_dimension, _not_ghost, _ek_structural);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 StructuralMechanicsModel::~StructuralMechanicsModel() {
   AKANTU_DEBUG_IN();
 
   delete integrator;
   delete solver;
   delete stiffness_matrix;
   delete jacobian_matrix;
   delete mass_matrix;
   delete velocity_damping_matrix;
 
   AKANTU_DEBUG_OUT();
 }
 
 void StructuralMechanicsModel::setTimeStep(Real time_step) {
   this->time_step = time_step;
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper().setTimeStep(time_step);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 /* Initialisation                                                             */
 /* -------------------------------------------------------------------------- */
 
 void StructuralMechanicsModel::initFull(const ModelOptions & options) {
 
   const StructuralMechanicsModelOptions & stmm_options =
       dynamic_cast<const StructuralMechanicsModelOptions &>(options);
 
   method = stmm_options.analysis_method;
 
   initModel();
   initArrays();
 
   displacement_rotation->clear();
   velocity->clear();
   acceleration->clear();
   force_momentum->clear();
   residual->clear();
   blocked_dofs->clear();
   increment->clear();
 
   Mesh::type_iterator it = getFEEngine().getMesh().firstType(
       spatial_dimension, _not_ghost, _ek_structural);
   Mesh::type_iterator end = getFEEngine().getMesh().lastType(
       spatial_dimension, _not_ghost, _ek_structural);
   for (; it != end; ++it) {
     computeRotationMatrix(*it);
   }
 
   switch (method) {
   case _implicit_dynamic:
     initImplicit();
     break;
   case _static:
     initSolver();
     break;
   default:
     AKANTU_EXCEPTION(
         "analysis method not recognised by StructuralMechanicsModel");
     break;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initArrays() {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = getFEEngine().getMesh().getNbNodes();
   std::stringstream sstr_disp;
   sstr_disp << id << ":displacement";
   std::stringstream sstr_velo;
   sstr_velo << id << ":velocity";
   std::stringstream sstr_acce;
   sstr_acce << id << ":acceleration";
   std::stringstream sstr_forc;
   sstr_forc << id << ":force";
   std::stringstream sstr_resi;
   sstr_resi << id << ":residual";
   std::stringstream sstr_boun;
   sstr_boun << id << ":blocked_dofs";
   std::stringstream sstr_incr;
   sstr_incr << id << ":increment";
 
   displacement_rotation = &(alloc<Real>(sstr_disp.str(), nb_nodes,
                                         nb_degree_of_freedom, REAL_INIT_VALUE));
   velocity = &(alloc<Real>(sstr_velo.str(), nb_nodes, nb_degree_of_freedom,
                            REAL_INIT_VALUE));
   acceleration = &(alloc<Real>(sstr_acce.str(), nb_nodes, nb_degree_of_freedom,
                                REAL_INIT_VALUE));
   force_momentum = &(alloc<Real>(sstr_forc.str(), nb_nodes,
                                  nb_degree_of_freedom, REAL_INIT_VALUE));
   residual = &(alloc<Real>(sstr_resi.str(), nb_nodes, nb_degree_of_freedom,
                            REAL_INIT_VALUE));
   blocked_dofs =
       &(alloc<bool>(sstr_boun.str(), nb_nodes, nb_degree_of_freedom, false));
   increment = &(alloc<Real>(sstr_incr.str(), nb_nodes, nb_degree_of_freedom,
                             REAL_INIT_VALUE));
 
   Mesh::type_iterator it = getFEEngine().getMesh().firstType(
       spatial_dimension, _not_ghost, _ek_structural);
   Mesh::type_iterator end = getFEEngine().getMesh().lastType(
       spatial_dimension, _not_ghost, _ek_structural);
   for (; it != end; ++it) {
     UInt nb_element = getFEEngine().getMesh().getNbElement(*it);
     UInt nb_quadrature_points = getFEEngine().getNbIntegrationPoints(*it);
 
     element_material.alloc(nb_element, 1, *it, _not_ghost);
     set_ID.alloc(nb_element, 1, *it, _not_ghost);
 
     UInt size = getTangentStiffnessVoigtSize(*it);
     stress.alloc(nb_element * nb_quadrature_points, size, *it, _not_ghost);
   }
 
   dof_synchronizer =
       new DOFSynchronizer(getFEEngine().getMesh(), nb_degree_of_freedom);
   dof_synchronizer->initLocalDOFEquationNumbers();
   dof_synchronizer->initGlobalDOFEquationNumbers();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initModel() {
   getFEEngine().initShapeFunctions(_not_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initSolver(__attribute__((unused))
                                           SolverOptions & options) {
   AKANTU_DEBUG_IN();
 
   const Mesh & mesh = getFEEngine().getMesh();
 #if !defined(AKANTU_USE_MUMPS) // or other solver in the future \todo add
                                // AKANTU_HAS_SOLVER in CMake
   AKANTU_DEBUG_ERROR("You should at least activate one solver.");
 #else
   UInt nb_global_node = mesh.getNbGlobalNodes();
 
   std::stringstream sstr;
   sstr << id << ":jacobian_matrix";
   jacobian_matrix = new SparseMatrix(nb_global_node * nb_degree_of_freedom,
                                      _symmetric, sstr.str(), memory_id);
 
   jacobian_matrix->buildProfile(mesh, *dof_synchronizer, nb_degree_of_freedom);
 
   std::stringstream sstr_sti;
   sstr_sti << id << ":stiffness_matrix";
   stiffness_matrix =
       new SparseMatrix(*jacobian_matrix, sstr_sti.str(), memory_id);
 
 #ifdef AKANTU_USE_MUMPS
   std::stringstream sstr_solv;
   sstr_solv << id << ":solver";
   solver = new SolverMumps(*jacobian_matrix, sstr_solv.str());
 
   dof_synchronizer->initScatterGatherCommunicationScheme();
 #else
   AKANTU_DEBUG_ERROR("You should at least activate one solver.");
 #endif // AKANTU_USE_MUMPS
 
   solver->initialize(options);
 #endif // AKANTU_HAS_SOLVER
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initImplicit(
     __attribute__((unused)) bool dynamic, SolverOptions & solver_options) {
   AKANTU_DEBUG_IN();
 
   if (!increment)
     setIncrementFlagOn();
 
   initSolver(solver_options);
 
   if (integrator)
     delete integrator;
   integrator = new TrapezoidalRule2();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt StructuralMechanicsModel::getTangentStiffnessVoigtSize(
     const ElementType & type) {
   UInt size;
 #define GET_TANGENT_STIFFNESS_VOIGT_SIZE(type)                                 \
   size = getTangentStiffnessVoigtSize<type>();
 
   AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(GET_TANGENT_STIFFNESS_VOIGT_SIZE);
 #undef GET_TANGENT_STIFFNESS_VOIGT_SIZE
 
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   stiffness_matrix->clear();
 
   Mesh::type_iterator it = getFEEngine().getMesh().firstType(
       spatial_dimension, _not_ghost, _ek_structural);
   Mesh::type_iterator end = getFEEngine().getMesh().lastType(
       spatial_dimension, _not_ghost, _ek_structural);
   for (; it != end; ++it) {
     ElementType type = *it;
 
 #define ASSEMBLE_STIFFNESS_MATRIX(type) assembleStiffnessMatrix<type>();
 
     AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(ASSEMBLE_STIFFNESS_MATRIX);
 #undef ASSEMBLE_STIFFNESS_MATRIX
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::computeRotationMatrix<_bernoulli_beam_2>(
     Array<Real> & rotations) {
 
   ElementType type = _bernoulli_beam_2;
   Mesh & mesh = getFEEngine().getMesh();
   UInt nb_element = mesh.getNbElement(type);
 
   Array<UInt>::iterator<Vector<UInt> > connec_it =
       mesh.getConnectivity(type).begin(2);
   Array<Real>::vector_iterator nodes_it =
       mesh.getNodes().begin(spatial_dimension);
   Array<Real>::matrix_iterator R_it =
       rotations.begin(nb_degree_of_freedom, nb_degree_of_freedom);
 
   for (UInt e = 0; e < nb_element; ++e, ++R_it, ++connec_it) {
     Matrix<Real> & R = *R_it;
     Vector<UInt> & connec = *connec_it;
 
     Vector<Real> x2;
     x2 = nodes_it[connec(1)]; // X2
     Vector<Real> x1;
     x1 = nodes_it[connec(0)]; // X1
 
     Real le = x1.distance(x2);
     Real c = (x2(0) - x1(0)) / le;
     Real s = (x2(1) - x1(1)) / le;
 
     /// Definition of the rotation matrix
     R(0, 0) = c;
     R(0, 1) = s;
     R(0, 2) = 0.;
     R(1, 0) = -s;
     R(1, 1) = c;
     R(1, 2) = 0.;
     R(2, 0) = 0.;
     R(2, 1) = 0.;
     R(2, 2) = 1.;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::computeRotationMatrix<_bernoulli_beam_3>(
     Array<Real> & rotations) {
   ElementType type = _bernoulli_beam_3;
   Mesh & mesh = getFEEngine().getMesh();
   UInt nb_element = mesh.getNbElement(type);
 
   Array<Real>::vector_iterator n_it =
       mesh.getNormals(type).begin(spatial_dimension);
   Array<UInt>::iterator<Vector<UInt> > connec_it =
       mesh.getConnectivity(type).begin(2);
   Array<Real>::vector_iterator nodes_it =
       mesh.getNodes().begin(spatial_dimension);
 
   Matrix<Real> Pe(spatial_dimension, spatial_dimension);
   Matrix<Real> Pg(spatial_dimension, spatial_dimension);
   Matrix<Real> inv_Pg(spatial_dimension, spatial_dimension);
   Vector<Real> x_n(spatial_dimension); // x vect n
 
   Array<Real>::matrix_iterator R_it =
       rotations.begin(nb_degree_of_freedom, nb_degree_of_freedom);
 
   for (UInt e = 0; e < nb_element; ++e, ++n_it, ++connec_it, ++R_it) {
     Vector<Real> & n = *n_it;
     Matrix<Real> & R = *R_it;
     Vector<UInt> & connec = *connec_it;
 
     Vector<Real> x;
     x = nodes_it[connec(1)]; // X2
     Vector<Real> y;
     y = nodes_it[connec(0)]; // X1
 
     Real l = x.distance(y);
     x -= y; // X2 - X1
     x_n.crossProduct(x, n);
 
     Pe.eye();
     Pe(0, 0) *= l;
     Pe(1, 1) *= -l;
 
     Pg(0, 0) = x(0);
     Pg(0, 1) = x_n(0);
     Pg(0, 2) = n(0);
     Pg(1, 0) = x(1);
     Pg(1, 1) = x_n(1);
     Pg(1, 2) = n(1);
     Pg(2, 0) = x(2);
     Pg(2, 1) = x_n(2);
     Pg(2, 2) = n(2);
 
     inv_Pg.inverse(Pg);
 
     Pe *= inv_Pg;
     for (UInt i = 0; i < spatial_dimension; ++i) {
       for (UInt j = 0; j < spatial_dimension; ++j) {
         R(i, j) = Pe(i, j);
         R(i + spatial_dimension, j + spatial_dimension) = Pe(i, j);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::computeRotationMatrix<_kirchhoff_shell>(
     Array<Real> & rotations) {
   ElementType type = _kirchhoff_shell;
   Mesh & mesh = getFEEngine().getMesh();
   UInt nb_element = mesh.getNbElement(type);
 
   Array<UInt>::iterator<Vector<UInt> > connec_it =
       mesh.getConnectivity(type).begin(3);
   Array<Real>::vector_iterator nodes_it =
       mesh.getNodes().begin(spatial_dimension);
 
   Matrix<Real> Pe(spatial_dimension, spatial_dimension);
   Matrix<Real> Pg(spatial_dimension, spatial_dimension);
   Matrix<Real> inv_Pg(spatial_dimension, spatial_dimension);
 
   Array<Real>::matrix_iterator R_it =
       rotations.begin(nb_degree_of_freedom, nb_degree_of_freedom);
 
   for (UInt e = 0; e < nb_element; ++e, ++connec_it, ++R_it) {
 
     Pe.eye();
 
     Matrix<Real> & R = *R_it;
     Vector<UInt> & connec = *connec_it;
 
     Vector<Real> x2;
     x2 = nodes_it[connec(1)]; // X2
     Vector<Real> x1;
     x1 = nodes_it[connec(0)]; // X1
     Vector<Real> x3;
     x3 = nodes_it[connec(2)]; // X3
 
     Vector<Real> Pg_col_1 = x2 - x1;
 
     Vector<Real> Pg_col_2 = x3 - x1;
 
     Vector<Real> Pg_col_3(spatial_dimension);
     Pg_col_3.crossProduct(Pg_col_1, Pg_col_2);
 
     for (UInt i = 0; i < spatial_dimension; ++i) {
       Pg(i, 0) = Pg_col_1(i);
       Pg(i, 1) = Pg_col_2(i);
       Pg(i, 2) = Pg_col_3(i);
     }
 
     inv_Pg.inverse(Pg);
     // Pe *= inv_Pg;
     Pe.eye();
 
     for (UInt i = 0; i < spatial_dimension; ++i) {
       for (UInt j = 0; j < spatial_dimension; ++j) {
         R(i, j) = Pe(i, j);
         R(i + spatial_dimension, j + spatial_dimension) = Pe(i, j);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::computeRotationMatrix(const ElementType & type) {
   Mesh & mesh = getFEEngine().getMesh();
 
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
   UInt nb_element = mesh.getNbElement(type);
 
   if (!rotation_matrix.exists(type)) {
     rotation_matrix.alloc(nb_element,
                           nb_degree_of_freedom * nb_nodes_per_element *
                               nb_degree_of_freedom * nb_nodes_per_element,
                           type);
   } else {
     rotation_matrix(type).resize(nb_element);
   }
   rotation_matrix(type).clear();
 
   Array<Real> rotations(nb_element,
                         nb_degree_of_freedom * nb_degree_of_freedom);
   rotations.clear();
 
 #define COMPUTE_ROTATION_MATRIX(type) computeRotationMatrix<type>(rotations);
 
   AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(COMPUTE_ROTATION_MATRIX);
 #undef COMPUTE_ROTATION_MATRIX
 
   Array<Real>::matrix_iterator R_it =
       rotations.begin(nb_degree_of_freedom, nb_degree_of_freedom);
   Array<Real>::matrix_iterator T_it =
       rotation_matrix(type).begin(nb_degree_of_freedom * nb_nodes_per_element,
                                   nb_degree_of_freedom * nb_nodes_per_element);
 
   for (UInt el = 0; el < nb_element; ++el, ++R_it, ++T_it) {
     Matrix<Real> & T = *T_it;
     Matrix<Real> & R = *R_it;
     T.clear();
     for (UInt k = 0; k < nb_nodes_per_element; ++k) {
       for (UInt i = 0; i < nb_degree_of_freedom; ++i)
         for (UInt j = 0; j < nb_degree_of_freedom; ++j)
           T(k * nb_degree_of_freedom + i, k * nb_degree_of_freedom + j) =
               R(i, j);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::computeStresses() {
   AKANTU_DEBUG_IN();
 
   Mesh::type_iterator it = getFEEngine().getMesh().firstType(
       spatial_dimension, _not_ghost, _ek_structural);
   Mesh::type_iterator end = getFEEngine().getMesh().lastType(
       spatial_dimension, _not_ghost, _ek_structural);
   for (; it != end; ++it) {
     ElementType type = *it;
 
 #define COMPUTE_STRESS_ON_QUAD(type) computeStressOnQuad<type>();
 
     AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(COMPUTE_STRESS_ON_QUAD);
 #undef COMPUTE_STRESS_ON_QUAD
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::updateResidual() {
   AKANTU_DEBUG_IN();
   residual->copy(*force_momentum);
 
   Array<Real> ku(*displacement_rotation, true);
   ku *= *stiffness_matrix;
   *residual -= ku;
 
   this->updateResidualInternal();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::implicitPred() {
   AKANTU_DEBUG_IN();
 
   if (previous_displacement)
     previous_displacement->copy(*displacement_rotation);
 
   if (method == _implicit_dynamic)
     integrator->integrationSchemePred(time_step, *displacement_rotation,
                                       *velocity, *acceleration, *blocked_dofs);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::implicitCorr() {
   AKANTU_DEBUG_IN();
 
   Real * incr_val = increment->storage();
   bool * boun_val = blocked_dofs->storage();
 
-  UInt nb_nodes = displacement_rotation->getSize();
+  UInt nb_nodes = displacement_rotation->size();
 
   for (UInt j = 0; j < nb_nodes * nb_degree_of_freedom;
        ++j, ++incr_val, ++boun_val) {
     *incr_val *= (1. - *boun_val);
   }
 
   if (method == _implicit_dynamic) {
     integrator->integrationSchemeCorrDispl(time_step, *displacement_rotation,
                                            *velocity, *acceleration,
                                            *blocked_dofs, *increment);
   } else {
 
     Real * disp_val = displacement_rotation->storage();
     incr_val = increment->storage();
 
     for (UInt j = 0; j < nb_nodes * nb_degree_of_freedom;
          ++j, ++disp_val, ++incr_val) {
       *disp_val += *incr_val;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::updateResidualInternal() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Update the residual");
   // f = f_ext - f_int - Ma - Cv = r - Ma - Cv;
 
   if (method != _static) {
     // f -= Ma
     if (mass_matrix) {
       // if full mass_matrix
       Array<Real> * Ma = new Array<Real>(*acceleration, true, "Ma");
       *Ma *= *mass_matrix;
       /// \todo check unit conversion for implicit dynamics
       //      *Ma /= f_m2a
       *residual -= *Ma;
       delete Ma;
     } else if (mass) {
 
       // else lumped mass
-      UInt nb_nodes = acceleration->getSize();
+      UInt nb_nodes = acceleration->size();
       UInt nb_degree_of_freedom = acceleration->getNbComponent();
 
       Real * mass_val = mass->storage();
       Real * accel_val = acceleration->storage();
       Real * res_val = residual->storage();
       bool * blocked_dofs_val = blocked_dofs->storage();
 
       for (UInt n = 0; n < nb_nodes * nb_degree_of_freedom; ++n) {
         if (!(*blocked_dofs_val)) {
           *res_val -= *accel_val ** mass_val / f_m2a;
         }
         blocked_dofs_val++;
         res_val++;
         mass_val++;
         accel_val++;
       }
     } else {
       AKANTU_DEBUG_ERROR("No function called to assemble the mass matrix.");
     }
 
     // f -= Cv
     if (velocity_damping_matrix) {
       Array<Real> * Cv = new Array<Real>(*velocity);
       *Cv *= *velocity_damping_matrix;
       *residual -= *Cv;
       delete Cv;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::setIncrementFlagOn() {
   AKANTU_DEBUG_IN();
 
   if (!increment) {
     UInt nb_nodes = mesh.getNbNodes();
     std::stringstream sstr_inc;
     sstr_inc << id << ":increment";
     increment = &(alloc<Real>(sstr_inc.str(), nb_nodes, spatial_dimension, 0.));
   }
 
   increment_flag = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::solve() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Solving an implicit step.");
 
-  UInt nb_nodes = displacement_rotation->getSize();
+  UInt nb_nodes = displacement_rotation->size();
 
   /// todo residual = force - Kxr * d_bloq
   jacobian_matrix->copyContent(*stiffness_matrix);
   jacobian_matrix->applyBoundary(*blocked_dofs);
 
   jacobian_matrix->saveMatrix("Kbound.mtx");
 
   increment->clear();
 
   solver->setRHS(*residual);
 
   solver->factorize();
   solver->solve(*increment);
 
   Real * increment_val = increment->storage();
   Real * displacement_val = displacement_rotation->storage();
   bool * blocked_dofs_val = blocked_dofs->storage();
 
   for (UInt n = 0; n < nb_nodes * nb_degree_of_freedom; ++n) {
     if (!(*blocked_dofs_val)) {
       *displacement_val += *increment_val;
     } else {
       *increment_val = 0.0;
     }
 
     displacement_val++;
     blocked_dofs_val++;
     increment_val++;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 bool StructuralMechanicsModel::testConvergence<_scc_increment>(Real tolerance,
                                                                Real & error) {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = displacement_rotation->getSize();
+  UInt nb_nodes = displacement_rotation->size();
   UInt nb_degree_of_freedom = displacement_rotation->getNbComponent();
 
   error = 0;
   Real norm[2] = {0., 0.};
   Real * increment_val = increment->storage();
   bool * blocked_dofs_val = blocked_dofs->storage();
   Real * displacement_val = displacement_rotation->storage();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
       if (!(*blocked_dofs_val)) {
         norm[0] += *increment_val * *increment_val;
         norm[1] += *displacement_val * *displacement_val;
       }
       blocked_dofs_val++;
       increment_val++;
       displacement_val++;
     }
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(norm, 2, _so_sum);
 
   norm[0] = sqrt(norm[0]);
   norm[1] = sqrt(norm[1]);
   AKANTU_DEBUG_ASSERT(!Math::isnan(norm[0]),
                       "Something went wrong in the solve phase");
 
   AKANTU_DEBUG_OUT();
   if (norm[1] > Math::getTolerance())
     error = norm[0] / norm[1];
   else
     error = norm[0]; // In case the total displacement is zero!
   return (error < tolerance);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 bool StructuralMechanicsModel::testConvergence<_scc_residual>(Real tolerance,
                                                               Real & norm) {
   AKANTU_DEBUG_IN();
 
-  UInt nb_nodes = residual->getSize();
+  UInt nb_nodes = residual->size();
 
   norm = 0;
   Real * residual_val = residual->storage();
   bool * blocked_dofs_val = blocked_dofs->storage();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     bool is_local_node = mesh.isLocalOrMasterNode(n);
     if (is_local_node) {
       for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
         if (!(*blocked_dofs_val)) {
           norm += *residual_val * *residual_val;
         }
         blocked_dofs_val++;
         residual_val++;
       }
     } else {
       blocked_dofs_val += spatial_dimension;
       residual_val += spatial_dimension;
     }
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(&norm, 1, _so_sum);
 
   norm = sqrt(norm);
 
   AKANTU_DEBUG_ASSERT(!Math::isnan(norm),
                       "Something goes wrong in the solve phase");
 
   AKANTU_DEBUG_OUT();
   return (norm < tolerance);
 }
 
 /* -------------------------------------------------------------------------- */
 bool StructuralMechanicsModel::testConvergenceIncrement(Real tolerance) {
   Real error;
   bool tmp = testConvergenceIncrement(tolerance, error);
 
   AKANTU_DEBUG_INFO("Norm of increment : " << error);
 
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 bool StructuralMechanicsModel::testConvergenceIncrement(Real tolerance,
                                                         Real & error) {
   AKANTU_DEBUG_IN();
   Mesh & mesh = getFEEngine().getMesh();
-  UInt nb_nodes = displacement_rotation->getSize();
+  UInt nb_nodes = displacement_rotation->size();
   UInt nb_degree_of_freedom = displacement_rotation->getNbComponent();
 
   Real norm = 0;
   Real * increment_val = increment->storage();
   bool * blocked_dofs_val = blocked_dofs->storage();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     bool is_local_node = mesh.isLocalOrMasterNode(n);
     for (UInt d = 0; d < nb_degree_of_freedom; ++d) {
       if (!(*blocked_dofs_val) && is_local_node) {
         norm += *increment_val * *increment_val;
       }
       blocked_dofs_val++;
       increment_val++;
     }
   }
 
   StaticCommunicator::getStaticCommunicator().allReduce(&norm, 1, _so_sum);
 
   error = sqrt(norm);
   AKANTU_DEBUG_ASSERT(!Math::isnan(norm),
                       "Something goes wrong in the solve phase");
 
   AKANTU_DEBUG_OUT();
   return (error < tolerance);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::computeTangentModuli<_bernoulli_beam_2>(
     Array<Real> & tangent_moduli) {
   UInt nb_element = getFEEngine().getMesh().getNbElement(_bernoulli_beam_2);
   UInt nb_quadrature_points =
       getFEEngine().getNbIntegrationPoints(_bernoulli_beam_2);
   UInt tangent_size = 2;
 
   Array<Real>::matrix_iterator D_it =
       tangent_moduli.begin(tangent_size, tangent_size);
   Array<UInt> & el_mat = element_material(_bernoulli_beam_2, _not_ghost);
 
   for (UInt e = 0; e < nb_element; ++e) {
     UInt mat = el_mat(e);
     Real E = materials[mat].E;
     Real A = materials[mat].A;
     Real I = materials[mat].I;
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++D_it) {
       Matrix<Real> & D = *D_it;
       D(0, 0) = E * A;
       D(1, 1) = E * I;
     }
   }
 }
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::computeTangentModuli<_bernoulli_beam_3>(
     Array<Real> & tangent_moduli) {
   UInt nb_element = getFEEngine().getMesh().getNbElement(_bernoulli_beam_3);
   UInt nb_quadrature_points =
       getFEEngine().getNbIntegrationPoints(_bernoulli_beam_3);
   UInt tangent_size = 4;
 
   Array<Real>::matrix_iterator D_it =
       tangent_moduli.begin(tangent_size, tangent_size);
 
   for (UInt e = 0; e < nb_element; ++e) {
     UInt mat = element_material(_bernoulli_beam_3, _not_ghost)(e);
     Real E = materials[mat].E;
     Real A = materials[mat].A;
     Real Iz = materials[mat].Iz;
     Real Iy = materials[mat].Iy;
     Real GJ = materials[mat].GJ;
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++D_it) {
       Matrix<Real> & D = *D_it;
       D(0, 0) = E * A;
       D(1, 1) = E * Iz;
       D(2, 2) = E * Iy;
       D(3, 3) = GJ;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::computeTangentModuli<_kirchhoff_shell>(
     Array<Real> & tangent_moduli) {
   UInt nb_element = getFEEngine().getMesh().getNbElement(_kirchhoff_shell);
   UInt nb_quadrature_points =
       getFEEngine().getNbIntegrationPoints(_kirchhoff_shell);
   UInt tangent_size = 6;
 
   Array<Real>::matrix_iterator D_it =
       tangent_moduli.begin(tangent_size, tangent_size);
 
   for (UInt e = 0; e < nb_element; ++e) {
     UInt mat = element_material(_kirchhoff_shell, _not_ghost)(e);
     Real E = materials[mat].E;
     Real nu = materials[mat].nu;
     Real t = materials[mat].t;
 
     Real HH = E * t / (1 - nu * nu);
     Real DD = E * t * t * t / (12 * (1 - nu * nu));
 
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++D_it) {
       Matrix<Real> & D = *D_it;
       D(0, 0) = HH;
       D(0, 1) = HH * nu;
       D(1, 0) = HH * nu;
       D(1, 1) = HH;
       D(2, 2) = HH * (1 - nu) / 2;
       D(3, 3) = DD;
       D(3, 4) = DD * nu;
       D(4, 3) = DD * nu;
       D(4, 4) = DD;
       D(5, 5) = DD * (1 - nu) / 2;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::transferBMatrixToSymVoigtBMatrix<
     _bernoulli_beam_2>(Array<Real> & b, __attribute__((unused)) bool local) {
   UInt nb_element = getFEEngine().getMesh().getNbElement(_bernoulli_beam_2);
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(_bernoulli_beam_2);
   UInt nb_quadrature_points =
       getFEEngine().getNbIntegrationPoints(_bernoulli_beam_2);
 
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
   Array<Real>::const_vector_iterator shape_Np =
       fem.getShapesDerivatives(_bernoulli_beam_2, _not_ghost, 0)
           .begin(nb_nodes_per_element);
   Array<Real>::const_vector_iterator shape_Mpp =
       fem.getShapesDerivatives(_bernoulli_beam_2, _not_ghost, 1)
           .begin(nb_nodes_per_element);
   Array<Real>::const_vector_iterator shape_Lpp =
       fem.getShapesDerivatives(_bernoulli_beam_2, _not_ghost, 2)
           .begin(nb_nodes_per_element);
 
   UInt tangent_size = getTangentStiffnessVoigtSize<_bernoulli_beam_2>();
   UInt bt_d_b_size = nb_nodes_per_element * nb_degree_of_freedom;
   b.clear();
   Array<Real>::matrix_iterator B_it = b.begin(tangent_size, bt_d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e) {
     for (UInt q = 0; q < nb_quadrature_points; ++q) {
       Matrix<Real> & B = *B_it;
       const Vector<Real> & Np = *shape_Np;
       const Vector<Real> & Lpp = *shape_Lpp;
       const Vector<Real> & Mpp = *shape_Mpp;
 
       B(0, 0) = Np(0);
       B(0, 3) = Np(1);
 
       B(1, 1) = Mpp(0);
       B(1, 2) = Lpp(0);
       B(1, 4) = Mpp(1);
       B(1, 5) = Lpp(1);
 
       ++B_it;
       ++shape_Np;
       ++shape_Mpp;
       ++shape_Lpp;
     }
 
     // ++R_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::transferBMatrixToSymVoigtBMatrix<
     _bernoulli_beam_3>(Array<Real> & b, __attribute__((unused)) bool local) {
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
 
   UInt nb_element = getFEEngine().getMesh().getNbElement(_bernoulli_beam_3);
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(_bernoulli_beam_3);
   UInt nb_quadrature_points =
       getFEEngine().getNbIntegrationPoints(_bernoulli_beam_3);
 
   Array<Real>::const_vector_iterator shape_Np =
       fem.getShapesDerivatives(_bernoulli_beam_3, _not_ghost, 0)
           .begin(nb_nodes_per_element);
   Array<Real>::const_vector_iterator shape_Mpp =
       fem.getShapesDerivatives(_bernoulli_beam_3, _not_ghost, 1)
           .begin(nb_nodes_per_element);
   Array<Real>::const_vector_iterator shape_Lpp =
       fem.getShapesDerivatives(_bernoulli_beam_3, _not_ghost, 2)
           .begin(nb_nodes_per_element);
 
   UInt tangent_size = getTangentStiffnessVoigtSize<_bernoulli_beam_3>();
   UInt bt_d_b_size = nb_nodes_per_element * nb_degree_of_freedom;
 
   b.clear();
 
   Array<Real>::matrix_iterator B_it = b.begin(tangent_size, bt_d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e) {
     for (UInt q = 0; q < nb_quadrature_points; ++q) {
       Matrix<Real> & B = *B_it;
 
       const Vector<Real> & Np = *shape_Np;
       const Vector<Real> & Lpp = *shape_Lpp;
       const Vector<Real> & Mpp = *shape_Mpp;
 
       B(0, 0) = Np(0);
       B(0, 6) = Np(1);
 
       B(1, 1) = Mpp(0);
       B(1, 5) = Lpp(0);
       B(1, 7) = Mpp(1);
       B(1, 11) = Lpp(1);
 
       B(2, 2) = Mpp(0);
       B(2, 4) = -Lpp(0);
       B(2, 8) = Mpp(1);
       B(2, 10) = -Lpp(1);
 
       B(3, 3) = Np(0);
       B(3, 9) = Np(1);
 
       ++B_it;
       ++shape_Np;
       ++shape_Mpp;
       ++shape_Lpp;
     }
   }
 }
 /* -------------------------------------------------------------------------- */
 template <>
 void StructuralMechanicsModel::transferBMatrixToSymVoigtBMatrix<
     _kirchhoff_shell>(Array<Real> & b, __attribute__((unused)) bool local) {
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
 
   UInt nb_element = getFEEngine().getMesh().getNbElement(_kirchhoff_shell);
   UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(_kirchhoff_shell);
   UInt nb_quadrature_points =
       getFEEngine().getNbIntegrationPoints(_kirchhoff_shell);
 
   Array<Real>::const_matrix_iterator shape_Np =
       fem.getShapesDerivatives(_kirchhoff_shell, _not_ghost, 0)
           .begin(2, nb_nodes_per_element);
   Array<Real>::const_matrix_iterator shape_Nx1p =
       fem.getShapesDerivatives(_kirchhoff_shell, _not_ghost, 1)
           .begin(2, nb_nodes_per_element);
   Array<Real>::const_matrix_iterator shape_Nx2p =
       fem.getShapesDerivatives(_kirchhoff_shell, _not_ghost, 2)
           .begin(2, nb_nodes_per_element);
   Array<Real>::const_matrix_iterator shape_Nx3p =
       fem.getShapesDerivatives(_kirchhoff_shell, _not_ghost, 3)
           .begin(2, nb_nodes_per_element);
   Array<Real>::const_matrix_iterator shape_Ny1p =
       fem.getShapesDerivatives(_kirchhoff_shell, _not_ghost, 4)
           .begin(2, nb_nodes_per_element);
   Array<Real>::const_matrix_iterator shape_Ny2p =
       fem.getShapesDerivatives(_kirchhoff_shell, _not_ghost, 5)
           .begin(2, nb_nodes_per_element);
   Array<Real>::const_matrix_iterator shape_Ny3p =
       fem.getShapesDerivatives(_kirchhoff_shell, _not_ghost, 6)
           .begin(2, nb_nodes_per_element);
 
   UInt tangent_size = getTangentStiffnessVoigtSize<_kirchhoff_shell>();
   UInt bt_d_b_size = nb_nodes_per_element * nb_degree_of_freedom;
 
   b.clear();
 
   Array<Real>::matrix_iterator B_it = b.begin(tangent_size, bt_d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e) {
     for (UInt q = 0; q < nb_quadrature_points; ++q) {
       Matrix<Real> & B = *B_it;
 
       const Matrix<Real> & Np = *shape_Np;
       const Matrix<Real> & Nx1p = *shape_Nx1p;
       const Matrix<Real> & Nx2p = *shape_Nx2p;
       const Matrix<Real> & Nx3p = *shape_Nx3p;
       const Matrix<Real> & Ny1p = *shape_Ny1p;
       const Matrix<Real> & Ny2p = *shape_Ny2p;
       const Matrix<Real> & Ny3p = *shape_Ny3p;
 
       B(0, 0) = Np(0, 0);
       B(0, 6) = Np(0, 1);
       B(0, 12) = Np(0, 2);
 
       B(1, 1) = Np(1, 0);
       B(1, 7) = Np(1, 1);
       B(1, 13) = Np(1, 2);
 
       B(2, 0) = Np(1, 0);
       B(2, 1) = Np(0, 0);
       B(2, 6) = Np(1, 1);
       B(2, 7) = Np(0, 1);
       B(2, 12) = Np(1, 2);
       B(2, 13) = Np(0, 2);
 
       B(3, 2) = Nx1p(0, 0);
       B(3, 3) = Nx2p(0, 0);
       B(3, 4) = Nx3p(0, 0);
       B(3, 8) = Nx1p(0, 1);
       B(3, 9) = Nx2p(0, 1);
       B(3, 10) = Nx3p(0, 1);
       B(3, 14) = Nx1p(0, 2);
       B(3, 15) = Nx2p(0, 2);
       B(3, 16) = Nx3p(0, 2);
 
       B(4, 2) = Ny1p(1, 0);
       B(4, 3) = Ny2p(1, 0);
       B(4, 4) = Ny3p(1, 0);
       B(4, 8) = Ny1p(1, 1);
       B(4, 9) = Ny2p(1, 1);
       B(4, 10) = Ny3p(1, 1);
       B(4, 14) = Ny1p(1, 2);
       B(4, 15) = Ny2p(1, 2);
       B(4, 16) = Ny3p(1, 2);
 
       B(5, 2) = Nx1p(1, 0) + Ny1p(0, 0);
       B(5, 3) = Nx2p(1, 0) + Ny2p(0, 0);
       B(5, 4) = Nx3p(1, 0) + Ny3p(0, 0);
       B(5, 8) = Nx1p(1, 1) + Ny1p(0, 1);
       B(5, 9) = Nx2p(1, 1) + Ny2p(0, 1);
       B(5, 10) = Nx3p(1, 1) + Ny3p(0, 1);
       B(5, 14) = Nx1p(1, 2) + Ny1p(0, 2);
       B(5, 15) = Nx2p(1, 2) + Ny2p(0, 2);
       B(5, 16) = Nx3p(1, 2) + Ny3p(0, 2);
 
       ++B_it;
       ++shape_Np;
       ++shape_Nx1p;
       ++shape_Nx2p;
       ++shape_Nx3p;
       ++shape_Ny1p;
       ++shape_Ny2p;
       ++shape_Ny3p;
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 dumper::Field *
 StructuralMechanicsModel::createNodalFieldBool(const std::string & field_name,
                                                const std::string & group_name,
                                                __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs;
 
   dumper::Field * field = NULL;
   field = mesh.createNodalField(uint_nodal_fields[field_name], group_name);
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 
 dumper::Field *
 StructuralMechanicsModel::createNodalFieldReal(const std::string & field_name,
                                                const std::string & group_name,
                                                bool padding_flag) {
 
   UInt n;
   if (spatial_dimension == 2) {
     n = 2;
   } else
     n = 3;
 
   dumper::Field * field = NULL;
 
   if (field_name == "displacement") {
     field = mesh.createStridedNodalField(displacement_rotation, group_name, n,
                                          0, padding_flag);
   }
   if (field_name == "rotation") {
     field =
         mesh.createStridedNodalField(displacement_rotation, group_name,
                                      nb_degree_of_freedom - n, n, padding_flag);
   }
   if (field_name == "force") {
     field = mesh.createStridedNodalField(force_momentum, group_name, n, 0,
                                          padding_flag);
   }
   if (field_name == "momentum") {
     field = mesh.createStridedNodalField(
         force_momentum, group_name, nb_degree_of_freedom - n, n, padding_flag);
   }
   if (field_name == "residual") {
     field = mesh.createNodalField(residual, group_name, padding_flag);
   }
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 
 dumper::Field * StructuralMechanicsModel::createElementalField(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag, const ElementKind & kind,
     __attribute__((unused)) const std::string & fe_engine_id) {
 
   dumper::Field * field = NULL;
 
   if (field_name == "element_index_by_material")
     field = mesh.createElementalField<UInt, Vector, dumper::ElementalField>(
         field_name, group_name, this->spatial_dimension, kind);
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc b/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc
index f552fa76a..f75781a8e 100644
--- a/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc
+++ b/src/model/structural_mechanics/structural_mechanics_model_inline_impl.cc
@@ -1,615 +1,615 @@
 /**
  * @file   structural_mechanics_model_inline_impl.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Fri Jul 15 2011
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Implementation of inline functions of StructuralMechanicsModel
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template<ElementType type>
 inline UInt StructuralMechanicsModel::getTangentStiffnessVoigtSize() {
   AKANTU_DEBUG_TO_IMPLEMENT();
   return 0;
 }
 
 template<>
 inline UInt StructuralMechanicsModel::getTangentStiffnessVoigtSize<_bernoulli_beam_2>() {
   return 2;
 }
 
 template<>
 inline UInt StructuralMechanicsModel::getTangentStiffnessVoigtSize<_bernoulli_beam_3>() {
   return 4;
 }
 
 /* -------------------------------------------------------------------------- */
 
 template<>
 inline UInt StructuralMechanicsModel::getTangentStiffnessVoigtSize<_kirchhoff_shell>() {
   return 6;
 }
 
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type>
 void StructuralMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   SparseMatrix & K = *stiffness_matrix;
 
   UInt nb_element                 = getFEEngine().getMesh().getNbElement(type);
   UInt nb_nodes_per_element       = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points       = getFEEngine().getNbIntegrationPoints(type);
 
   UInt tangent_size = getTangentStiffnessVoigtSize<type>();
 
   Array<Real> * tangent_moduli =
     new Array<Real>(nb_element * nb_quadrature_points, tangent_size * tangent_size,
 		     "tangent_stiffness_matrix");
 
   tangent_moduli->clear();
 
   computeTangentModuli<type>(*tangent_moduli);
 
   /// compute @f$\mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   UInt bt_d_b_size = nb_degree_of_freedom * nb_nodes_per_element;
 
   Array<Real> * bt_d_b = new Array<Real>(nb_element*nb_quadrature_points,
 					   bt_d_b_size * bt_d_b_size,
 					   "B^t*D*B");
 
   Array<Real> * b = new Array<Real>(nb_element*nb_quadrature_points,
 				      tangent_size*bt_d_b_size,
 				      "B");
 
   transferBMatrixToSymVoigtBMatrix<type>(*b);
 
   Matrix<Real> Bt_D(bt_d_b_size, tangent_size);
   Matrix<Real> BT(tangent_size, bt_d_b_size);
 
   Array<Real>::matrix_iterator B = b->begin(tangent_size, bt_d_b_size);
   Array<Real>::matrix_iterator D = tangent_moduli->begin(tangent_size, tangent_size);
   Array<Real>::matrix_iterator Bt_D_B = bt_d_b->begin(bt_d_b_size, bt_d_b_size);
   Array<Real>::matrix_iterator T = rotation_matrix(type).begin(bt_d_b_size, bt_d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e, ++T) {
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++B, ++D, ++Bt_D_B) {
       BT.mul<false, false>(*B, *T);
       Bt_D.mul<true, false>(BT, *D);
       Bt_D_B->mul<false, false>(Bt_D, BT);
     }
   }
 
   delete b;
   delete tangent_moduli;
 
   /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
   Array<Real> * int_bt_d_b = new Array<Real>(nb_element,
 					   bt_d_b_size * bt_d_b_size,
 					   "int_B^t*D*B");
 
   getFEEngine().integrate(*bt_d_b, *int_bt_d_b,
 		     bt_d_b_size * bt_d_b_size,
 		     type);
 
   delete bt_d_b;
 
   getFEEngine().assembleMatrix(*int_bt_d_b, K, nb_degree_of_freedom, type);
 
   delete int_bt_d_b;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template<ElementType type>
 void StructuralMechanicsModel::computeTangentModuli(Array<Real> & tangent_moduli) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 
 /* -------------------------------------------------------------------------- */
 template<ElementType type>
 void StructuralMechanicsModel::transferBMatrixToSymVoigtBMatrix(Array<Real> & b, bool local) {
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template<ElementType type>
 void StructuralMechanicsModel::computeStressOnQuad() {
   AKANTU_DEBUG_IN();
 
   Array<Real> & sigma  = stress(type, _not_ghost);
 
   sigma.clear();
   const Mesh & mesh = getFEEngine().getMesh();
 
   UInt nb_element                 = mesh.getNbElement(type);
   UInt nb_nodes_per_element       = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points       = getFEEngine().getNbIntegrationPoints(type);
 
   UInt tangent_size = getTangentStiffnessVoigtSize<type>();
 
   Array<Real> * tangent_moduli =
     new Array<Real>(nb_element*nb_quadrature_points, tangent_size * tangent_size,
 		     "tangent_stiffness_matrix");
   tangent_moduli->clear();
 
   computeTangentModuli<type>(*tangent_moduli);
 
   /// compute DB
   UInt d_b_size = nb_degree_of_freedom * nb_nodes_per_element;
 
   Array<Real> * d_b = new Array<Real>(nb_element*nb_quadrature_points,
 					d_b_size * tangent_size,
 					"D*B");
 
   Array<Real> * b = new Array<Real>(nb_element*nb_quadrature_points,
 				      tangent_size*d_b_size,
 				      "B");
 
   transferBMatrixToSymVoigtBMatrix<type>(*b);
 
   Array<Real>::matrix_iterator B = b->begin(tangent_size, d_b_size);
   Array<Real>::matrix_iterator D = tangent_moduli->begin(tangent_size, tangent_size);
   Array<Real>::matrix_iterator D_B = d_b->begin(tangent_size, d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e) {
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++B, ++D, ++D_B) {
       D_B->mul<false, false>(*D, *B);
     }
   }
 
   delete b;
   delete tangent_moduli;
 
   /// compute DBu
   D_B = d_b->begin(tangent_size, d_b_size);
   Array<Real>::iterator< Vector<Real> > DBu = sigma.begin(tangent_size);
   Vector<Real> ul (d_b_size);
 
   Array<Real> u_el(0, d_b_size);
   FEEngine::extractNodalToElementField(mesh, *displacement_rotation, u_el, type);
 
   Array<Real>::vector_iterator ug = u_el.begin(d_b_size);
   Array<Real>::matrix_iterator T = rotation_matrix(type).begin(d_b_size, d_b_size);
 
   for (UInt e = 0; e < nb_element; ++e, ++T, ++ug) {
     ul.mul<false>(*T, *ug);
     for (UInt q = 0; q < nb_quadrature_points; ++q, ++D_B, ++DBu) {
       DBu->mul<false>(*D_B, ul);
     }
   }
 
   delete d_b;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template<ElementType type>
 void StructuralMechanicsModel::computeForcesByLocalTractionArray(const Array<Real> & tractions) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = getFEEngine().getMesh().getNbElement(type);
   UInt nb_nodes_per_element = getFEEngine().getMesh().getNbNodesPerElement(type);
   UInt nb_quad = getFEEngine().getNbIntegrationPoints(type);
 
   // check dimension match
   AKANTU_DEBUG_ASSERT(Mesh::getSpatialDimension(type) == getFEEngine().getElementDimension(),
 		      "element type dimension does not match the dimension of boundaries : " <<
 		      getFEEngine().getElementDimension() << " != " <<
 		      Mesh::getSpatialDimension(type));
 
   // check size of the vector
-  AKANTU_DEBUG_ASSERT(tractions.getSize() == nb_quad*nb_element,
+  AKANTU_DEBUG_ASSERT(tractions.size() == nb_quad*nb_element,
 		      "the size of the vector should be the total number of quadrature points");
 
   // check number of components
   AKANTU_DEBUG_ASSERT(tractions.getNbComponent() == nb_degree_of_freedom,
 		      "the number of components should be the spatial dimension of the problem");
 
 
   Array<Real> Nvoigt(nb_element * nb_quad, nb_degree_of_freedom * nb_degree_of_freedom * nb_nodes_per_element);
   transferNMatrixToSymVoigtNMatrix<type>(Nvoigt);
 
   Array<Real>::const_matrix_iterator N_it = Nvoigt.begin(nb_degree_of_freedom,
 								   nb_degree_of_freedom * nb_nodes_per_element);
   Array<Real>::const_matrix_iterator T_it = rotation_matrix(type).begin(nb_degree_of_freedom * nb_nodes_per_element,
 										  nb_degree_of_freedom * nb_nodes_per_element);
   Array<Real>::const_vector_iterator te_it = tractions.begin(nb_degree_of_freedom);
 
   Array<Real> funct(nb_element * nb_quad, nb_degree_of_freedom * nb_nodes_per_element, 0.);
   Array<Real>::iterator< Vector<Real> > Fe_it = funct.begin(nb_degree_of_freedom * nb_nodes_per_element);
 
   Vector<Real> fe(nb_degree_of_freedom * nb_nodes_per_element);
   for (UInt e = 0; e < nb_element; ++e, ++T_it) {
     const Matrix<Real> & T = *T_it;
     for (UInt q = 0; q < nb_quad; ++q, ++N_it, ++te_it, ++Fe_it) {
       const Matrix<Real> & N = *N_it;
       const Vector<Real> & te = *te_it;
       Vector<Real> & Fe = *Fe_it;
 
       // compute N^t tl
       fe.mul<true>(N, te);
       // turn N^t tl back in the global referential
       Fe.mul<true>(T, fe);
     }
   }
 
   // allocate the vector that will contain the integrated values
   std::stringstream name;
   name << id << type << ":integral_boundary";
   Array<Real> int_funct(nb_element, nb_degree_of_freedom * nb_nodes_per_element, name.str());
 
   //do the integration
   getFEEngine().integrate(funct, int_funct, nb_degree_of_freedom*nb_nodes_per_element, type);
 
   // assemble the result into force vector
   getFEEngine().assembleArray(int_funct,*force_momentum,
 			  dof_synchronizer->getLocalDOFEquationNumbers(),
 			  nb_degree_of_freedom, type);
   AKANTU_DEBUG_OUT();
 }
 
 
 /* -------------------------------------------------------------------------- */
 template<ElementType type>
 void StructuralMechanicsModel::computeForcesByGlobalTractionArray(const Array<Real> & traction_global){
  AKANTU_DEBUG_IN();
   UInt nb_element = getFEEngine().getMesh().getNbElement(type);
   UInt nb_quad = getFEEngine().getNbIntegrationPoints(type);
   UInt nb_nodes_per_element = getFEEngine().getMesh().getNbNodesPerElement(type);
 
   std::stringstream name;
   name << id << ":structuralmechanics:imposed_linear_load";
   Array<Real> traction_local(nb_element*nb_quad, nb_degree_of_freedom, name.str());
 
   Array<Real>::const_matrix_iterator T_it = rotation_matrix(type).begin(nb_degree_of_freedom * nb_nodes_per_element,
 										  nb_degree_of_freedom * nb_nodes_per_element);
 
   Array<Real>::const_iterator< Vector<Real> > Te_it = traction_global.begin(nb_degree_of_freedom);
   Array<Real>::iterator< Vector<Real> > te_it = traction_local.begin(nb_degree_of_freedom);
 
   Matrix<Real> R(nb_degree_of_freedom, nb_degree_of_freedom);
   for (UInt e = 0; e < nb_element; ++e, ++T_it) {
     const Matrix<Real> & T = *T_it;
     for (UInt i = 0; i < nb_degree_of_freedom; ++i)
       for (UInt j = 0; j < nb_degree_of_freedom; ++j)
 	R(i, j) = T(i, j);
 
     for (UInt q = 0; q < nb_quad; ++q, ++Te_it, ++te_it) {
       const Vector<Real> & Te = *Te_it;
       Vector<Real> & te = *te_it;
       // turn the traction in the local referential
       te.mul<false>(R, Te);
     }
   }
 
   computeForcesByLocalTractionArray<type>(traction_local);
 
   AKANTU_DEBUG_OUT();
 
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * @param myf pointer  to a function that fills a  vector/tensor with respect to
  * passed coordinates
  */
 template<ElementType type>
 inline void StructuralMechanicsModel::computeForcesFromFunction(BoundaryFunction myf,
 							 BoundaryFunctionType function_type){
   /** function type is
    ** _bft_forces : linear load is given
    ** _bft_stress : stress function is given -> Not already done for this kind of model
    */
 
   std::stringstream name;
   name << id << ":structuralmechanics:imposed_linear_load";
   Array<Real> lin_load(0, nb_degree_of_freedom,name.str());
   name.clear();
 
   UInt offset = nb_degree_of_freedom;
 
   //prepare the loop over element types
   UInt nb_quad           = getFEEngine().getNbIntegrationPoints(type);
   UInt nb_element        = getFEEngine().getMesh().getNbElement(type);
 
   name.clear();
   name << id << ":structuralmechanics:quad_coords";
   Array<Real> quad_coords(nb_element * nb_quad, spatial_dimension, "quad_coords");
 
 
   getFEEngineClass<MyFEEngineType>().getShapeFunctions().interpolateOnIntegrationPoints<type>(getFEEngine().getMesh().getNodes(),
 										quad_coords,
 										spatial_dimension);
   getFEEngineClass<MyFEEngineType>().getShapeFunctions().interpolateOnIntegrationPoints<type>(getFEEngine().getMesh().getNodes(),
 										quad_coords,
 										spatial_dimension,
 										_not_ghost,
 										empty_filter,
 										true,
 										0,
 										1,
 										1);
   if(spatial_dimension == 3)
     getFEEngineClass<MyFEEngineType>().getShapeFunctions().interpolateOnIntegrationPoints<type>(getFEEngine().getMesh().getNodes(),
 										  quad_coords,
 										  spatial_dimension,
 										  _not_ghost,
 										  empty_filter,
 										  true,
 										  0,
 										  2,
 										  2);
   lin_load.resize(nb_element*nb_quad);
   Real * imposed_val = lin_load.storage();
 
   /// sigma/load on each quadrature points
   Real * qcoord = quad_coords.storage();
   for (UInt el = 0; el < nb_element; ++el) {
     for (UInt q = 0; q < nb_quad; ++q) {
       myf(qcoord, imposed_val, NULL, 0);
       imposed_val += offset;
       qcoord += spatial_dimension;
     }
   }
 
   switch(function_type) {
   case _bft_traction_local:
     computeForcesByLocalTractionArray<type>(lin_load); break;
   case _bft_traction:
     computeForcesByGlobalTractionArray<type>(lin_load); break;
   default: break;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline void StructuralMechanicsModel::assembleMass<_bernoulli_beam_2>() {
   AKANTU_DEBUG_IN();
   
   GhostType ghost_type = _not_ghost;
   ElementType type = _bernoulli_beam_2;
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
   UInt nb_element                 = getFEEngine().getMesh().getNbElement(type);
   UInt nb_nodes_per_element       = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points       = getFEEngine().getNbIntegrationPoints(type);
   UInt nb_fields_to_interpolate = getTangentStiffnessVoigtSize<_bernoulli_beam_2>();
 
   UInt nt_n_field_size = nb_degree_of_freedom * nb_nodes_per_element;
 
   Array<Real> * n = new Array<Real>(nb_element*nb_quadrature_points,
 				    nb_fields_to_interpolate * nt_n_field_size,
 				    "N");
   n->clear();
   Array<Real> * rho_field = new Array<Real>(nb_element*nb_quadrature_points,
 					  "Rho");
   rho_field->clear();
   computeRho(*rho_field, type, _not_ghost);
   
   bool sign = true;
   
 /* -------------------------------------------------------------------------- */
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 0, 0, 0, sign, ghost_type); // Ni ui -> u
 
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 1, 1, 1, sign, ghost_type); // Mi vi -> v
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 2, 2, 1, sign, ghost_type); // Li Theta_i -> v
 /* -------------------------------------------------------------------------- */
 
   fem.assembleFieldMatrix(*rho_field, nb_degree_of_freedom, *mass_matrix, n, rotation_matrix, type, ghost_type);
   
   delete n;
   delete rho_field;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline void StructuralMechanicsModel::assembleMass<_bernoulli_beam_3>() {
   AKANTU_DEBUG_IN();
 
   GhostType ghost_type = _not_ghost;
   ElementType type = _bernoulli_beam_3;
   MyFEEngineType & fem = getFEEngineClass<MyFEEngineType>();
   UInt nb_element                 = getFEEngine().getMesh().getNbElement(type);
   UInt nb_nodes_per_element       = Mesh::getNbNodesPerElement(type);
   UInt nb_quadrature_points       = getFEEngine().getNbIntegrationPoints(type);
   UInt nb_fields_to_interpolate = getTangentStiffnessVoigtSize<_bernoulli_beam_3>();
 
   UInt nt_n_field_size = nb_degree_of_freedom * nb_nodes_per_element; 
 
   Array<Real> * n = new Array<Real>(nb_element*nb_quadrature_points,
 				    nb_fields_to_interpolate * nt_n_field_size,
 				    "N");
   n->clear();
   Array<Real> * rho_field = new Array<Real>(nb_element * nb_quadrature_points,
 					   "Rho");
   rho_field->clear();
   computeRho(*rho_field, type, _not_ghost);
   
 /* -------------------------------------------------------------------------- */
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 0, 0, 0, true, ghost_type); // Ni ui ->         u
 
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 1, 1, 1, true, ghost_type); // Mi vi ->         v
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 2, 5, 1, true, ghost_type); // Li Theta_z_i ->  v
 
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 1, 2, 2, true, ghost_type); // Mi wi ->        w
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 2, 4, 2, false,ghost_type);// -Li Theta_y_i ->  w
 
   fem.computeShapesMatrix(type, nb_degree_of_freedom, nb_nodes_per_element, n, 0, 3, 3, true, ghost_type); // Ni Theta_x_i->Theta_x
 /* -------------------------------------------------------------------------- */
 
   fem.assembleFieldMatrix(*rho_field, nb_degree_of_freedom, *mass_matrix, n, rotation_matrix, type, ghost_type);
   
   delete n;
   delete rho_field;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline void StructuralMechanicsModel::assembleMass<_kirchhoff_shell>() {
 
   AKANTU_DEBUG_TO_IMPLEMENT();
 
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template<SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 bool StructuralMechanicsModel::solveStep(Real tolerance,
 					 UInt max_iteration) {
   Real error = 0.;
   return this->template solveStep<cmethod,criteria>(tolerance,
 						    error,
 						    max_iteration);
 }
 
 /* -------------------------------------------------------------------------- */
 template<SolveConvergenceMethod cmethod, SolveConvergenceCriteria criteria>
 bool StructuralMechanicsModel::solveStep(Real tolerance, Real & error, UInt max_iteration) {
   
   this->implicitPred();
   this->updateResidual();
 
   AKANTU_DEBUG_ASSERT(stiffness_matrix != NULL,
 		      "You should first initialize the implicit solver and assemble the stiffness matrix");
 
   if (method==_implicit_dynamic) {
     AKANTU_DEBUG_ASSERT(mass_matrix != NULL,
 			"You should first initialize the implicit solver and assemble the mass matrix");
   }
 
   switch (cmethod) {
   case _scm_newton_raphson_tangent:
   case _scm_newton_raphson_tangent_not_computed:
     break;
   case _scm_newton_raphson_tangent_modified:
     this->assembleStiffnessMatrix();
     break;
   default:
     AKANTU_DEBUG_ERROR("The resolution method " << cmethod << " has not been implemented!");
   }
 
   UInt iter = 0;
   bool converged = false;
   error = 0.;
   if(criteria == _scc_residual) {
     converged = this->testConvergence<criteria> (tolerance, error);
     if(converged) return converged;
   }
 
   do {
     if (cmethod == _scm_newton_raphson_tangent)
       this->assembleStiffnessMatrix();
 
     solve<NewmarkBeta::_displacement_corrector> (*increment);
 
     this->implicitCorr();
 
     if(criteria == _scc_residual) this->updateResidual();
 
     converged = this->testConvergence<criteria> (tolerance, error);
 
     if(criteria == _scc_increment && !converged) this->updateResidual();
     //this->dump();
 
     iter++;
     AKANTU_DEBUG_INFO("[" << criteria << "] Convergence iteration "
 		      << std::setw(std::log10(max_iteration)) << iter
 		      << ": error " << error << (converged ? " < " : " > ") << tolerance);
 
   } while (!converged && iter < max_iteration);
 
 
   if (converged) {
     
   } else if(iter == max_iteration) {
     AKANTU_DEBUG_WARNING("[" << criteria << "] Convergence not reached after "
                          << std::setw(std::log10(max_iteration)) << iter <<
                          " iteration" << (iter == 1 ? "" : "s") << "!" << std::endl);
   }
 
   return converged;
 }
 /* -------------------------------------------------------------------------- */
 template<NewmarkBeta::IntegrationSchemeCorrectorType type>
 void StructuralMechanicsModel::solve(Array<Real> & increment,
                                 Real block_val) {
   jacobian_matrix->clear();
 
   //updateResidualInternal(); //doesn't do anything for static
 
   Real c = 0.,d = 0.,e = 0.;
 
   if(method == _static) {
     AKANTU_DEBUG_INFO("Solving K inc = r");
     e = 1.;
   } else {
     AKANTU_DEBUG_INFO("Solving (c M + d C + e K) inc = r");
 
     NewmarkBeta * nmb_int = dynamic_cast<NewmarkBeta *>(integrator);
     c = nmb_int->getAccelerationCoefficient<type>(time_step);
     d = nmb_int->getVelocityCoefficient<type>(time_step);
     e = nmb_int->getDisplacementCoefficient<type>(time_step);
   }
 
   // J = c M + d C + e K
   if(stiffness_matrix)
     jacobian_matrix->add(*stiffness_matrix, e);
 
 //  if(type != NewmarkBeta::_acceleration_corrector)
 //    jacobian_matrix->add(*stiffness_matrix, e);
 
   if(mass_matrix)
     jacobian_matrix->add(*mass_matrix, c);
 
 #if !defined(AKANTU_NDEBUG)
   if(mass_matrix && AKANTU_DEBUG_TEST(dblDump))
     mass_matrix->saveMatrix("M.mtx");
 #endif
 
   if(velocity_damping_matrix)
     jacobian_matrix->add(*velocity_damping_matrix, d);
 
   jacobian_matrix->applyBoundary(*blocked_dofs);
 
 #if !defined(AKANTU_NDEBUG)
   if(AKANTU_DEBUG_TEST(dblDump))
     jacobian_matrix->saveMatrix("J.mtx");
 #endif
 
   solver->setRHS(*residual);
   // solve @f[ J \delta w = r @f]
   solver->factorize();
   solver->solve(increment);
 }
diff --git a/src/python/python_functor_inline_impl.cc b/src/python/python_functor_inline_impl.cc
index bd9bba712..5d693bc6a 100644
--- a/src/python/python_functor_inline_impl.cc
+++ b/src/python/python_functor_inline_impl.cc
@@ -1,337 +1,337 @@
 /**
  * @file   python_functor_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date creation: Fri Nov 13 2015
  * @date last modification: Wed Nov 18 2015
  *
  * @brief  Python functor interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__
 #define __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__
 
 /* -------------------------------------------------------------------------- */
 #include "integration_point.hh"
 #include <numpy/arrayobject.h>
 #include <typeinfo>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 
 template <typename T> inline int PythonFunctor::getPythonDataTypeCode() const {
   AKANTU_EXCEPTION("undefined type: " << debug::demangle(typeid(T).name()));
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline int PythonFunctor::getPythonDataTypeCode<bool>() const {
   int data_typecode = NPY_NOTYPE;
   size_t s = sizeof(bool);
   switch (s) {
   case 1:
     data_typecode = NPY_BOOL;
     break;
   case 2:
     data_typecode = NPY_UINT16;
     break;
   case 4:
     data_typecode = NPY_UINT32;
     break;
   case 8:
     data_typecode = NPY_UINT64;
     break;
   }
   return data_typecode;
 }
 
 /* -------------------------------------------------------------------------- */
 template <> inline int PythonFunctor::getPythonDataTypeCode<double>() const {
   return NPY_DOUBLE;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(__attribute__((unused))
                                           const T & akantu_object) const {
   AKANTU_DEBUG_ERROR(
       __func__ << " : not implemented yet !" << std::endl
                << debug::demangle(typeid(T).name())
                << "\n*************************************************\n\n\n");
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<double>(const double & akantu_object) const {
   return PyFloat_FromDouble(akantu_object);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<UInt>(const UInt & akantu_object) const {
   return PyInt_FromLong(akantu_object);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<bool>(const bool & akantu_object) const {
   return PyBool_FromLong(long(akantu_object));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline PyObject *
 PythonFunctor::convertToPython(const std::vector<T> & array) const {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[1] = {int(array.size())};
   PyObject * obj = PyArray_SimpleNewFromData(1, dims, data_typecode,
                                              const_cast<T *>(&array[0]));
   PyArrayObject * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline PyObject *
 PythonFunctor::convertToPython(const std::vector<Array<T> *> & array) const {
 
   PyObject * res = PyDict_New();
 
   for (auto a : array) {
     PyObject * obj = this->convertToPython(*a);
     PyObject * name = this->convertToPython(a->getID());
     PyDict_SetItem(res, name, obj);
   }
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 
 template <typename T1, typename T2>
 inline PyObject *
 PythonFunctor::convertToPython(const std::map<T1, T2> & map) const {
 
   PyObject * res = PyDict_New();
 
   for (auto a : map) {
     PyObject * key = this->convertToPython(a.first);
     PyObject * value = this->convertToPython(a.second);
     PyDict_SetItem(res, key, value);
   }
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Vector<T> & array) const {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[1] = {array.size()};
   PyObject * obj =
       PyArray_SimpleNewFromData(1, dims, data_typecode, array.storage());
   PyArrayObject * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Array<T> & array) const {
   int data_typecode = getPythonDataTypeCode<T>();
-  npy_intp dims[2] = {array.getSize(), array.getNbComponent()};
+  npy_intp dims[2] = {array.size(), array.getNbComponent()};
   PyObject * obj =
       PyArray_SimpleNewFromData(2, dims, data_typecode, array.storage());
   PyArrayObject * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(Array<T> * array) const {
   return this->convertToPython(*array);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 PyObject * PythonFunctor::convertToPython(const Matrix<T> & mat) const {
   int data_typecode = getPythonDataTypeCode<T>();
   npy_intp dims[2] = {mat.size(0), mat.size(1)};
   PyObject * obj =
       PyArray_SimpleNewFromData(2, dims, data_typecode, mat.storage());
   PyArrayObject * res = (PyArrayObject *)obj;
   return (PyObject *)res;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject *
 PythonFunctor::convertToPython<std::string>(const std::string & str) const {
   return PyString_FromString(str.c_str());
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline PyObject * PythonFunctor::convertToPython<IntegrationPoint>(
     const IntegrationPoint & qp) const {
 
   PyObject * input = PyDict_New();
   PyObject * num_point = this->convertToPython(qp.num_point);
   PyObject * global_num = this->convertToPython(qp.global_num);
   PyObject * material_id = this->convertToPython(qp.material_id);
   PyObject * position = this->convertToPython(qp.getPosition());
   PyDict_SetItemString(input, "num_point", num_point);
   PyDict_SetItemString(input, "global_num", global_num);
   PyDict_SetItemString(input, "material_id", material_id);
   PyDict_SetItemString(input, "position", position);
   return input;
 }
 
 /* -------------------------------------------------------------------------- */
 inline PyObject *
 PythonFunctor::getPythonFunction(const std::string & functor_name) const {
   if (!PyInstance_Check(this->python_obj))
     AKANTU_EXCEPTION("Python object is not an instance");
 
   // if (!PyDict_Check(this->python_obj))
   //   AKANTU_EXCEPTION("Python object is not a dictionary");
 
   // PyObject * keys = PyDict_Keys(dict);
   // PyObject_Print(keys, stdout, Py_PRINT_RAW);
 
   PyObject * pFunctor =
       PyObject_GetAttrString(this->python_obj, functor_name.c_str());
   if (!pFunctor)
     AKANTU_EXCEPTION("Python dictionary has no " << functor_name << " entry");
 
   return pFunctor;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void
 PythonFunctor::packArguments(__attribute__((unused))
                              std::vector<PyObject *> & p_args) const {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename... Args>
 inline void PythonFunctor::packArguments(std::vector<PyObject *> & p_args,
                                          T & p, Args &... params) const {
   p_args.push_back(this->convertToPython(p));
   if (sizeof...(params) != 0)
     this->packArguments(p_args, params...);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename return_type, typename... Params>
 return_type PythonFunctor::callFunctor(const std::string & functor_name,
                                        Params &... parameters) const {
   _import_array();
 
   std::vector<PyObject *> arg_vector;
   this->packArguments(arg_vector, parameters...);
 
   PyObject * pArgs = PyTuple_New(arg_vector.size());
   for (UInt i = 0; i < arg_vector.size(); ++i) {
     PyTuple_SetItem(pArgs, i, arg_vector[i]);
   }
 
   PyObject * kwargs = PyDict_New();
 
   PyObject * pFunctor = getPythonFunction(functor_name);
   PyObject * res = this->callFunctor(pFunctor, pArgs, kwargs);
 
   // for (auto a: arg_vector) {
   //   // if (PyDict_Check(a)){
   //   //   PyObject* values = PyDict_Values(a);
   //   //   UInt sz = PyList_GET_SIZE(values);
   //   //   for (UInt i = 0; i < sz; ++i) {
   //   // 	Py_XDECREF(PyList_GetItem(values,i));
   //   //   }
   //   // }
   //   // Py_XDECREF(a);
   // }
   Py_XDECREF(pArgs);
   Py_XDECREF(kwargs);
 
   return this->convertToAkantu<return_type>(res);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename return_type>
 inline return_type PythonFunctor::convertToAkantu(PyObject * python_obj) const {
 
   if (PyList_Check(python_obj)) {
     return this->convertListToAkantu<typename return_type::value_type>(
         python_obj);
   }
   AKANTU_DEBUG_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void PythonFunctor::convertToAkantu<void>(PyObject * python_obj) const {
   if (python_obj != Py_None)
     AKANTU_DEBUG_WARNING(
         "functor return a value while none was expected: ignored");
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline std::string
 PythonFunctor::convertToAkantu<std::string>(PyObject * python_obj) const {
   if (!PyString_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to string");
   return PyString_AsString(python_obj);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline Real PythonFunctor::convertToAkantu<Real>(PyObject * python_obj) const {
   if (!PyFloat_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to float");
   return PyFloat_AsDouble(python_obj);
 }
 /* -------------------------------------------------------------------------- */
 template <>
 inline UInt PythonFunctor::convertToAkantu<UInt>(PyObject * python_obj) const {
   if (!PyInt_Check(python_obj))
     AKANTU_EXCEPTION("cannot convert object to integer");
   return PyInt_AsLong(python_obj);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline std::vector<T>
 PythonFunctor::convertListToAkantu(PyObject * python_obj) const {
   std::vector<T> res;
   UInt size = PyList_Size(python_obj);
   for (UInt i = 0; i < size; ++i) {
     PyObject * item = PyList_GET_ITEM(python_obj, i);
     res.push_back(this->convertToAkantu<T>(item));
   }
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_PYTHON_FUNCTOR_INLINE_IMPL_CC__ */
diff --git a/src/solver/solver_petsc.cc b/src/solver/solver_petsc.cc
index 2a7c03b30..d43cf704e 100644
--- a/src/solver/solver_petsc.cc
+++ b/src/solver/solver_petsc.cc
@@ -1,1107 +1,1107 @@
 /**
  * @file   solver_petsc.cc
  *
  * @author Alejandro M. Aragón <alejandro.aragon@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue May 13 2014
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Solver class implementation for the petsc solver
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solver_petsc.hh"
 #include "dof_manager_petsc.hh"
 #include "sparse_matrix_petsc.hh"
 #include "mpi_type_wrapper.hh"
 /* -------------------------------------------------------------------------- */
 #include <petscksp.h>
 //#include <petscsys.h>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SolverPETSc::SolverPETSc(DOFManagerPETSc & dof_manager, const ID & matrix_id,
                          const ID & id, const MemoryID & memory_id)
     : SparseSolver(dof_manager, matrix_id, id, memory_id),
       dof_manager(dof_manager),
       matrix(dof_manager.getMatrix(matrix_id)),
       is_petsc_data_initialized(false) {
   PetscErrorCode ierr;
 
   /// create a solver context
   ierr = KSPCreate(PETSC_COMM_WORLD, &this->ksp);
   CHKERRXX(ierr);
 }
 
 /* -------------------------------------------------------------------------- */
 SolverPETSc::~SolverPETSc() {
   AKANTU_DEBUG_IN();
 
   this->destroyInternalData();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolverPETSc::destroyInternalData() {
   AKANTU_DEBUG_IN();
 
   if (this->is_petsc_data_initialized) {
     PetscErrorCode ierr;
     ierr = KSPDestroy(&(this->ksp));
     CHKERRXX(ierr);
     this->is_petsc_data_initialized = false;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolverPETSc::initialize() {
   AKANTU_DEBUG_IN();
 
   this->is_petsc_data_initialized = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolverPETSc::solve() {
   AKANTU_DEBUG_IN();
 
   Vec & rhs = this->dof_manager.getResidual();
   Vec & solution = this->dof_manager.getGlobalSolution();
 
   PetscErrorCode ierr;
   ierr = KSPSolve(this->ksp, rhs, solution);
   CHKERRXX(ierr);
 
   AKANTU_DEBUG_OUT();
 }
 
 // /* -------------------------------------------------------------------------- */
 // void SolverPETSc::solve(Array<Real> & solution) {
 //   AKANTU_DEBUG_IN();
 
 //   this->solution = &solution;
 //   this->solve();
 
 //   PetscErrorCode ierr;
 //   PETScMatrix * petsc_matrix = static_cast<PETScMatrix *>(this->matrix);
 
 //   // ierr = VecGetOwnershipRange(this->petsc_solver_wrapper->solution,
 //   // solution_begin, solution_end); CHKERRXX(ierr);
 //   // ierr = VecGetArray(this->petsc_solver_wrapper->solution, PetscScalar
 //   // **array); CHKERRXX(ierr);
 //   UInt nb_component = solution.getNbComponent();
-//   UInt size = solution.getSize();
+//   UInt size = solution.size();
 
 //   for (UInt i = 0; i < size; ++i) {
 //     for (UInt j = 0; j < nb_component; ++j) {
 //       UInt i_local = i * nb_component + j;
 //       if (this->matrix->getDOFSynchronizer().isLocalOrMasterDOF(i_local)) {
 //         Int i_global =
 //             this->matrix->getDOFSynchronizer().getDOFGlobalID(i_local);
 //         ierr = AOApplicationToPetsc(petsc_matrix->getPETScMatrixWrapper()->ao,
 //                                     1, &(i_global));
 //         CHKERRXX(ierr);
 //         ierr = VecGetValues(this->petsc_solver_wrapper->solution, 1, &i_global,
 //                             &solution(i, j));
 //         CHKERRXX(ierr);
 //       }
 //     }
 //   }
 //   synch_registry->synchronize(_gst_solver_solution);
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 void SolverPETSc::setOperators() {
   AKANTU_DEBUG_IN();
   PetscErrorCode ierr;
   /// set the matrix that defines the linear system and the matrix for
   /// preconditioning (here they are the same)
 #if PETSC_VERSION_MAJOR >= 3 && PETSC_VERSION_MINOR >= 5
   ierr = KSPSetOperators(this->ksp,
                          this->matrix.getPETScMat(),
                          this->matrix.getPETScMat());
   CHKERRXX(ierr);
 #else
   ierr = KSPSetOperators(this->ksp,
                          this->matrix.getPETScMat(),
                          this->matrix.getPETScMat(),
                          SAME_NONZERO_PATTERN);
   CHKERRXX(ierr);
 #endif
 
   /// If this is not called the solution vector is zeroed in the call to
   /// KSPSolve().
   ierr = KSPSetInitialGuessNonzero(this->ksp, PETSC_TRUE);
   KSPSetFromOptions(this->ksp);
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 // void finalize_petsc() {
 
 //   static bool finalized = false;
 //   if (!finalized) {
 
 //     cout<<"*** INFO *** PETSc is finalizing..."<<endl;
 //     // finalize PETSc
 //     PetscErrorCode ierr = PetscFinalize();CHKERRCONTINUE(ierr);
 //     finalized = true;
 //   }
 // }
 
 // SolverPETSc::sparse_vector_type
 // SolverPETSc::operator()(const SolverPETSc::sparse_matrix_type& AA,
 //                          const SolverPETSc::sparse_vector_type& bb) {
 
 // #ifdef CPPUTILS_VERBOSE
 //   // parallel output stream
 //   Output_stream out;
 //   // timer
 //   cpputils::ctimer timer;
 //   out<<"Inside PETSc solver: "<<timer<<endl;
 // #endif
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Inside operator()(const sparse_matrix_type&, const
 //   sparse_vector_type&)... "<<timer<<endl;
 // #endif
 
 //   assert(AA.rows() == bb.size());
 
 //   //  KSP ksp;            //!< linear solver context
 
 //   Vec            b;                /* RHS */
 //   PC             pc;               /* preconditioner context */
 //   PetscErrorCode ierr;
 //   PetscInt       nlocal;
 //   PetscInt       n = bb.size();
 //   VecScatter ctx;
 
 //   /*
 //    Create vectors.  Note that we form 1 vector from scratch and
 //    then duplicate as needed. For this simple case let PETSc decide how
 //    many elements of the vector are stored on each processor. The second
 //    argument to VecSetSizes() below causes PETSc to decide.
 //    */
 //   ierr = VecCreate(PETSC_COMM_WORLD,&b);CHKERRCONTINUE(ierr);
 //   ierr = VecSetSizes(b,PETSC_DECIDE,n);CHKERRCONTINUE(ierr);
 //   ierr = VecSetFromOptions(b);CHKERRCONTINUE(ierr);
 //   if (!allocated_) {
 //     ierr = VecDuplicate(b,&x_);CHKERRCONTINUE(ierr);
 //   } else
 //     VecZeroEntries(x_);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vectors created... "<<timer<<endl;
 // #endif
 
 //   /* Set hight-hand-side vector */
 //   for (sparse_vector_type::const_hash_iterator it = bb.map_.begin(); it !=
 //   bb.map_.end(); ++it) {
 //     int row = it->first;
 //     ierr = VecSetValues(b, 1, &row, &it->second, ADD_VALUES);
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Right hand side set... "<<timer<<endl;
 // #endif
 
 //   /*
 //    Assemble vector, using the 2-step process:
 //    VecAssemblyBegin(), VecAssemblyEnd()
 //    Computations can be done while messages are in transition
 //    by placing code between these two statements.
 //    */
 //   ierr = VecAssemblyBegin(b);CHKERRCONTINUE(ierr);
 //   ierr = VecAssemblyEnd(b);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Right-hand-side vector assembled... "<<timer<<endl;
 
 //   ierr = VecView(b,PETSC_VIEWER_STDOUT_WORLD);CHKERRCONTINUE(ierr);
 
 //   Vec b_all;
 //   ierr = VecScatterCreateToAll(b, &ctx, &b_all);CHKERRCONTINUE(ierr);
 //   ierr =
 //   VecScatterBegin(ctx,b,b_all,INSERT_VALUES,SCATTER_FORWARD);CHKERRCONTINUE(ierr);
 //   ierr =
 //   VecScatterEnd(ctx,b,b_all,INSERT_VALUES,SCATTER_FORWARD);CHKERRCONTINUE(ierr);
 
 //   value_type nrm;
 //   VecNorm(b_all,NORM_2,&nrm);
 //   out<<"  Norm of right hand side... "<<nrm<<endl;
 // #endif
 
 //   /* Identify the starting and ending mesh points on each
 //    processor for the interior part of the mesh. We let PETSc decide
 //    above. */
 
 //   //    PetscInt rstart,rend;
 //   //    ierr = VecGetOwnershipRange(x_,&rstart,&rend);CHKERRCONTINUE(ierr);
 //   ierr = VecGetLocalSize(x_,&nlocal);CHKERRCONTINUE(ierr);
 
 //   /*
 //    Create matrix.  When using MatCreate(), the matrix format can
 //    be specified at runtime.
 
 //    Performance tuning note:  For problems of substantial size,
 //    preallocation of matrix memory is crucial for attaining good
 //    performance. See the matrix chapter of the users manual for details.
 
 //    We pass in nlocal as the "local" size of the matrix to force it
 //    to have the same parallel layout as the vector created above.
 //    */
 //   if (!allocated_) {
 
 //     ierr = MatCreate(PETSC_COMM_WORLD,&A_);CHKERRCONTINUE(ierr);
 //     ierr = MatSetSizes(A_,nlocal,nlocal,n,n);CHKERRCONTINUE(ierr);
 //     ierr = MatSetFromOptions(A_);CHKERRCONTINUE(ierr);
 //     ierr = MatSetUp(A_);CHKERRCONTINUE(ierr);
 //   } else {
 //     // zero-out matrix
 //     MatZeroEntries(A_);
 //   }
 
 //   /*
 //    Assemble matrix.
 
 //    The linear system is distributed across the processors by
 //    chunks of contiguous rows, which correspond to contiguous
 //    sections of the mesh on which the problem is discretized.
 //    For matrix assembly, each processor contributes entries for
 //    the part that it owns locally.
 //    */
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Zeroed-out sparse matrix entries... "<<timer<<endl;
 // #endif
 
 //   for (sparse_matrix_type::const_hash_iterator it = AA.map_.begin(); it !=
 //   AA.map_.end(); ++it) {
 
 //     // get subscripts
 //     std::pair<size_t,size_t> subs = AA.unhash(it->first);
 //     PetscInt row = subs.first;
 //     PetscInt col = subs.second;
 //     ierr = MatSetValues(A_, 1, &row, 1, &col, &it->second,
 //     ADD_VALUES);CHKERRCONTINUE(ierr);
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Filled sparse matrix... "<<timer<<endl;
 // #endif
 
 //   /* Assemble the matrix */
 //   ierr = MatAssemblyBegin(A_,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 //   ierr = MatAssemblyEnd(A_,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 
 //   if (!allocated_) {
 //     // set after the first MatAssemblyEnd
 //     //        ierr = MatSetOption(A_, MAT_NEW_NONZERO_LOCATIONS,
 //     PETSC_FALSE);CHKERRCONTINUE(ierr);
 //     ierr = MatSetOption(A_, MAT_NEW_NONZERO_ALLOCATION_ERR,
 //     PETSC_FALSE);CHKERRCONTINUE(ierr);
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Sparse matrix assembled... "<<timer<<endl;
 //   // view matrix
 //   MatView(A_, PETSC_VIEWER_STDOUT_WORLD);
 
 //   MatNorm(A_,NORM_FROBENIUS,&nrm);
 //   out<<"  Norm of stiffness matrix... "<<nrm<<endl;
 // #endif
 
 //   /*
 //    Set operators. Here the matrix that defines the linear system
 //    also serves as the preconditioning matrix.
 //    */
 //   //    ierr =
 //   KSPSetOperators(ksp,A_,A_,DIFFERENT_NONZERO_PATTERN);CHKERRCONTINUE(ierr);
 //   ierr =
 //   KSPSetOperators(ksp_,A_,A_,SAME_NONZERO_PATTERN);CHKERRCONTINUE(ierr);
 
 //   //
 //   //    /*
 //   //     Set runtime options, e.g.,
 //   //     -ksp_type <type> -pc_type <type> -ksp_monitor -ksp_rtol <rtol>
 //   //     These options will override those specified above as long as
 //   //     KSPSetFromOptions() is called _after_ any other customization
 //   //     routines.
 //   //     */
 //   //    ierr = KSPSetFromOptions(ksp);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Solving system... "<<timer<<endl;
 // #endif
 
 //   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //    Solve the linear system
 //    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 //   /*
 //    Solve linear system
 //    */
 //   ierr = KSPSolve(ksp_,b,x_);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 
 //   /*
 //    View solver info; we could instead use the option -ksp_view to
 //    print this info to the screen at the conclusion of KSPSolve().
 //    */
 //   ierr = KSPView(ksp_,PETSC_VIEWER_STDOUT_WORLD);CHKERRCONTINUE(ierr);
 
 //   int iter;
 //   KSPGetIterationNumber(ksp_, &iter);
 //   out<<"  System solved in "<<iter<<" iterations... "<<timer<<endl;
 //   KSPConvergedReason reason;
 //   ierr = KSPGetConvergedReason(ksp_,&reason);CHKERRCONTINUE(ierr);
 //   if (reason < 0)
 //     out<<"*** WARNING *** PETSc solver diverged with flag ";
 //   else
 //     out<<"*** INFO *** PETSc solver converged with flag ";
 
 //   if (reason == KSP_CONVERGED_RTOL)
 //     out<<"KSP_CONVERGED_RTOL"<<endl;
 //   else if (reason == KSP_CONVERGED_ATOL)
 //     out<<"KSP_CONVERGED_ATOL"<<endl;
 //   else if (reason == KSP_CONVERGED_ITS)
 //     out<<"KSP_CONVERGED_ITS"<<endl;
 //   else if (reason == KSP_CONVERGED_CG_NEG_CURVE)
 //     out<<"KSP_CONVERGED_CG_NEG_CURVE"<<endl;
 //   else if (reason == KSP_CONVERGED_CG_CONSTRAINED)
 //     out<<"KSP_CONVERGED_CG_CONSTRAINED"<<endl;
 //   else if (reason == KSP_CONVERGED_STEP_LENGTH)
 //     out<<"KSP_CONVERGED_STEP_LENGTH"<<endl;
 //   else if (reason == KSP_CONVERGED_HAPPY_BREAKDOWN)
 //     out<<"KSP_CONVERGED_HAPPY_BREAKDOWN"<<endl;
 //   else if (reason == KSP_DIVERGED_NULL)
 //     out<<"KSP_DIVERGED_NULL"<<endl;
 //   else if (reason == KSP_DIVERGED_ITS)
 //     out<<"KSP_DIVERGED_ITS"<<endl;
 //   else if (reason == KSP_DIVERGED_DTOL)
 //     out<<"KSP_DIVERGED_DTOL"<<endl;
 //   else if (reason == KSP_DIVERGED_BREAKDOWN)
 //     out<<"KSP_DIVERGED_BREAKDOWN"<<endl;
 //   else if (reason == KSP_DIVERGED_BREAKDOWN_BICG)
 //     out<<"KSP_DIVERGED_BREAKDOWN_BICG"<<endl;
 //   else if (reason == KSP_DIVERGED_NONSYMMETRIC)
 //     out<<"KSP_DIVERGED_NONSYMMETRIC"<<endl;
 //   else if (reason == KSP_DIVERGED_INDEFINITE_PC)
 //     out<<"KSP_DIVERGED_INDEFINITE_PC"<<endl;
 //   else if (reason == KSP_DIVERGED_NAN)
 //     out<<"KSP_DIVERGED_NAN"<<endl;
 //   else if (reason == KSP_DIVERGED_INDEFINITE_MAT)
 //     out<<"KSP_DIVERGED_INDEFINITE_MAT"<<endl;
 //   else if (reason == KSP_CONVERGED_ITERATING)
 //     out<<"KSP_CONVERGED_ITERATING"<<endl;
 
 //   PetscReal rnorm;
 //   ierr = KSPGetResidualNorm(ksp_,&rnorm);CHKERRCONTINUE(ierr);
 
 //   out<<"PETSc last residual norm computed: "<<rnorm<<endl;
 
 //   ierr = VecView(x_,PETSC_VIEWER_STDOUT_WORLD);CHKERRCONTINUE(ierr);
 
 //   VecNorm(x_,NORM_2,&nrm);
 //   out<<"  Norm of solution vector... "<<nrm<<endl;
 
 // #endif
 
 //   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //    Check solution and clean up
 //    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 //   Vec x_all;
 
 //   ierr = VecScatterCreateToAll(x_, &ctx, &x_all);CHKERRCONTINUE(ierr);
 //   ierr =
 //   VecScatterBegin(ctx,x_,x_all,INSERT_VALUES,SCATTER_FORWARD);CHKERRCONTINUE(ierr);
 //   ierr =
 //   VecScatterEnd(ctx,x_,x_all,INSERT_VALUES,SCATTER_FORWARD);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Solution vector scattered... "<<timer<<endl;
 //   VecNorm(x_all,NORM_2,&nrm);
 //   out<<"  Norm of scattered vector... "<<nrm<<endl;
 //   //    ierr = VecView(x_all,PETSC_VIEWER_STDOUT_WORLD);CHKERRCONTINUE(ierr);
 // #endif
 
 //   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //    Get values from solution and store them in the object that will be
 //    returned
 //    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 //   sparse_vector_type xx(bb.size());
 
 //   /* Set solution vector */
 //   double zero = 0.;
 //   double val;
 //   for (sparse_vector_type::const_hash_iterator it = bb.map_.begin(); it !=
 //   bb.map_.end(); ++it) {
 //     int row = it->first;
 //     ierr = VecGetValues(x_all, 1, &row, &val);
 //     if (val != zero)
 //       xx[row] = val;
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Solution vector copied... "<<timer<<endl;
 //   //    out<<"  Norm of copied solution vector... "<<norm(xx,
 //   Insert_t)<<endl;
 // #endif
 
 //   /*
 //    Free work space.  All PETSc objects should be destroyed when they
 //    are no longer needed.
 //    */
 //   ierr = VecDestroy(&b);CHKERRCONTINUE(ierr);
 //   //    ierr = KSPDestroy(&ksp);CHKERRCONTINUE(ierr);
 
 //   // set allocated flag
 //   if (!allocated_) {
 //     allocated_ = true;
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Temporary data structures destroyed... "<<timer<<endl;
 // #endif
 
 //   return xx;
 // }
 
 // SolverPETSc::sparse_vector_type SolverPETSc::operator()(const
 // SolverPETSc::sparse_matrix_type& KKpf, const SolverPETSc::sparse_matrix_type&
 // KKpp, const SolverPETSc::sparse_vector_type& UUp) {
 
 // #ifdef CPPUTILS_VERBOSE
 //   // parallel output stream
 //   Output_stream out;
 //   // timer
 //   cpputils::ctimer timer;
 //   out<<"Inside SolverPETSc::operator()(const sparse_matrix&, const
 //   sparse_matrix&, const sparse_vector&). "<<timer<<endl;
 // #endif
 
 //   Mat Kpf, Kpp;
 //   Vec Up, Pf, Pp;
 
 //   PetscErrorCode ierr =
 //   MatCreate(PETSC_COMM_WORLD,&Kpf);CHKERRCONTINUE(ierr);
 //   ierr = MatCreate(PETSC_COMM_WORLD,&Kpp);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Allocating memory... "<<timer<<endl;
 // #endif
 
 //   ierr = MatSetFromOptions(Kpf);CHKERRCONTINUE(ierr);
 //   ierr = MatSetFromOptions(Kpp);CHKERRCONTINUE(ierr);
 
 //   ierr = MatSetSizes(Kpf,PETSC_DECIDE,PETSC_DECIDE, KKpf.rows(),
 //   KKpf.columns());CHKERRCONTINUE(ierr);
 //   ierr = MatSetSizes(Kpp,PETSC_DECIDE,PETSC_DECIDE, KKpp.rows(),
 //   KKpp.columns());CHKERRCONTINUE(ierr);
 
 //   // get number of non-zeros in both diagonal and non-diagonal portions of
 //   the matrix
 
 //   std::pair<size_t,size_t> Kpf_nz = KKpf.non_zero_off_diagonal();
 //   std::pair<size_t,size_t> Kpp_nz = KKpp.non_zero_off_diagonal();
 
 //   ierr = MatMPIAIJSetPreallocation(Kpf, Kpf_nz.first, PETSC_NULL,
 //   Kpf_nz.second, PETSC_NULL); CHKERRCONTINUE(ierr);
 //   ierr = MatMPIAIJSetPreallocation(Kpp, Kpp_nz.first, PETSC_NULL,
 //   Kpp_nz.second, PETSC_NULL); CHKERRCONTINUE(ierr);
 //   ierr = MatSeqAIJSetPreallocation(Kpf, Kpf_nz.first, PETSC_NULL);
 //   CHKERRCONTINUE(ierr);
 //   ierr = MatSeqAIJSetPreallocation(Kpp, Kpp_nz.first, PETSC_NULL);
 //   CHKERRCONTINUE(ierr);
 
 //   for (sparse_matrix_type::const_hash_iterator it = KKpf.map_.begin(); it !=
 //   KKpf.map_.end(); ++it) {
 
 //     // get subscripts
 //     std::pair<size_t,size_t> subs = KKpf.unhash(it->first);
 //     int row = subs.first;
 //     int col = subs.second;
 //     ierr = MatSetValues(Kpf, 1, &row, 1, &col, &it->second,
 //     ADD_VALUES);CHKERRCONTINUE(ierr);
 //   }
 
 //   for (sparse_matrix_type::const_hash_iterator it = KKpp.map_.begin(); it !=
 //   KKpp.map_.end(); ++it) {
 
 //     // get subscripts
 //     std::pair<size_t,size_t> subs = KKpp.unhash(it->first);
 //     int row = subs.first;
 //     int col = subs.second;
 //     ierr = MatSetValues(Kpf, 1, &row, 1, &col, &it->second,
 //     ADD_VALUES);CHKERRCONTINUE(ierr);
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Filled sparse matrices... "<<timer<<endl;
 // #endif
 
 //   /*
 //    Assemble matrix, using the 2-step process:
 //    MatAssemblyBegin(), MatAssemblyEnd()
 //    Computations can be done while messages are in transition
 //    by placing code between these two statements.
 //    */
 //   ierr = MatAssemblyBegin(Kpf,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 //   ierr = MatAssemblyBegin(Kpp,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 //   ierr = MatAssemblyEnd(Kpf,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 //   ierr = MatAssemblyEnd(Kpp,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Sparse matrices assembled... "<<timer<<endl;
 // #endif
 
 //   ierr = VecCreate(PETSC_COMM_WORLD,&Up);CHKERRCONTINUE(ierr);
 //   ierr = VecSetSizes(Up,PETSC_DECIDE, UUp.size());CHKERRCONTINUE(ierr);
 //   ierr = VecSetFromOptions(Up);CHKERRCONTINUE(ierr);
 
 //   ierr = VecCreate(PETSC_COMM_WORLD,&Pf);CHKERRCONTINUE(ierr);
 //   ierr = VecSetSizes(Pf,PETSC_DECIDE, KKpf.rows());CHKERRCONTINUE(ierr);
 //   ierr = VecSetFromOptions(Pf);CHKERRCONTINUE(ierr);
 //   ierr = VecDuplicate(Pf,&Pp);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vectors created... "<<timer<<endl;
 // #endif
 
 //   /* Set hight-hand-side vector */
 //   for (sparse_vector_type::const_hash_iterator it = UUp.map_.begin(); it !=
 //   UUp.map_.end(); ++it) {
 //     int row = it->first;
 //     ierr = VecSetValues(Up, 1, &row, &it->second, ADD_VALUES);
 //   }
 
 //   /*
 //    Assemble vector, using the 2-step process:
 //    VecAssemblyBegin(), VecAssemblyEnd()
 //    Computations can be done while messages are in transition
 //    by placing code between these two statements.
 //    */
 //   ierr = VecAssemblyBegin(Up);CHKERRCONTINUE(ierr);
 //   ierr = VecAssemblyEnd(Up);CHKERRCONTINUE(ierr);
 
 //   // add Kpf*Uf
 //   ierr = MatMult(Kpf, x_, Pf);
 
 //   // add Kpp*Up
 //   ierr = MatMultAdd(Kpp, Up, Pf, Pp);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Matrices multiplied... "<<timer<<endl;
 // #endif
 
 //   VecScatter ctx;
 //   Vec Pp_all;
 
 //   ierr = VecScatterCreateToAll(Pp, &ctx, &Pp_all);CHKERRCONTINUE(ierr);
 //   ierr =
 //   VecScatterBegin(ctx,Pp,Pp_all,INSERT_VALUES,SCATTER_FORWARD);CHKERRCONTINUE(ierr);
 //   ierr =
 //   VecScatterEnd(ctx,Pp,Pp_all,INSERT_VALUES,SCATTER_FORWARD);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vector scattered... "<<timer<<endl;
 // #endif
 
 //   /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //    Get values from solution and store them in the object that will be
 //    returned
 //    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 //   sparse_vector_type pp(KKpf.rows());
 
 //   // get reaction vector
 //   for (int i=0; i<KKpf.rows(); ++i) {
 
 //     PetscScalar v;
 //     ierr = VecGetValues(Pp_all, 1, &i, &v);
 //     if (v != PetscScalar())
 //       pp[i] = v;
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vector copied... "<<timer<<endl;
 // #endif
 
 //   ierr = MatDestroy(&Kpf);CHKERRCONTINUE(ierr);
 //   ierr = MatDestroy(&Kpp);CHKERRCONTINUE(ierr);
 //   ierr = VecDestroy(&Up);CHKERRCONTINUE(ierr);
 //   ierr = VecDestroy(&Pf);CHKERRCONTINUE(ierr);
 //   ierr = VecDestroy(&Pp);CHKERRCONTINUE(ierr);
 //   ierr = VecDestroy(&Pp_all);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Temporary data structures destroyed... "<<timer<<endl;
 // #endif
 
 //   return pp;
 // }
 
 // SolverPETSc::sparse_vector_type SolverPETSc::operator()(const
 // SolverPETSc::sparse_vector_type& aa, const SolverPETSc::sparse_vector_type&
 // bb) {
 
 //   assert(aa.size() == bb.size());
 
 // #ifdef CPPUTILS_VERBOSE
 //   // parallel output stream
 //   Output_stream out;
 //   // timer
 //   cpputils::ctimer timer;
 //   out<<"Inside SolverPETSc::operator()(const sparse_vector&, const
 //   sparse_vector&). "<<timer<<endl;
 // #endif
 
 //   Vec r;
 
 //   PetscErrorCode ierr = VecCreate(PETSC_COMM_WORLD,&r);CHKERRCONTINUE(ierr);
 //   ierr = VecSetSizes(r,PETSC_DECIDE, aa.size());CHKERRCONTINUE(ierr);
 //   ierr = VecSetFromOptions(r);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vectors created... "<<timer<<endl;
 // #endif
 
 //   // set values
 //   for (sparse_vector_type::const_hash_iterator it = aa.map_.begin(); it !=
 //   aa.map_.end(); ++it) {
 //     int row = it->first;
 //     ierr = VecSetValues(r, 1, &row, &it->second, ADD_VALUES);
 //   }
 //   for (sparse_vector_type::const_hash_iterator it = bb.map_.begin(); it !=
 //   bb.map_.end(); ++it) {
 //     int row = it->first;
 //     ierr = VecSetValues(r, 1, &row, &it->second, ADD_VALUES);
 //   }
 
 //   /*
 //    Assemble vector, using the 2-step process:
 //    VecAssemblyBegin(), VecAssemblyEnd()
 //    Computations can be done while messages are in transition
 //    by placing code between these two statements.
 //    */
 //   ierr = VecAssemblyBegin(r);CHKERRCONTINUE(ierr);
 //   ierr = VecAssemblyEnd(r);CHKERRCONTINUE(ierr);
 
 //   sparse_vector_type rr(aa.size());
 
 //   for (sparse_vector_type::const_hash_iterator it = aa.map_.begin(); it !=
 //   aa.map_.end(); ++it) {
 //     int row = it->first;
 //     ierr = VecGetValues(r, 1, &row, &rr[row]);
 //   }
 //   for (sparse_vector_type::const_hash_iterator it = bb.map_.begin(); it !=
 //   bb.map_.end(); ++it) {
 //     int row = it->first;
 //     ierr = VecGetValues(r, 1, &row, &rr[row]);
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vector copied... "<<timer<<endl;
 // #endif
 
 //   ierr = VecDestroy(&r);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Temporary data structures destroyed... "<<timer<<endl;
 // #endif
 
 //   return rr;
 // }
 
 // SolverPETSc::value_type SolverPETSc::norm(const
 // SolverPETSc::sparse_matrix_type& aa, Element_insertion_type flag) {
 
 // #ifdef CPPUTILS_VERBOSE
 //   // parallel output stream
 //   Output_stream out;
 //   // timer
 //   cpputils::ctimer timer;
 //   out<<"Inside SolverPETSc::norm(const sparse_matrix&). "<<timer<<endl;
 // #endif
 
 //   Mat r;
 
 //   PetscErrorCode ierr = MatCreate(PETSC_COMM_WORLD,&r);CHKERRCONTINUE(ierr);
 //   ierr = MatSetSizes(r,PETSC_DECIDE,PETSC_DECIDE, aa.rows(),
 //   aa.columns());CHKERRCONTINUE(ierr);
 //   ierr = MatSetFromOptions(r);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Matrix created... "<<timer<<endl;
 // #endif
 
 //   // set values
 //   for (sparse_vector_type::const_hash_iterator it = aa.map_.begin(); it !=
 //   aa.map_.end(); ++it) {
 //     // get subscripts
 //     std::pair<size_t,size_t> subs = aa.unhash(it->first);
 //     int row = subs.first;
 //     int col = subs.second;
 
 //     if (flag == Add_t)
 //       ierr = MatSetValues(r, 1, &row, 1, &col, &it->second, ADD_VALUES);
 //     else if (flag == Insert_t)
 //       ierr = MatSetValues(r, 1, &row, 1, &col, &it->second, INSERT_VALUES);
 //     CHKERRCONTINUE(ierr);
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Matrix filled..."<<timer<<endl;
 // #endif
 
 //   /*
 //    Assemble vector, using the 2-step process:
 //    VecAssemblyBegin(), VecAssemblyEnd()
 //    Computations can be done while messages are in transition
 //    by placing code between these two statements.
 //    */
 //   ierr = MatAssemblyBegin(r,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 //   ierr = MatAssemblyEnd(r,MAT_FINAL_ASSEMBLY);CHKERRCONTINUE(ierr);
 
 //   value_type nrm;
 
 //   MatNorm(r,NORM_FROBENIUS,&nrm);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Norm computed... "<<timer<<endl;
 // #endif
 
 //   ierr = MatDestroy(&r);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Temporary data structures destroyed... "<<timer<<endl;
 // #endif
 
 //   return nrm;
 // }
 
 // SolverPETSc::value_type SolverPETSc::norm(const
 // SolverPETSc::sparse_vector_type& aa, Element_insertion_type flag) {
 
 // #ifdef CPPUTILS_VERBOSE
 //   // parallel output stream
 //   Output_stream out;
 //   // timer
 //   cpputils::ctimer timer;
 //   out<<"Inside SolverPETSc::norm(const sparse_vector&). "<<timer<<endl;
 // #endif
 
 //   Vec r;
 
 //   PetscErrorCode ierr = VecCreate(PETSC_COMM_WORLD,&r);CHKERRCONTINUE(ierr);
 //   ierr = VecSetSizes(r,PETSC_DECIDE, aa.size());CHKERRCONTINUE(ierr);
 //   ierr = VecSetFromOptions(r);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vector created... "<<timer<<endl;
 // #endif
 
 //   // set values
 //   for (sparse_vector_type::const_hash_iterator it = aa.map_.begin(); it !=
 //   aa.map_.end(); ++it) {
 //     int row = it->first;
 //     if (flag == Add_t)
 //       ierr = VecSetValues(r, 1, &row, &it->second, ADD_VALUES);
 //     else if (flag == Insert_t)
 //       ierr = VecSetValues(r, 1, &row, &it->second, INSERT_VALUES);
 //     CHKERRCONTINUE(ierr);
 //   }
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Vector filled..."<<timer<<endl;
 // #endif
 
 //   /*
 //    Assemble vector, using the 2-step process:
 //    VecAssemblyBegin(), VecAssemblyEnd()
 //    Computations can be done while messages are in transition
 //    by placing code between these two statements.
 //    */
 //   ierr = VecAssemblyBegin(r);CHKERRCONTINUE(ierr);
 //   ierr = VecAssemblyEnd(r);CHKERRCONTINUE(ierr);
 
 //   value_type nrm;
 
 //   VecNorm(r,NORM_2,&nrm);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Norm computed... "<<timer<<endl;
 // #endif
 
 //   ierr = VecDestroy(&r);CHKERRCONTINUE(ierr);
 
 // #ifdef CPPUTILS_VERBOSE
 //   out<<"  Temporary data structures destroyed... "<<timer<<endl;
 // #endif
 
 //   return nrm;
 
 // }
 
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //SolverMumps::SolverMumps(SparseMatrix & matrix,
 // //                         const ID & id,
 // //                         const MemoryID & memory_id) :
 // //Solver(matrix, id, memory_id), is_mumps_data_initialized(false),
 // rhs_is_local(true) {
 // //  AKANTU_DEBUG_IN();
 // //
 // //#ifdef AKANTU_USE_MPI
 // //  parallel_method = SolverMumpsOptions::_fully_distributed;
 // //#else //AKANTU_USE_MPI
 // //  parallel_method = SolverMumpsOptions::_master_slave_distributed;
 // //#endif //AKANTU_USE_MPI
 // //
 // //  CommunicatorEventHandler & comm_event_handler = *this;
 // //
 // //  communicator.registerEventHandler(comm_event_handler);
 // //
 // //  AKANTU_DEBUG_OUT();
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //SolverMumps::~SolverMumps() {
 // //  AKANTU_DEBUG_IN();
 // //
 // //  AKANTU_DEBUG_OUT();
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //void SolverMumps::destroyMumpsData() {
 // //  AKANTU_DEBUG_IN();
 // //
 // //  if(is_mumps_data_initialized) {
 // //    mumps_data.job = _smj_destroy; // destroy
 // //    dmumps_c(&mumps_data);
 // //    is_mumps_data_initialized = false;
 // //  }
 // //
 // //  AKANTU_DEBUG_OUT();
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //void SolverMumps::onCommunicatorFinalize(const StaticCommunicator & comm) {
 // //  AKANTU_DEBUG_IN();
 // //
 // //  try{
 // //    const StaticCommunicatorMPI & comm_mpi =
 // //    dynamic_cast<const StaticCommunicatorMPI
 // &>(comm.getRealStaticCommunicator());
 // //    if(mumps_data.comm_fortran ==
 // MPI_Comm_c2f(comm_mpi.getMPICommunicator()))
 // //      destroyMumpsData();
 // //  } catch(...) {}
 // //
 // //  AKANTU_DEBUG_OUT();
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //void SolverMumps::initMumpsData(SolverMumpsOptions::ParallelMethod
 // parallel_method) {
 // //  switch(parallel_method) {
 // //    case SolverMumpsOptions::_fully_distributed:
 // //      icntl(18) = 3; //fully distributed
 // //      icntl(28) = 0; //automatic choice
 // //
 // //      mumps_data.nz_loc  = matrix->getNbNonZero();
 // //      mumps_data.irn_loc = matrix->getIRN().values;
 // //      mumps_data.jcn_loc = matrix->getJCN().values;
 // //      break;
 // //    case SolverMumpsOptions::_master_slave_distributed:
 // //      if(prank == 0) {
 // //        mumps_data.nz  = matrix->getNbNonZero();
 // //        mumps_data.irn = matrix->getIRN().values;
 // //        mumps_data.jcn = matrix->getJCN().values;
 // //      } else {
 // //        mumps_data.nz  = 0;
 // //        mumps_data.irn = NULL;
 // //        mumps_data.jcn = NULL;
 // //
 // //        icntl(18) = 0; //centralized
 // //        icntl(28) = 0; //sequential analysis
 // //      }
 // //      break;
 // //  }
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //void SolverMumps::initialize(SolverOptions & options) {
 // //  AKANTU_DEBUG_IN();
 // //
 // //  mumps_data.par = 1;
 // //
 // //  if(SolverMumpsOptions * opt = dynamic_cast<SolverMumpsOptions
 // *>(&options)) {
 // //    if(opt->parallel_method ==
 // SolverMumpsOptions::_master_slave_distributed) {
 // //      mumps_data.par = 0;
 // //    }
 // //  }
 // //
 // //  mumps_data.sym = 2 * (matrix->getSparseMatrixType() == _symmetric);
 // //  prank = communicator.whoAmI();
 // //#ifdef AKANTU_USE_MPI
 // //  mumps_data.comm_fortran = MPI_Comm_c2f(dynamic_cast<const
 // StaticCommunicatorMPI
 // &>(communicator.getRealStaticCommunicator()).getMPICommunicator());
 // //#endif
 // //
 // //  if(AKANTU_DEBUG_TEST(dblTrace)) {
 // //    icntl(1) = 2;
 // //    icntl(2) = 2;
 // //    icntl(3) = 2;
 // //    icntl(4) = 4;
 // //  }
 // //
 // //  mumps_data.job = _smj_initialize; //initialize
 // //  dmumps_c(&mumps_data);
 // //  is_mumps_data_initialized = true;
 // //
 // //  /*
 // ------------------------------------------------------------------------ */
-// //  UInt size = matrix->getSize();
+// //  UInt size = matrix->size();
 // //
 // //  if(prank == 0) {
 // //    std::stringstream sstr_rhs; sstr_rhs << id << ":rhs";
 // //    rhs = &(alloc<Real>(sstr_rhs.str(), size, 1, REAL_INIT_VALUE));
 // //  } else {
 // //    rhs = NULL;
 // //  }
 // //
 // //  /// No outputs
 // //  icntl(1) = 0;
 // //  icntl(2) = 0;
 // //  icntl(3) = 0;
 // //  icntl(4) = 0;
 // //  mumps_data.nz_alloc = 0;
 // //
 // //  if (AKANTU_DEBUG_TEST(dblDump)) icntl(4) = 4;
 // //
 // //  mumps_data.n   = size;
 // //
 // //  if(AKANTU_DEBUG_TEST(dblDump)) {
 // //    strcpy(mumps_data.write_problem, "mumps_matrix.mtx");
 // //  }
 // //
 // //  /*
 // ------------------------------------------------------------------------ */
 // //  // Default Scaling
 // //  icntl(8) = 77;
 // //
 // //  icntl(5) = 0; // Assembled matrix
 // //
 // //  SolverMumpsOptions * opt = dynamic_cast<SolverMumpsOptions *>(&options);
 // //  if(opt)
 // //    parallel_method = opt->parallel_method;
 // //
 // //  initMumpsData(parallel_method);
 // //
 // //  mumps_data.job = _smj_analyze; //analyze
 // //  dmumps_c(&mumps_data);
 // //
 // //  AKANTU_DEBUG_OUT();
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //void SolverMumps::setRHS(Array<Real> & rhs) {
 // //  if(prank == 0) {
 // //    matrix->getDOFSynchronizer().gather(rhs, 0, this->rhs);
 // //  } else {
 // //    matrix->getDOFSynchronizer().gather(rhs, 0);
 // //  }
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //void SolverMumps::solve() {
 // //  AKANTU_DEBUG_IN();
 // //
 // //  if(parallel_method == SolverMumpsOptions::_fully_distributed)
 // //    mumps_data.a_loc  = matrix->getA().values;
 // //  else
 // //    if(prank == 0) {
 // //      mumps_data.a  = matrix->getA().values;
 // //    }
 // //
 // //  if(prank == 0) {
 // //    mumps_data.rhs = rhs->values;
 // //  }
 // //
 // //  /// Default centralized dense second member
 // //  icntl(20) = 0;
 // //  icntl(21) = 0;
 // //
 // //  mumps_data.job = _smj_factorize_solve; //solve
 // //  dmumps_c(&mumps_data);
 // //
 // //  AKANTU_DEBUG_ASSERT(info(1) != -10, "Singular matrix");
 // //  AKANTU_DEBUG_ASSERT(info(1) == 0,
 // //                      "Error in mumps during solve process, check mumps
 // user guide INFO(1) ="
 // //                      << info(1));
 // //
 // //  AKANTU_DEBUG_OUT();
 // //}
 // //
 // ///*
 // -------------------------------------------------------------------------- */
 // //void SolverMumps::solve(Array<Real> & solution) {
 // //  AKANTU_DEBUG_IN();
 // //
 // //  solve();
 // //
 // //  if(prank == 0) {
 // //    matrix->getDOFSynchronizer().scatter(solution, 0, this->rhs);
 // //  } else {
 // //    matrix->getDOFSynchronizer().scatter(solution, 0);
 // //  }
 // //
 // //  AKANTU_DEBUG_OUT();
 // //}
 
 } // akantu
diff --git a/src/solver/sparse_matrix.cc b/src/solver/sparse_matrix.cc
index c24d5d855..93323ff14 100644
--- a/src/solver/sparse_matrix.cc
+++ b/src/solver/sparse_matrix.cc
@@ -1,80 +1,80 @@
 /**
  * @file   sparse_matrix.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Mon Nov 16 2015
  *
  * @brief  implementation of the SparseMatrix class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 #include "dof_manager.hh"
 #include "sparse_matrix.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix::SparseMatrix(DOFManager & dof_manager,
                            const MatrixType & matrix_type, const ID & id)
     : id(id), _dof_manager(dof_manager), matrix_type(matrix_type),
-      size(dof_manager.getSystemSize()), nb_non_zero(0) {
+      size_(dof_manager.getSystemSize()), nb_non_zero(0) {
   AKANTU_DEBUG_IN();
 
   const auto & comm = _dof_manager.getCommunicator();
   this->nb_proc = comm.getNbProc();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix::SparseMatrix(const SparseMatrix & matrix, const ID & id)
     : SparseMatrix(matrix._dof_manager, matrix.matrix_type, id) {
   nb_non_zero = matrix.nb_non_zero;
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix::~SparseMatrix() {}
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & operator*=(Array<Real> & vect, const SparseMatrix & mat) {
-  Array<Real> tmp(vect.getSize(), vect.getNbComponent(), 0.);
+  Array<Real> tmp(vect.size(), vect.getNbComponent(), 0.);
   mat.matVecMul(vect, tmp);
 
   vect.copy(tmp);
   return vect;
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrix::add(const SparseMatrix & B, Real alpha) {
   B.addMeTo(*this, alpha);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/solver/sparse_matrix.hh b/src/solver/sparse_matrix.hh
index 760010a33..2bec271f8 100644
--- a/src/solver/sparse_matrix.hh
+++ b/src/solver/sparse_matrix.hh
@@ -1,161 +1,159 @@
 
 /**
  * @file   sparse_matrix.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  sparse matrix storage class (distributed assembled matrix)
  * This is a COO format (Coordinate List)
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SPARSE_MATRIX_HH__
 #define __AKANTU_SPARSE_MATRIX_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class DOFManager;
 class TermsToAssemble;
 }
 
 namespace akantu {
 
 class SparseMatrix {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   SparseMatrix(DOFManager & dof_manager, const MatrixType & matrix_type,
                const ID & id = "sparse_matrix");
 
   SparseMatrix(const SparseMatrix & matrix, const ID & id = "sparse_matrix");
 
   virtual ~SparseMatrix();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// remove the existing profile
   virtual void clearProfile();
 
   /// set the matrix to 0
   virtual void clear() = 0;
 
   /// add a non-zero element to the profile
   virtual UInt addToProfile(UInt i, UInt j) = 0;
 
   /// assemble a local matrix in the sparse one
   virtual void addToMatrix(UInt i, UInt j, Real value) = 0;
 
   /// save the profil in a file using the MatrixMarket file format
   virtual void saveProfile(__attribute__((unused)) const std::string &) const {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// save the matrix in a file using the MatrixMarket file format
   virtual void saveMatrix(__attribute__((unused)) const std::string &) const {
     AKANTU_DEBUG_TO_IMPLEMENT();
   };
 
   /// multiply the matrix by a coefficient
   virtual void mul(Real alpha) = 0;
 
   /// add matrices
   virtual void add(const SparseMatrix & matrix, Real alpha = 1.);
 
   /// Equivalent of *gemv in blas
   virtual void matVecMul(const Array<Real> & x, Array<Real> & y,
                          Real alpha = 1., Real beta = 0.) const = 0;
 
   /// modify the matrix to "remove" the blocked dof
   virtual void applyBoundary(Real block_val = 1.) = 0;
 
   /// operator *=
   SparseMatrix & operator*=(Real alpha) { this->mul(alpha); return *this; }
 
 protected:
   /// This is the revert of add B += \alpha * *this;
   virtual void addMeTo(SparseMatrix & B, Real alpha) const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// return the values at potition i, j
   virtual inline Real operator()(__attribute__((unused)) UInt i,
                                  __attribute__((unused)) UInt j) const {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
   /// return the values at potition i, j
   virtual inline Real & operator()(__attribute__((unused)) UInt i,
                                    __attribute__((unused)) UInt j) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   AKANTU_GET_MACRO(NbNonZero, nb_non_zero, UInt);
-
-  AKANTU_GET_MACRO(Size, size, UInt);
-
+  UInt size() const { return size_;}
   AKANTU_GET_MACRO(MatrixType, matrix_type, const MatrixType &);
 
   virtual UInt getRelease() const = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   ID id;
 
   /// Underlying dof manager
   DOFManager & _dof_manager;
 
   /// sparce matrix type
   MatrixType matrix_type;
 
   /// Size of the matrix
-  UInt size;
+  UInt size_;
 
   /// number of processors
   UInt nb_proc;
 
   /// number of non zero element
   UInt nb_non_zero;
 };
 
 Array<Real> & operator*=(Array<Real> & vect, const SparseMatrix & mat);
 
 } // akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix_inline_impl.cc"
 
 #endif /* __AKANTU_SPARSE_MATRIX_HH__ */
diff --git a/src/solver/sparse_matrix_aij.cc b/src/solver/sparse_matrix_aij.cc
index feb34c5cd..a33c88771 100644
--- a/src/solver/sparse_matrix_aij.cc
+++ b/src/solver/sparse_matrix_aij.cc
@@ -1,225 +1,222 @@
 /**
  * @file   sparse_matrix_aij.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 18 16:31:23 2015
  *
  * @brief  Implementation of the AIJ sparse matrix
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix_aij.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "terms_to_assemble.hh"
+#include "aka_iterators.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ::SparseMatrixAIJ(DOFManagerDefault & dof_manager,
                                  const MatrixType & matrix_type, const ID & id)
     : SparseMatrix(dof_manager, matrix_type, id), dof_manager(dof_manager),
       irn(0, 1, id + ":irn"), jcn(0, 1, id + ":jcn"), a(0, 1, id + ":a"),
       profile_release(1), value_release(1) {}
 
 /* -------------------------------------------------------------------------- */
 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"), profile_release(1), value_release(1) {}
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ::~SparseMatrixAIJ() {}
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::applyBoundary(Real block_val) {
   AKANTU_DEBUG_IN();
 
   // clang-format off
   const auto & blocked_dofs = this->dof_manager.getGlobalBlockedDOFs();
 
-  auto irn_it = irn.begin();
-  auto jcn_it = jcn.begin();
-  auto a_it   = a.begin();
-  auto a_end  = a.end();
-
-  for (;a_it != a_end; ++a_it, ++irn_it, ++jcn_it) {
-    UInt ni = this->dof_manager.globalToLocalEquationNumber(*irn_it - 1);
-    UInt nj = this->dof_manager.globalToLocalEquationNumber(*jcn_it - 1);
+  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)) {
-      *a_it = *irn_it != *jcn_it                       ? 0.
-            : this->dof_manager.isLocalOrMasterDOF(ni) ? block_val
-            :                                            0.;
+      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;
+  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
+  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.getSize() * x.getNbComponent());
-  auto y_it = y.begin_reinterpret(x.getSize() * x.getNbComponent());
+  auto x_it = x.begin_reinterpret(x.size() * x.getNbComponent());
+  auto y_it = y.begin_reinterpret(x.size() * x.getNbComponent());
 
   for (; a_it != a_end; ++i_it, ++j_it, ++a_it) {
     Int i = this->dof_manager.globalToLocalEquationNumber(*i_it - 1);
     Int j = this->dof_manager.globalToLocalEquationNumber(*j_it - 1);
     const Real & A = *a_it;
 
     y_it[i] += alpha * A * x_it[j];
 
     if ((this->matrix_type == _symmetric) && (i != j))
       y_it[j] += alpha * A * x_it[i];
   }
 
   if (this->dof_manager.hasSynchronizer())
     this->dof_manager.getSynchronizer().reduceSynchronize<AddOperation>(y);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::copyContent(const SparseMatrix & matrix) {
   AKANTU_DEBUG_IN();
   const SparseMatrixAIJ & mat = dynamic_cast<const SparseMatrixAIJ &>(matrix);
   AKANTU_DEBUG_ASSERT(nb_non_zero == mat.getNbNonZero(),
                       "The to matrix don't have the same profiles");
   memcpy(a.storage(), mat.getA().storage(), nb_non_zero * sizeof(Real));
 
   this->value_release++;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class MatrixType>
 void SparseMatrixAIJ::addMeToTemplated(MatrixType & B, Real alpha) const {
   auto i_it = this->irn.begin();
   auto j_it = this->jcn.begin();
   auto a_it = this->a.begin();
   auto a_end = this->a.end();
 
   for (; a_it != a_end; ++a_it, ++i_it, ++j_it) {
     const Int & i = *i_it;
     const Int & j = *j_it;
     const Real & A_ij = *a_it;
 
     B.addToMatrix(i - 1, j - 1, alpha * A_ij);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixAIJ::addMeTo(SparseMatrix & B, Real alpha) const {
   if (SparseMatrixAIJ * 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++;
 }
 
-} // akantu
+} // namespace akantu
diff --git a/src/solver/sparse_matrix_aij.hh b/src/solver/sparse_matrix_aij.hh
index 7821f452d..466b033f0 100644
--- a/src/solver/sparse_matrix_aij.hh
+++ b/src/solver/sparse_matrix_aij.hh
@@ -1,181 +1,179 @@
 /**
  * @file   sparse_matrix_aij.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Mon Aug 17 21:22:57 2015
  *
  * @brief AIJ implementation of the SparseMatrix (this the format used by Mumps)
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SPARSE_MATRIX_AIJ_HH__
 #define __AKANTU_SPARSE_MATRIX_AIJ_HH__
 
 namespace akantu {
 class DOFManagerDefault;
 class TermsToAssemble;
 }
 
 namespace akantu {
 
 class SparseMatrixAIJ : public SparseMatrix {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   SparseMatrixAIJ(DOFManagerDefault & dof_manager,
                   const MatrixType & matrix_type,
                   const ID & id = "sparse_matrix_aij");
 
   SparseMatrixAIJ(const SparseMatrixAIJ & matrix,
                   const ID & id = "sparse_matrix_aij");
 
   virtual ~SparseMatrixAIJ();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// remove the existing profile
   inline void clearProfile();
 
   /// add a non-zero element
   virtual inline UInt addToProfile(UInt i, UInt j);
 
   /// set the matrix to 0
   virtual void clear();
 
   /// assemble a local matrix in the sparse one
   virtual inline void addToMatrix(UInt i, UInt j, Real value);
 
   /// set the size of the matrix
-  void resize(UInt size) { this->size = size; }
+  void resize(UInt size) { this->size_ = size; }
 
   /// modify the matrix to "remove" the blocked dof
   virtual void applyBoundary(Real block_val = 1.);
 
   /// save the profil in a file using the MatrixMarket file format
   virtual void saveProfile(const std::string & filename) const;
 
   /// save the matrix in a file using the MatrixMarket file format
   virtual void saveMatrix(const std::string & filename) const;
 
   /// copy assuming the profile are the same
   virtual void copyContent(const SparseMatrix & matrix);
 
   /// multiply the matrix by a scalar
   void mul(Real alpha);
 
   /// add matrix *this += B
   // virtual void add(const SparseMatrix & matrix, Real alpha);
 
   /// Equivalent of *gemv in blas
   virtual void matVecMul(const Array<Real> & x, Array<Real> & y,
                          Real alpha = 1., Real beta = 0.) const;
 
   /* ------------------------------------------------------------------------ */
   /// accessor to A_{ij} - if (i, j) not present it returns 0
   inline Real operator()(UInt i, UInt j) const;
 
   /// accessor to A_{ij} - if (i, j) not present it fails, (i, j) should be
   /// first added to the profile
   inline Real & operator()(UInt i, UInt j);
 
 protected:
   /// This is the revert of add B += \alpha * *this;
   virtual void addMeTo(SparseMatrix & B, Real alpha) const;
 
 private:
   /// This is just to inline the addToMatrix function
   template <class MatrixType>
   void addMeToTemplated(MatrixType & B, Real alpha) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(IRN, irn, const Array<Int> &);
 
   AKANTU_GET_MACRO(JCN, jcn, const Array<Int> &);
 
   AKANTU_GET_MACRO(A, a, const Array<Real> &);
 
   /// The release changes at each call of a function that changes the profile,
   /// it in increasing but could overflow so it should be checked as
   /// (my_release != release) and not as (my_release < release)
   AKANTU_GET_MACRO(ProfileRelease, profile_release, UInt);
   AKANTU_GET_MACRO(ValueRelease, value_release, UInt);
   virtual UInt getRelease() const { return value_release; }
 protected:
   using KeyCOO = std::pair<UInt, UInt>;
   using coordinate_list_map = std::unordered_map<KeyCOO, UInt>;
 
   /// get the pair corresponding to (i, j)
   inline KeyCOO key(UInt i, UInt j) const {
     if (this->matrix_type == _symmetric && (i > j))
       return std::make_pair(j, i);
     return std::make_pair(i, j);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   DOFManagerDefault & dof_manager;
 
   /// row indexes
   Array<Int> irn;
 
   /// column indexes
   Array<Int> jcn;
 
   /// values : A[k] = Matrix[irn[k]][jcn[k]]
   Array<Real> a;
 
   /// Profile release
   UInt profile_release;
 
   /// Value release
   UInt value_release;
 
-  /*
-   * map for (i, j) ->  k correspondence
-   */
+  /// map for (i, j) ->  k correspondence
   coordinate_list_map irn_jcn_k;
 };
 
 } // akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "sparse_matrix_aij_inline_impl.cc"
 
 #endif /* __AKANTU_SPARSE_MATRIX_AIJ_HH__ */
diff --git a/src/solver/sparse_matrix_aij_inline_impl.cc b/src/solver/sparse_matrix_aij_inline_impl.cc
index 493f9627d..0d09cf024 100644
--- a/src/solver/sparse_matrix_aij_inline_impl.cc
+++ b/src/solver/sparse_matrix_aij_inline_impl.cc
@@ -1,111 +1,111 @@
 /**
  * @file   sparse_matrix_aij_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue Aug 18 00:42:45 2015
  *
  * @brief  Implementation of inline functions of SparseMatrixAIJ
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_SPARSE_MATRIX_AIJ_INLINE_IMPL_CC__
 #define __AKANTU_SPARSE_MATRIX_AIJ_INLINE_IMPL_CC__
 
 namespace akantu {
 
 inline UInt SparseMatrixAIJ::addToProfile(UInt i, UInt j) {
   KeyCOO jcn_irn = this->key(i, j);
 
   coordinate_list_map::iterator it = this->irn_jcn_k.find(jcn_irn);
 
   if (!(it == this->irn_jcn_k.end())) return it->second;
 
-  if(i + 1 > this->size) this->size = i + 1;
-  if(j + 1 > this->size) this->size = j + 1;
+  if(i + 1 > this->size_) this->size_ = i + 1;
+  if(j + 1 > this->size_) this->size_ = j + 1;
 
   this->irn.push_back(i + 1);
   this->jcn.push_back(j + 1);
   this->a.push_back(0.);
 
   this->irn_jcn_k[jcn_irn] = this->nb_non_zero;
 
   (this->nb_non_zero)++;
 
   this->profile_release++;
   this->value_release++;
 
   return (this->nb_non_zero - 1);
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SparseMatrixAIJ::clearProfile() {
   SparseMatrix::clearProfile();
 
   this->irn_jcn_k.clear();
 
   this->irn.resize(0);
   this->jcn.resize(0);
   this->a.resize(0);
 
-  this->size = 0;
+  this->size_ = 0;
 
   this->profile_release++;
   this->value_release++;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void SparseMatrixAIJ::addToMatrix(UInt i, UInt j, Real value) {
   UInt idx = this->addToProfile(i, j);
 
   this->a(idx) += value;
 
   this->value_release++;
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real SparseMatrixAIJ::operator()(UInt i, UInt j) const {
   KeyCOO jcn_irn = this->key(i, j);
   coordinate_list_map::const_iterator irn_jcn_k_it =
       this->irn_jcn_k.find(jcn_irn);
 
   if (irn_jcn_k_it == this->irn_jcn_k.end()) return 0.;
   return this->a(irn_jcn_k_it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 inline Real & SparseMatrixAIJ::operator()(UInt i, UInt j) {
   KeyCOO jcn_irn = this->key(i, j);
   coordinate_list_map::iterator irn_jcn_k_it = this->irn_jcn_k.find(jcn_irn);
   AKANTU_DEBUG_ASSERT(irn_jcn_k_it != this->irn_jcn_k.end(),
                       "Couple (i,j) = (" << i << "," << j
                                          << ") does not exist in the profile");
 
   // it may change the profile so it is considered as a change
   this->value_release++;
 
   return this->a(irn_jcn_k_it->second);
 }
 
 } // akantu
 
 #endif /* __AKANTU_SPARSE_MATRIX_AIJ_INLINE_IMPL_CC__ */
diff --git a/src/solver/sparse_matrix_petsc.cc b/src/solver/sparse_matrix_petsc.cc
index 48456c6fb..7d357d9c9 100644
--- a/src/solver/sparse_matrix_petsc.cc
+++ b/src/solver/sparse_matrix_petsc.cc
@@ -1,404 +1,404 @@
 /**
  * @file   petsc_matrix.cc
  * @author Aurelia Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @date   Mon Jul 21 17:40:41 2014
  *
  * @brief  Implementation of PETSc matrix 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 "sparse_matrix_petsc.hh"
 #include "mpi_type_wrapper.hh"
 #include "dof_manager_petsc.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstring>
 #include <petscsys.h>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 #if not defined(PETSC_CLANGUAGE_CXX)
 int aka_PETScError(int ierr) {
   CHKERRQ(ierr);
   return 0;
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixPETSc::SparseMatrixPETSc(DOFManagerPETSc & dof_manager,
     const MatrixType & sparse_matrix_type, const ID & id,
     const MemoryID & memory_id)
   : SparseMatrix(dof_manager, matrix_type, id, memory_id),
     dof_manager(dof_manager),
     d_nnz(0, 1, "dnnz"),
     o_nnz(0, 1, "onnz"), first_global_index(0) {
   AKANTU_DEBUG_IN();
 
   PetscErrorCode ierr;
 
   // create the PETSc matrix object
   ierr = MatCreate(PETSC_COMM_WORLD, &this->mat);
   CHKERRXX(ierr);
 
   /**
    * Set the matrix type
    * @todo PETSc does currently not support a straightforward way to
    * apply Dirichlet boundary conditions for MPISBAIJ
    * matrices. Therefore always the entire matrix is allocated. It
    * would be possible to use MATSBAIJ for sequential matrices in case
    * memory becomes critical. Also, block matrices would give a much
    * better performance. Modify this in the future!
    */
   ierr = MatSetType(this->mat, MATAIJ);
   CHKERRXX(ierr);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixPETSc::~SparseMatrixPETSc() {
   AKANTU_DEBUG_IN();
 
   /// destroy all the PETSc data structures used for this matrix
   PetscErrorCode ierr;
   ierr = MatDestroy(&this->mat);
   CHKERRXX(ierr);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * With this method each processor computes the dimensions of the
  * local matrix, i.e. the part of the global matrix it is storing.
  * @param dof_synchronizer dof synchronizer that maps the local
  * dofs to the global dofs and the equation numbers, i.e., the
  * position at which the dof is assembled in the matrix
  */
 void SparseMatrixPETSc::setSize() {
   AKANTU_DEBUG_IN();
 
   //  PetscErrorCode ierr;
 
   /// find the number of dofs corresponding to master or local nodes
   UInt nb_dofs = this->dof_manager.getLocalSystemSize();
   // UInt nb_local_master_dofs = 0;
 
   /// create array to store the global equation number of all local and master
   /// dofs
   Array<Int> local_master_eq_nbs(nb_dofs);
   Array<Int>::scalar_iterator it_eq_nb = local_master_eq_nbs.begin();
 
   throw;
   /// get the pointer to the global equation number array
  //  Int * eq_nb_val =
 //       this->dof_synchronizer->getGlobalDOFEquationNumbers().storage();
 
 //   for (UInt i = 0; i < nb_dofs; ++i) {
 //     if (this->dof_synchronizer->isLocalOrMasterDOF(i)) {
 //       *it_eq_nb = eq_nb_val[i];
 //       ++it_eq_nb;
 //       ++nb_local_master_dofs;
 //     }
 //   }
 
 //   local_master_eq_nbs.resize(nb_local_master_dofs);
 
 //   /// set the local size
 //   this->local_size = nb_local_master_dofs;
 
 // /// resize PETSc matrix
 // #if defined(AKANTU_USE_MPI)
 //   ierr = MatSetSizes(this->petsc_matrix_wrapper->mat, this->local_size,
 //                      this->local_size, this->size, this->size);
 //   CHKERRXX(ierr);
 // #else
 //   ierr = MatSetSizes(this->petsc_matrix_wrapper->mat, this->local_size,
 //                      this->local_size);
 //   CHKERRXX(ierr);
 // #endif
 
 //   /// create mapping from akantu global numbering to petsc global numbering
 //   this->createGlobalAkantuToPETScMap(local_master_eq_nbs.storage());
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * This method generates a mapping from the global Akantu equation
  * numbering to the global PETSc dof ordering
  * @param local_master_eq_nbs_ptr Int pointer to the array of equation
  * numbers of all local or master dofs, i.e. the row indices of the
  * local matrix
  */
 void
 SparseMatrixPETSc::createGlobalAkantuToPETScMap(Int * local_master_eq_nbs_ptr) {
   AKANTU_DEBUG_IN();
 
   PetscErrorCode ierr;
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   UInt rank = comm.whoAmI();
 
   // initialize vector to store the number of local and master nodes that are
   // assigned to each processor
   Vector<UInt> master_local_ndofs_per_proc(nb_proc);
 
   /// store the nb of master and local dofs on each processor
   master_local_ndofs_per_proc(rank) = this->local_size;
 
   /// exchange the information among all processors
   comm.allGather(master_local_ndofs_per_proc.storage(), 1);
 
   /// each processor creates a map for his akantu global dofs to the
   /// corresponding petsc global dofs
 
   /// determine the PETSc-index for the first dof on each processor
 
   for (UInt i = 0; i < rank; ++i) {
     this->first_global_index += master_local_ndofs_per_proc(i);
   }
 
   /// create array for petsc ordering
   Array<Int> petsc_dofs(this->local_size);
   Array<Int>::scalar_iterator it_petsc_dofs = petsc_dofs.begin();
 
   for (Int i = this->first_global_index;
        i < this->first_global_index + this->local_size; ++i, ++it_petsc_dofs) {
     *it_petsc_dofs = i;
   }
 
   ierr = AOCreateBasic(PETSC_COMM_WORLD,
                        this->local_size, local_master_eq_nbs_ptr,
                        petsc_dofs.storage(), &(this->ao));
   CHKERRXX(ierr);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Method to save the nonzero pattern and the values stored at each position
  * @param filename name of the file in which the information will be stored
  */
 void SparseMatrixPETSc::saveMatrix(const std::string & filename) const {
   AKANTU_DEBUG_IN();
 
   PetscErrorCode ierr;
 
   /// create Petsc viewer
   PetscViewer viewer;
   ierr = PetscViewerASCIIOpen(PETSC_COMM_WORLD,
                               filename.c_str(), &viewer);
   CHKERRXX(ierr);
 
   /// set the format
   PetscViewerSetFormat(viewer, PETSC_VIEWER_DEFAULT);
   CHKERRXX(ierr);
 
   /// save the matrix
   /// @todo Write should be done in serial -> might cause problems
   ierr = MatView(this->mat, viewer);
   CHKERRXX(ierr);
 
   /// destroy the viewer
   ierr = PetscViewerDestroy(&viewer);
   CHKERRXX(ierr);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Method to add an Akantu sparse matrix to the PETSc matrix
  * @param matrix Akantu sparse matrix to be added
  * @param alpha the factor specifying how many times the matrix should be added
  */
 // void SparseMatrixPETSc::add(const SparseMatrix & matrix, Real alpha) {
 //   PetscErrorCode ierr;
 //   //  AKANTU_DEBUG_ASSERT(nb_non_zero == matrix.getNbNonZero(),
 //   //                  "The two matrix don't have the same profiles");
 
 //   Real val_to_add = 0;
 //   Array<Int> index(2);
 //   for (UInt n = 0; n < matrix.getNbNonZero(); ++n) {
 //     UInt mat_to_add_offset = matrix.getOffset();
 //     index(0) = matrix.getIRN()(n) - mat_to_add_offset;
 //     index(1) = matrix.getJCN()(n) - mat_to_add_offset;
 //     AOApplicationToPetsc(this->petsc_matrix_wrapper->ao, 2, index.storage());
 //     if (this->sparse_matrix_type == _symmetric && index(0) > index(1))
 //       std::swap(index(0), index(1));
 
 //     val_to_add = matrix.getA()(n) * alpha;
 //     /// MatSetValue might be very slow for MATBAIJ, might need to use
 //     /// MatSetValuesBlocked
 //     ierr = MatSetValue(this->petsc_matrix_wrapper->mat, index(0), index(1),
 //                        val_to_add, ADD_VALUES);
 //     CHKERRXX(ierr);
 //     /// chek if sparse matrix to be added is symmetric. In this case
 //     /// the value also needs to be added at the transposed location in
 //     /// the matrix because PETSc is using the full profile, also for symmetric
 //     /// matrices
 //     if (matrix.getSparseMatrixType() == _symmetric && index(0) != index(1))
 //       ierr = MatSetValue(this->petsc_matrix_wrapper->mat, index(1), index(0),
 //                          val_to_add, ADD_VALUES);
 //     CHKERRXX(ierr);
 //   }
 
 //   this->performAssembly();
 // }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Method to add another PETSc matrix to this PETSc matrix
  * @param matrix PETSc matrix to be added
  * @param alpha the factor specifying how many times the matrix should be added
  */
 void SparseMatrixPETSc::add(const SparseMatrixPETSc & matrix, Real alpha) {
   PetscErrorCode ierr;
 
   ierr = MatAXPY(this->mat, alpha,
                  matrix.mat, SAME_NONZERO_PATTERN);
   CHKERRXX(ierr);
 
   this->performAssembly();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * MatSetValues() generally caches the values. The matrix is ready to
  * use only after MatAssemblyBegin() and MatAssemblyEnd() have been
  * called. (http://www.mcs.anl.gov/petsc/)
  */
 void SparseMatrixPETSc::performAssembly() {
   this->beginAssembly();
   this->endAssembly();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixPETSc::beginAssembly() {
   PetscErrorCode ierr;
   ierr = MatAssemblyBegin(this->mat, MAT_FINAL_ASSEMBLY);
   CHKERRXX(ierr);
   ierr = MatAssemblyEnd(this->mat, MAT_FINAL_ASSEMBLY);
   CHKERRXX(ierr);
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseMatrixPETSc::endAssembly() {
   PetscErrorCode ierr;
   ierr = MatAssemblyEnd(this->mat, MAT_FINAL_ASSEMBLY);
   CHKERRXX(ierr);
 }
 
 /* -------------------------------------------------------------------------- */
 /// access K(i, j). Works only for dofs on this processor!!!!
 Real SparseMatrixPETSc::operator()(UInt i, UInt j) const {
   AKANTU_DEBUG_IN();
 
   // AKANTU_DEBUG_ASSERT(this->dof_synchronizer->isLocalOrMasterDOF(i) &&
   //                         this->dof_synchronizer->isLocalOrMasterDOF(j),
   //                     "Operator works only for dofs on this processor");
 
   // Array<Int> index(2, 1);
   // index(0) = this->dof_synchronizer->getDOFGlobalID(i);
   // index(1) = this->dof_synchronizer->getDOFGlobalID(j);
   // AOApplicationToPetsc(this->petsc_matrix_wrapper->ao, 2, index.storage());
 
   // Real value = 0;
 
   // PetscErrorCode ierr;
   // /// @todo MatGetValue might be very slow for MATBAIJ, might need to use
   // /// MatGetValuesBlocked
   // ierr = MatGetValues(this->petsc_matrix_wrapper->mat, 1, &index(0), 1,
   //                     &index(1), &value);
   // CHKERRXX(ierr);
 
   // AKANTU_DEBUG_OUT();
 
   // return value;
   return 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Apply Dirichlet boundary conditions by zeroing the rows and columns which
  * correspond to blocked dofs
  * @param boundary array of booleans which are true if the dof at this position
  * is blocked
  * @param block_val the value in the diagonal entry of blocked rows
  */
 void SparseMatrixPETSc::applyBoundary(const Array<bool> & boundary,
                                       Real block_val) {
   AKANTU_DEBUG_IN();
 
   // PetscErrorCode ierr;
 
   // /// get the global equation numbers to find the rows that need to be zeroed
   // /// for the blocked dofs
   // Int * eq_nb_val = dof_synchronizer->getGlobalDOFEquationNumbers().storage();
 
   // /// every processor calls the MatSetZero() only for his local or master dofs.
   // /// This assures that not two processors or more try to zero the same row
   // UInt nb_component = boundary.getNbComponent();
-  // UInt size = boundary.getSize();
+  // UInt size = boundary.size();
   // Int nb_blocked_local_master_eq_nb = 0;
   // Array<Int> blocked_local_master_eq_nb(this->local_size);
   // Int * blocked_lm_eq_nb_ptr = blocked_local_master_eq_nb.storage();
 
   // for (UInt i = 0; i < size; ++i) {
   //   for (UInt j = 0; j < nb_component; ++j) {
   //     UInt local_dof = i * nb_component + j;
   //     if (boundary(i, j) == true &&
   //         this->dof_synchronizer->isLocalOrMasterDOF(local_dof)) {
   //       Int global_eq_nb = *eq_nb_val;
   //       *blocked_lm_eq_nb_ptr = global_eq_nb;
   //       ++nb_blocked_local_master_eq_nb;
   //       ++blocked_lm_eq_nb_ptr;
   //     }
   //     ++eq_nb_val;
   //   }
   // }
   // blocked_local_master_eq_nb.resize(nb_blocked_local_master_eq_nb);
 
   // ierr = AOApplicationToPetsc(this->petsc_matrix_wrapper->ao,
   //                             nb_blocked_local_master_eq_nb,
   //                             blocked_local_master_eq_nb.storage());
   // CHKERRXX(ierr);
   // ierr = MatZeroRowsColumns(
   //     this->petsc_matrix_wrapper->mat, nb_blocked_local_master_eq_nb,
   //     blocked_local_master_eq_nb.storage(), block_val, 0, 0);
   // CHKERRXX(ierr);
 
   // this->performAssembly();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /// set all entries to zero while keeping the same nonzero pattern
 void SparseMatrixPETSc::clear() {
   MatZeroEntries(this->mat);
 }
 
 } // akantu
diff --git a/src/solver/sparse_solver_inline_impl.cc b/src/solver/sparse_solver_inline_impl.cc
index 904243fda..da2ae4618 100644
--- a/src/solver/sparse_solver_inline_impl.cc
+++ b/src/solver/sparse_solver_inline_impl.cc
@@ -1,81 +1,81 @@
 /**
  * @file   solver_inline_impl.cc
  * @author Aurelia Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @date   Thu Nov 13 14:43:41 2014
  *
  * @brief  implementation of solver inline functions
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // inline UInt Solver::getNbDataForDOFs(const Array<UInt> & dofs,
 // 				     SynchronizationTag tag) const {
 //   AKANTU_DEBUG_IN();
 
 //   UInt size = 0;
 
 //   switch(tag) {
 //   case _gst_solver_solution: {
-//     size += dofs.getSize() * sizeof(Real);
+//     size += dofs.size() * sizeof(Real);
 //     break;
 //   }
 //   default: {  }
 //   }
 
 //   AKANTU_DEBUG_OUT();
 //   return size;
 // }
 
 // /* -------------------------------------------------------------------------- */
 // inline void Solver::packDOFData(CommunicationBuffer & buffer,
 // 				const Array<UInt> & dofs,
 // 				SynchronizationTag tag) const {
 //   AKANTU_DEBUG_IN();
 
 //   switch(tag) {
 //   case _gst_solver_solution: {
 //     packDOFDataHelper(*solution, buffer, dofs);
 //     break;
 //   }
 //   default: {
 //   }
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 // /* -------------------------------------------------------------------------- */
 // inline void Solver::unpackDOFData(CommunicationBuffer & buffer,
 // 				  const Array<UInt> & dofs,
 // 				  SynchronizationTag tag) {
 //   AKANTU_DEBUG_IN();
 
 //   switch(tag) {
 //   case _gst_solver_solution: {
 //     unpackDOFDataHelper(*solution, buffer, dofs);
 //     break;
 //   }
 //   default: {
 //   }
 //   }
 
 //   AKANTU_DEBUG_OUT();
 // }
diff --git a/src/solver/sparse_solver_mumps.cc b/src/solver/sparse_solver_mumps.cc
index 54786d40a..681279b59 100644
--- a/src/solver/sparse_solver_mumps.cc
+++ b/src/solver/sparse_solver_mumps.cc
@@ -1,441 +1,441 @@
 /**
  * @file   sparse_solver_mumps.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  implem of SparseSolverMumps class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  * @section DESCRIPTION
  *
  * @subsection Ctrl_param Control parameters
  *
  * ICNTL(1),
  * ICNTL(2),
  * ICNTL(3) : output streams for error, diagnostics, and global messages
  *
  * ICNTL(4) : verbose level : 0 no message - 4 all messages
  *
  * ICNTL(5) : type of matrix, 0 assembled, 1 elementary
  *
  * ICNTL(6) : control  the permutation and scaling(default 7)  see mumps doc for
  * more information
  *
  * ICNTL(7) : determine  the pivot  order (default  7) see  mumps doc  for more
  * information
  *
  * ICNTL(8) : describe the scaling method used
  *
  * ICNTL(9) : 1 solve A x = b, 0 solve At x = b
  *
  * ICNTL(10) : number of iterative refinement when NRHS = 1
  *
  * ICNTL(11) : > 0 return statistics
  *
  * ICNTL(12) : only used for SYM = 2, ordering strategy
  *
  * ICNTL(13) :
  *
  * ICNTL(14) : percentage of increase of the estimated working space
  *
  * ICNTL(15-17) : not used
  *
  * ICNTL(18) : only  used if ICNTL(5) = 0, 0 matrix  centralized, 1 structure on
  * host and mumps  give the mapping, 2 structure on  host and distributed matrix
  * for facto, 3 distributed matrix
  *
  * ICNTL(19) : > 0, Shur complement returned
  *
  * ICNTL(20) : 0 rhs dense, 1 rhs sparse
  *
  * ICNTL(21) : 0 solution in rhs, 1 solution distributed in ISOL_loc and SOL_loc
  * allocated by user
  *
  * ICNTL(22) : 0 in-core, 1 out-of-core
  *
  * ICNTL(23) : maximum memory allocatable by mumps pre proc
  *
  * ICNTL(24) : controls the detection of "null pivot rows"
  *
  * ICNTL(25) :
  *
  * ICNTL(26) :
  *
  * ICNTL(27) :
  *
  * ICNTL(28) : 0 automatic choice, 1 sequential analysis, 2 parallel analysis
  *
  * ICNTL(29) : 0 automatic choice, 1 PT-Scotch, 2 ParMetis
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 #include "sparse_matrix_aij.hh"
 
 #if defined(AKANTU_USE_MPI)
 #include "mpi_type_wrapper.hh"
 #include "static_communicator_mpi.hh"
 #endif
 
 #include "sparse_solver_mumps.hh"
 
 /* -------------------------------------------------------------------------- */
 // static std::ostream & operator <<(std::ostream & stream, const DMUMPS_STRUC_C
 // & _this) {
 //   stream << "DMUMPS Data [" << std::endl;
 //   stream << " + job          : " << _this.job          << std::endl;
 //   stream << " + par          : " << _this.par          << std::endl;
 //   stream << " + sym          : " << _this.sym          << std::endl;
 //   stream << " + comm_fortran : " << _this.comm_fortran << std::endl;
 //   stream << " + nz           : " << _this.nz           << std::endl;
 //   stream << " + irn          : " << _this.irn          << std::endl;
 //   stream << " + jcn          : " << _this.jcn          << std::endl;
 //   stream << " + nz_loc       : " << _this.nz_loc       << std::endl;
 //   stream << " + irn_loc      : " << _this.irn_loc      << std::endl;
 //   stream << " + jcn_loc      : " << _this.jcn_loc      << std::endl;
 //   stream << "]";
 //   return stream;
 // }
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SparseSolverMumps::SparseSolverMumps(DOFManagerDefault & dof_manager,
                                      const ID & matrix_id, const ID & id,
                                      const MemoryID & memory_id)
     : SparseSolver(dof_manager, matrix_id, id, memory_id),
       dof_manager(dof_manager), matrix(dof_manager.getMatrix(matrix_id)),
       master_rhs_solution(0, 1), is_initialized(false) {
   AKANTU_DEBUG_IN();
 
   this->prank = communicator.whoAmI();
 
 #ifdef AKANTU_USE_MPI
   this->parallel_method = _fully_distributed;
 #else  // AKANTU_USE_MPI
   this->parallel_method = _not_parallel;
 #endif // AKANTU_USE_MPI
 
   this->mumps_data.par = 1; // The host is part of computations
 
   switch (this->parallel_method) {
   case _not_parallel:
     break;
   case _master_slave_distributed:
     this->mumps_data.par = 0; // The host is not part of the computations
   case _fully_distributed:
 #ifdef AKANTU_USE_MPI
     const StaticCommunicatorMPI & mpi_st_comm =
         dynamic_cast<const StaticCommunicatorMPI &>(
             communicator.getRealStaticCommunicator());
     MPI_Comm mpi_comm = mpi_st_comm.getMPITypeWrapper().getMPICommunicator();
     this->mumps_data.comm_fortran = MPI_Comm_c2f(mpi_comm);
 #else
     AKANTU_DEBUG_ERROR(
         "You cannot use parallel method to solve without activating MPI");
 #endif
     break;
   }
 
   this->mumps_data.sym = 2 * (this->matrix.getMatrixType() == _symmetric);
   this->prank = communicator.whoAmI();
 
   this->setOutputLevel();
 
   this->mumps_data.job = _smj_initialize; // initialize
   dmumps_c(&this->mumps_data);
 
   this->setOutputLevel();
 
   this->is_initialized = true;
 
   this->last_profile_release = this->matrix.getProfileRelease() - 1;
   this->last_value_release = this->matrix.getValueRelease() - 1;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SparseSolverMumps::~SparseSolverMumps() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::destroyInternalData() {
   if (this->is_initialized) {
     this->mumps_data.job = _smj_destroy; // destroy
     dmumps_c(&this->mumps_data);
     this->is_initialized = false;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::checkInitialized() {
   if (!this->is_initialized)
     AKANTU_EXCEPTION("You cannot use an un/de-initialized mumps solver");
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::setOutputLevel() {
   // Output setup
   icntl(1) = 0; // error output
   icntl(2) = 0; // dignostics output
   icntl(3) = 0; // informations
   icntl(4) = 0;
 
 #if !defined(AKANTU_NDEBUG)
   DebugLevel dbg_lvl = debug::debugger.getDebugLevel();
 
   if (AKANTU_DEBUG_TEST(dblDump)) {
     strcpy(this->mumps_data.write_problem, "mumps_matrix.mtx");
   }
 
   icntl(1) = (dbg_lvl >= dblWarning) ? 6 : 0;
   icntl(3) = (dbg_lvl >= dblInfo) ? 6 : 0;
   icntl(2) = (dbg_lvl >= dblTrace) ? 6 : 0;
 
   if (dbg_lvl >= dblDump) {
     icntl(4) = 4;
   } else if (dbg_lvl >= dblTrace) {
     icntl(4) = 3;
   } else if (dbg_lvl >= dblInfo) {
     icntl(4) = 2;
   } else if (dbg_lvl >= dblWarning) {
     icntl(4) = 1;
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::initMumpsData() {
   // Default Scaling
   icntl(8) = 77;
 
   // Assembled matrix
   icntl(5) = 0;
 
   /// Default centralized dense second member
   icntl(20) = 0;
   icntl(21) = 0;
 
   // automatic choice for analysis
   icntl(28) = 0;
 
-  UInt size = this->matrix.getSize();
+  UInt size = this->matrix.size();
 
   if (prank == 0) {
     this->master_rhs_solution.resize(size);
   }
 
   this->mumps_data.nz_alloc = 0;
   this->mumps_data.n = size;
 
   switch (this->parallel_method) {
   case _fully_distributed:
     icntl(18) = 3; // fully distributed
 
     this->mumps_data.nz_loc = matrix.getNbNonZero();
     this->mumps_data.irn_loc = matrix.getIRN().storage();
     this->mumps_data.jcn_loc = matrix.getJCN().storage();
 
     break;
   case _not_parallel:
   case _master_slave_distributed:
     icntl(18) = 0; // centralized
 
     if (prank == 0) {
       this->mumps_data.nz = matrix.getNbNonZero();
       this->mumps_data.irn = matrix.getIRN().storage();
       this->mumps_data.jcn = matrix.getJCN().storage();
     } else {
       this->mumps_data.nz = 0;
       this->mumps_data.irn = NULL;
       this->mumps_data.jcn = NULL;
     }
     break;
   default:
     AKANTU_DEBUG_ERROR("This case should not happen!!");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::initialize() {
   AKANTU_DEBUG_IN();
 
   this->analysis();
   //  icntl(14) = 80;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::analysis() {
   AKANTU_DEBUG_IN();
 
   initMumpsData();
 
   this->checkInitialized();
   this->mumps_data.job = _smj_analyze; // analyze
   dmumps_c(&this->mumps_data);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::factorize() {
   AKANTU_DEBUG_IN();
 
   // should be null on slaves
   // this->mumps_data.rhs = this->master_rhs_solution.storage();
 
   if (parallel_method == _fully_distributed)
     this->mumps_data.a_loc = this->matrix.getA().storage();
   else {
     if (prank == 0)
       this->mumps_data.a = this->matrix.getA().storage();
   }
 
   this->checkInitialized();
   this->mumps_data.job = _smj_factorize; // factorize
   dmumps_c(&this->mumps_data);
 
   this->printError();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solve(Array<Real> & x, const Array<Real> & b) {
   auto & synch = this->dof_manager.getSynchronizer();
 
   if (this->prank == 0) {
     this->master_rhs_solution.resize(this->dof_manager.getSystemSize());
     synch.gather(b, this->master_rhs_solution);
   } else {
     synch.gather(b);
   }
 
   this->solveInternal();
 
   if (this->prank == 0) {
     synch.scatter(x, this->master_rhs_solution);
   } else {
     synch.scatter(x);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solve() {
   this->master_rhs_solution.copy(this->dof_manager.getGlobalResidual());
 
   this->solveInternal();
 
   this->dof_manager.setGlobalSolution(this->master_rhs_solution);
 
   this->dof_manager.splitSolutionPerDOFs();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::solveInternal() {
   AKANTU_DEBUG_IN();
 
   this->setOutputLevel();
 
   if (this->last_profile_release != this->matrix.getProfileRelease()) {
     this->analysis();
     this->last_profile_release = this->matrix.getProfileRelease();
   }
 
   if (AKANTU_DEBUG_TEST(dblDump)) {
     std::stringstream sstr;
     sstr << prank << ".mtx";
     this->matrix.saveMatrix("solver_mumps" + sstr.str());
   }
 
   if (this->last_value_release != this->matrix.getValueRelease()) {
     this->factorize();
     this->last_value_release = this->matrix.getValueRelease();
   }
 
   if (prank == 0) {
     this->mumps_data.rhs = this->master_rhs_solution.storage();
   }
 
   this->checkInitialized();
   this->mumps_data.job = _smj_solve; // solve
   dmumps_c(&this->mumps_data);
 
   this->printError();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SparseSolverMumps::printError() {
   Vector<Int> _info_v(2);
   _info_v[0] = info(1);  // to get errors
   _info_v[1] = -info(1); // to get warnings
   StaticCommunicator::getStaticCommunicator().allReduce(_info_v, _so_min);
   _info_v[1] = -_info_v[1];
 
   if (_info_v[0] < 0) { // < 0 is an error
     switch (_info_v[0]) {
     case -10:
       AKANTU_DEBUG_ERROR("The matrix is singular");
       break;
     case -9: {
       icntl(14) += 10;
       if (icntl(14) != 90) {
         // std::cout << "Dynamic memory increase of 10%" << std::endl;
         AKANTU_DEBUG_WARNING("MUMPS dynamic memory is insufficient it will be "
                              "increased allowed to use 10% more");
 
         // change releases to force a recompute
         this->last_value_release--;
         this->last_profile_release--;
 
         this->solve();
       } else {
         AKANTU_DEBUG_ERROR("The MUMPS workarray is too small INFO(2)="
                            << info(2) << "No further increase possible");
         break;
       }
     }
     default:
       AKANTU_DEBUG_ERROR("Error in mumps during solve process, check mumps "
                          "user guide INFO(1) = "
                          << _info_v[1]);
     }
   } else if (_info_v[1] > 0) {
     AKANTU_DEBUG_WARNING("Warning in mumps during solve process, check mumps "
                          "user guide INFO(1) = "
                          << _info_v[1]);
   }
 }
 
 } // akantu
diff --git a/src/synchronizer/communication_buffer.hh b/src/synchronizer/communication_buffer.hh
index ea0006b71..43f6809c3 100644
--- a/src/synchronizer/communication_buffer.hh
+++ b/src/synchronizer/communication_buffer.hh
@@ -1,193 +1,193 @@
 /**
  * @file   communication_buffer.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Buffer for packing and unpacking data
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_array.hh"
 #include "element.hh"
 
 #ifndef __AKANTU_COMMUNICATION_BUFFER_HH__
 #define __AKANTU_COMMUNICATION_BUFFER_HH__
 
 namespace akantu {
 
 template<bool is_static = true>
 class CommunicationBufferTemplated {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   explicit CommunicationBufferTemplated(UInt size) : buffer(size, 1) {
     ptr_pack = buffer.storage();
     ptr_unpack = buffer.storage();
   };
 
   CommunicationBufferTemplated() : CommunicationBufferTemplated(0) {}
 
   CommunicationBufferTemplated(const CommunicationBufferTemplated & other) {
     buffer = other.buffer;
     ptr_pack = buffer.storage();
     ptr_unpack = buffer.storage();
   }
 
   CommunicationBufferTemplated & operator=(const CommunicationBufferTemplated & other) {
     if (this != &other) {
       buffer = other.buffer;
       ptr_pack = buffer.storage();
       ptr_unpack = buffer.storage();
     }
     return *this;
   }
 
   virtual ~CommunicationBufferTemplated() {};
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
 
   /// reset to "empty"
   inline void reset();
 
   /// resize the internal buffer
   inline void resize(UInt size);
 
   /// clear buffer context
   inline void clear();
 
 private:
   inline void packResize(UInt size);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   inline char * storage() { return buffer.storage(); };
 
   /* ------------------------------------------------------------------------ */
   /* 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(){ return ptr_pack - buffer.storage(); };
   /// return the size in bytes of data left to be unpacked
-  inline UInt getLeftToUnpack(){ return buffer.getSize() - (ptr_unpack - buffer.storage()); };
+  inline UInt getLeftToUnpack(){ return buffer.size() - (ptr_unpack - buffer.storage()); };
   /// return the global size allocated
-  inline UInt getSize(){ return buffer.getSize(); };
+  inline UInt size(){ return buffer.size(); };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 
   /// current position for packing
   char * ptr_pack;
 
   /// current position for unpacking
   char * ptr_unpack;
 
   /// storing buffer
   Array<char> buffer;
 };
 
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #if defined (AKANTU_INCLUDE_INLINE_IMPL)
 #  include "communication_buffer_inline_impl.cc"
 #endif
 
 using CommunicationBuffer = CommunicationBufferTemplated<true>;
 using DynamicCommunicationBuffer = CommunicationBufferTemplated<false> ;
 
 
 } // 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 73de024a3..565510cee 100644
--- a/src/synchronizer/communication_buffer_inline_impl.cc
+++ b/src/synchronizer/communication_buffer_inline_impl.cc
@@ -1,319 +1,319 @@
 /**
  * @file   communication_buffer_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Apr 14 2011
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  CommunicationBuffer inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(const T &) {
   return sizeof(T);
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt
 CommunicationBufferTemplated<is_static>::sizeInBuffer(const Vector<T> & data) {
   UInt size = data.size() * sizeof(T);
   return size;
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt
 CommunicationBufferTemplated<is_static>::sizeInBuffer(const Matrix<T> & data) {
   UInt size = data.size() * sizeof(T);
   return size;
 }
 
 template <bool is_static>
 template <typename T>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(
     const std::vector<T> & data) {
   UInt size = data.size() * sizeof(T) + sizeof(size_t);
   return size;
 }
 
 template <bool is_static>
 inline UInt CommunicationBufferTemplated<is_static>::sizeInBuffer(
     const std::string & data) {
   UInt size = data.size() * sizeof(std::string::value_type) + sizeof(size_t);
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::packResize(UInt size) {
   if (!is_static) {
     char * values = buffer.storage();
-    buffer.resize(buffer.getSize() + size);
+    buffer.resize(buffer.size() + size);
     ptr_pack = buffer.storage() + (ptr_pack - values);
     ptr_unpack = buffer.storage() + (ptr_unpack - values);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator<<(const T & to_pack) {
   UInt size = sizeInBuffer(to_pack);
   packResize(size);
   AKANTU_DEBUG_ASSERT(
-      (buffer.storage() + buffer.getSize()) >= (ptr_pack + size),
+      (buffer.storage() + buffer.size()) >= (ptr_pack + size),
       "Packing too much data in the CommunicationBufferTemplated");
   memcpy(ptr_pack, reinterpret_cast<const char *>(&to_pack), size);
   ptr_pack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(T & to_unpack) {
   UInt size = sizeInBuffer(to_unpack);
 
   alignas(alignof(T)) std::array<char, sizeof(T)> aligned_ptr;
   memcpy(aligned_ptr.data(), ptr_unpack, size);
 
   T * tmp = reinterpret_cast<T *>(aligned_ptr.data());
   AKANTU_DEBUG_ASSERT(
-      (buffer.storage() + buffer.getSize()) >= (ptr_unpack + size),
+      (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.getSize()) >= (ptr_pack + size),
+      (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.getSize()) >= (ptr_unpack + size),
+      (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.getSize()) >= (ptr_pack + size),
+      (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.getSize()) >= (ptr_unpack + size),
+      (buffer.storage() + buffer.size()) >= (ptr_unpack + size),
       "Unpacking too much data in the CommunicationBufferTemplated");
   memcpy(to_unpack.storage(), ptr_unpack, size);
   ptr_unpack += size;
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline void CommunicationBufferTemplated<is_static>::packIterable(T & to_pack) {
   operator<<(size_t(to_pack.size()));
   typename T::const_iterator it = to_pack.begin();
   typename T::const_iterator end = to_pack.end();
   for (; it != end; ++it)
     operator<<(*it);
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline void
 CommunicationBufferTemplated<is_static>::unpackIterable(T & to_unpack) {
   size_t size;
   operator>>(size);
   to_unpack.resize(size);
   typename T::iterator it = to_unpack.begin();
   typename T::iterator end = to_unpack.end();
   for (; it != end; ++it)
     operator>>(*it);
 }
 
 /**
  * std::vector<T>
  */
 /* -------------------------------------------------------------------------- */
 
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator<<(const std::vector<T> & to_pack) {
   packIterable(to_pack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator>>(std::vector<T> & to_unpack) {
   unpackIterable(to_unpack);
   return *this;
 }
 
 /**
  * std::string
  */
 /* -------------------------------------------------------------------------- */
 
 template <bool is_static>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::
 operator<<(const std::string & to_pack) {
   packIterable(to_pack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline CommunicationBufferTemplated<is_static> &
 CommunicationBufferTemplated<is_static>::operator>>(std::string & to_unpack) {
   unpackIterable(to_unpack);
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 template <typename T>
 inline std::string
 CommunicationBufferTemplated<is_static>::extractStream(UInt block_size) {
   std::stringstream str;
   T * ptr = reinterpret_cast<T *>(buffer.storage());
-  UInt sz = buffer.getSize() / sizeof(T);
+  UInt sz = buffer.size() / sizeof(T);
   UInt sz_block = block_size / sizeof(T);
 
   UInt n_block = 0;
   for (UInt i = 0; i < sz; ++i) {
     if (i % sz_block == 0) {
       str << std::endl << n_block << " ";
       ++n_block;
     }
     str << *ptr << " ";
     ++ptr;
   }
   return str.str();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::resize(UInt size) {
   if (!is_static) {
     buffer.resize(0);
   } else {
     buffer.resize(size);
   }
   reset();
 #ifndef AKANTU_NDEBUG
   clear();
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::clear() {
   buffer.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_static>
 inline void CommunicationBufferTemplated<is_static>::reset() {
   ptr_pack = buffer.storage();
   ptr_unpack = buffer.storage();
 }
 
 /* -------------------------------------------------------------------------- */
 // template<bool is_static>
 // inline CommunicationBufferTemplated<is_static> &
 // CommunicationBufferTemplated<is_static>::packMeshData (const MeshData &
 // to_pack, const ElementType & type) {
 
 // UInt size = to_pack.size();
 // operator<<(size);
 // typename std::vector<T>::iterator it  = to_pack.begin();
 // typename std::vector<T>::iterator end = to_pack.end();
 // for(;it != end; ++it) operator<<(*it);
 // return *this;
 
 //}
diff --git a/src/synchronizer/data_accessor.hh b/src/synchronizer/data_accessor.hh
index cd25f9dab..6ef63932a 100644
--- a/src/synchronizer/data_accessor.hh
+++ b/src/synchronizer/data_accessor.hh
@@ -1,281 +1,281 @@
 /**
  * @file   data_accessor.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Sep 01 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  Interface of accessors for pack_unpack system
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "communication_buffer.hh"
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DATA_ACCESSOR_HH__
 #define __AKANTU_DATA_ACCESSOR_HH__
 
 namespace akantu {
 class FEEngine;
 } // akantu
 
 namespace akantu {
 
 class DataAccessorBase {
 public:
   DataAccessorBase() {}
   virtual ~DataAccessorBase() {}
 };
 
 template <class T> class DataAccessor : public virtual DataAccessorBase {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   DataAccessor() {}
   virtual ~DataAccessor() {}
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /**
    * @brief get  the number of  data to exchange  for a given array of T
    * (elements or dofs) and a given akantu::SynchronizationTag
    */
   virtual UInt getNbData(const Array<T> & elements,
                          const SynchronizationTag & tag) const = 0;
 
   /**
    * @brief pack the data for a given array of T (elements or dofs) and a given
    * akantu::SynchronizationTag
    */
   virtual void packData(CommunicationBuffer & buffer, const Array<T> & element,
                         const SynchronizationTag & tag) const = 0;
 
   /**
    * @brief unpack the data for a given array of T (elements or dofs) and a
    * given akantu::SynchronizationTag
    */
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<T> & element,
                           const SynchronizationTag & tag) = 0;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Specialization                                                             */
 /* -------------------------------------------------------------------------- */
 template <> class DataAccessor<Element> : public virtual DataAccessorBase {
 public:
   DataAccessor() {}
   virtual ~DataAccessor() {}
 
   virtual UInt getNbData(const Array<Element> & elements,
                          const SynchronizationTag & tag) const = 0;
   virtual void packData(CommunicationBuffer & buffer,
                         const Array<Element> & element,
                         const SynchronizationTag & tag) const = 0;
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<Element> & element,
                           const SynchronizationTag & tag) = 0;
 
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T, bool pack_helper>
   static void
   packUnpackNodalDataHelper(Array<T> & data, CommunicationBuffer & buffer,
                             const Array<Element> & elements, const Mesh & mesh);
 
   /* ------------------------------------------------------------------------ */
   template <typename T, bool pack_helper>
   static void packUnpackElementalDataHelper(
       ElementTypeMapArray<T> & data_to_pack, CommunicationBuffer & buffer,
       const Array<Element> & element, bool per_quadrature_point_data,
       const FEEngine & fem);
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   static void
   packNodalDataHelper(const Array<T> & data, CommunicationBuffer & buffer,
                       const Array<Element> & elements, const Mesh & mesh) {
     packUnpackNodalDataHelper<T, true>(const_cast<Array<T> &>(data), buffer,
                                        elements, mesh);
   }
 
   template <typename T>
   static inline void
   unpackNodalDataHelper(Array<T> & data, CommunicationBuffer & buffer,
                         const Array<Element> & elements, const Mesh & mesh) {
     packUnpackNodalDataHelper<T, false>(data, buffer, elements, mesh);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   static inline void
   packElementalDataHelper(const ElementTypeMapArray<T> & data_to_pack,
                           CommunicationBuffer & buffer,
                           const Array<Element> & elements,
                           bool per_quadrature_point, const FEEngine & fem) {
     packUnpackElementalDataHelper<T, true>(
         const_cast<ElementTypeMapArray<T> &>(data_to_pack), buffer, elements,
         per_quadrature_point, fem);
   }
 
   template <typename T>
   static inline void
   unpackElementalDataHelper(ElementTypeMapArray<T> & data_to_unpack,
                             CommunicationBuffer & buffer,
                             const Array<Element> & elements,
                             bool per_quadrature_point, const FEEngine & fem) {
     packUnpackElementalDataHelper<T, false>(data_to_unpack, buffer, elements,
                                             per_quadrature_point, fem);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 template <> class DataAccessor<UInt> : public virtual DataAccessorBase {
 public:
   DataAccessor() {}
   virtual ~DataAccessor() {}
 
   virtual UInt getNbData(const Array<UInt> & elements,
                          const SynchronizationTag & tag) const = 0;
   virtual void packData(CommunicationBuffer & buffer,
                         const Array<UInt> & element,
                         const SynchronizationTag & tag) const = 0;
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<UInt> & element,
                           const SynchronizationTag & tag) = 0;
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T, bool pack_helper>
   static void packUnpackDOFDataHelper(Array<T> & data,
                                       CommunicationBuffer & buffer,
                                       const Array<UInt> & dofs);
 
   template <typename T>
   static inline void packDOFDataHelper(const Array<T> & data_to_pack,
                                        CommunicationBuffer & buffer,
                                        const Array<UInt> & dofs) {
     packUnpackDOFDataHelper<T, true>(const_cast<Array<T> &>(data_to_pack),
                                      buffer, dofs);
   }
 
   template <typename T>
   static inline void unpackDOFDataHelper(Array<T> & data_to_unpack,
                                          CommunicationBuffer & buffer,
                                          const Array<UInt> & dofs) {
     packUnpackDOFDataHelper<T, false>(data_to_unpack, buffer, dofs);
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T> class AddOperation {
 public:
   inline T operator()(T & a, T & b) { return a + b; };
 };
 
 template <typename T> class IdentityOperation {
 public:
   inline T & operator()(T &, T & b) { return b; };
 };
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <template <class> class Op, class T>
 class ReduceUIntDataAccessor : public virtual DataAccessor<UInt> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   ReduceUIntDataAccessor(Array<T> & data, const SynchronizationTag & tag)
       : data(data), tag(tag) {}
 
   virtual ~ReduceUIntDataAccessor() {}
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   virtual UInt getNbData(const Array<UInt> & elements,
                          const SynchronizationTag & tag) const {
     if (tag != this->tag)
       return 0;
 
     Vector<T> tmp(data.getNbComponent());
-    return elements.getSize() * CommunicationBuffer::sizeInBuffer(tmp);
+    return elements.size() * CommunicationBuffer::sizeInBuffer(tmp);
   }
 
   /* ------------------------------------------------------------------------ */
   virtual void packData(CommunicationBuffer & buffer,
                         const Array<UInt> & elements,
                         const SynchronizationTag & tag) const {
     if (tag != this->tag)
       return;
 
     auto data_it = data.begin(data.getNbComponent());
     for (auto el : elements) {
       buffer << Vector<T>(data_it[el]);
     }
   }
 
   /* ------------------------------------------------------------------------ */
   virtual void unpackData(CommunicationBuffer & buffer,
                           const Array<UInt> & elements,
                           const SynchronizationTag & tag) {
     if (tag != this->tag)
       return;
 
     auto data_it = data.begin(data.getNbComponent());
     for (auto el : elements) {
       Vector<T> unpacked(data.getNbComponent());
       Vector<T> vect(data_it[el]);
       buffer >> unpacked;
 
       vect = oper(vect, unpacked);
     }
   }
 
 protected:
   /// data to (un)pack
   Array<T> & data;
 
   /// Tag to consider
   SynchronizationTag tag;
 
   /// reduction operator
   Op<Vector<T>> oper;
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T>
 using SimpleUIntDataAccessor = ReduceUIntDataAccessor<IdentityOperation, T>;
 
 } // akantu
 
 #endif /* __AKANTU_DATA_ACCESSOR_HH__ */
diff --git a/src/synchronizer/dof_synchronizer.cc b/src/synchronizer/dof_synchronizer.cc
index 43c6db4d8..adb612d2e 100644
--- a/src/synchronizer/dof_synchronizer.cc
+++ b/src/synchronizer/dof_synchronizer.cc
@@ -1,281 +1,281 @@
 /**
  * @file   dof_synchronizer.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 17 2011
  * @date last modification: Wed Oct 21 2015
  *
  * @brief  DOF synchronizing object implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_synchronizer.hh"
 #include "aka_iterators.hh"
 #include "dof_manager_default.hh"
 #include "mesh.hh"
 #include "node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /**
  * A DOFSynchronizer needs a mesh and the number of degrees of freedom
  * per node to be created. In the constructor computes the local and global dof
  * number for each dof. The member
  * proc_informations (std vector) is resized with the number of mpi
  * processes. Each entry in the vector is a PerProcInformations object
  * that contains the interactions of the current mpi process (prank) with the
  * mpi process corresponding to the position of that entry. Every
  * ProcInformations object contains one array with the dofs that have
  * to be sent to prank and a second one with dofs that willl be received form
  * prank.
  * This information is needed for the asychronous communications. The
  * constructor sets up this information.
  */
 DOFSynchronizer::DOFSynchronizer(DOFManagerDefault & dof_manager, const ID & id,
                                  MemoryID memory_id,
                                  const StaticCommunicator & comm)
     : SynchronizerImpl<UInt>(id, memory_id, comm), root(0),
       dof_manager(dof_manager), root_dofs(0, 1, "dofs-to-receive-from-master"),
       dof_changed(true) {
   std::vector<ID> dof_ids = dof_manager.getDOFIDs();
 
   // Transfers nodes to global equation numbers in new schemes
   for (ID dof_id : dof_ids) {
     registerDOFs(dof_id);
   }
 
   this->initScatterGatherCommunicationScheme();
 }
 
 /* -------------------------------------------------------------------------- */
 DOFSynchronizer::~DOFSynchronizer() {}
 
 /* -------------------------------------------------------------------------- */
 void DOFSynchronizer::registerDOFs(const ID & dof_id) {
   if (this->nb_proc == 1)
     return;
 
   if (dof_manager.getSupportType(dof_id) != _dst_nodal)
     return;
 
   using const_scheme_iterator = Communications<UInt>::const_scheme_iterator;
 
   const auto equation_numbers = dof_manager.getLocalEquationNumbers(dof_id);
 
   const auto & associated_nodes = dof_manager.getDOFsAssociatedNodes(dof_id);
   const auto & node_synchronizer = dof_manager.getMesh().getNodeSynchronizer();
   const auto & node_communications = node_synchronizer.getCommunications();
 
   auto transcode_node_to_global_dof_scheme =
       [this, &associated_nodes,
        &equation_numbers](const_scheme_iterator it, const_scheme_iterator end,
                           const CommunicationSendRecv & sr) -> void {
     for (; it != end; ++it) {
       auto & scheme = communications.createScheme(it->first, sr);
 
       const auto & node_scheme = it->second;
       for (auto & node : node_scheme) {
         auto an_begin = associated_nodes.begin();
         auto an_it = an_begin;
         auto an_end = associated_nodes.end();
 
         std::vector<UInt> global_dofs_per_node;
         while ((an_it = std::find(an_it, an_end, node)) != an_end) {
           UInt pos = an_it - an_begin;
           UInt local_eq_num = equation_numbers(pos);
           UInt global_eq_num =
               dof_manager.localToGlobalEquationNumber(local_eq_num);
           global_dofs_per_node.push_back(global_eq_num);
           ++an_it;
         }
 
         std::sort(global_dofs_per_node.begin(), global_dofs_per_node.end());
         std::transform(global_dofs_per_node.begin(), global_dofs_per_node.end(),
                        global_dofs_per_node.begin(), [this](UInt g) -> UInt {
                          UInt l = dof_manager.globalToLocalEquationNumber(g);
                          return l;
                        });
         for (auto & leqnum : global_dofs_per_node) {
           scheme.push_back(leqnum);
         }
       }
     }
   };
 
   for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
        ++sr_it) {
     auto ncs_it = node_communications.begin_scheme(*sr_it);
     auto ncs_end = node_communications.end_scheme(*sr_it);
 
     transcode_node_to_global_dof_scheme(ncs_it, ncs_end, *sr_it);
   }
 
   dof_changed = true;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFSynchronizer::initScatterGatherCommunicationScheme() {
   AKANTU_DEBUG_IN();
 
   if (this->nb_proc == 1) {
     dof_changed = false;
     AKANTU_DEBUG_OUT();
     return;
   }
 
   UInt nb_dofs = dof_manager.getLocalSystemSize();
 
   this->root_dofs.clear();
   this->master_receive_dofs.clear();
 
   Array<UInt> dofs_to_send;
   for (UInt n = 0; n < nb_dofs; ++n) {
     if (dof_manager.isLocalOrMasterDOF(n)) {
       auto & receive_per_proc = master_receive_dofs[this->root];
       UInt global_dof = dof_manager.localToGlobalEquationNumber(n);
 
       root_dofs.push_back(n);
       receive_per_proc.push_back(global_dof);
       dofs_to_send.push_back(global_dof);
     }
   }
 
   if (this->rank == UInt(this->root)) {
     Array<UInt> nb_dof_per_proc(this->nb_proc);
-    communicator.gather(dofs_to_send.getSize(), nb_dof_per_proc);
+    communicator.gather(dofs_to_send.size(), nb_dof_per_proc);
 
     std::vector<CommunicationRequest> requests;
     for (UInt p = 0; p < nb_proc; ++p) {
       if (p == UInt(this->root))
         continue;
 
       auto & receive_per_proc = master_receive_dofs[p];
       receive_per_proc.resize(nb_dof_per_proc(p));
       if (nb_dof_per_proc(p) != 0)
         requests.push_back(communicator.asyncReceive(
             receive_per_proc, p,
             Tag::genTag(p, 0, Tag::_GATHER_INITIALIZATION, this->hash_id)));
     }
 
     communicator.waitAll(requests);
     communicator.freeCommunicationRequest(requests);
   } else {
-    communicator.gather(dofs_to_send.getSize(), this->root);
+    communicator.gather(dofs_to_send.size(), this->root);
     AKANTU_DEBUG(dblDebug, "I have " << nb_dofs << " dofs ("
-                                     << dofs_to_send.getSize()
+                                     << dofs_to_send.size()
                                      << " to send to master proc");
 
-    if (dofs_to_send.getSize() != 0)
+    if (dofs_to_send.size() != 0)
       communicator.send(dofs_to_send, this->root,
                         Tag::genTag(this->rank, 0, Tag::_GATHER_INITIALIZATION,
                                     this->hash_id));
   }
 
   dof_changed = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 bool DOFSynchronizer::hasChanged() {
   communicator.allReduce(dof_changed, _so_lor);
   return dof_changed;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFSynchronizer::onNodesAdded(const Array<UInt> & nodes_list) {
   auto dof_ids = dof_manager.getDOFIDs();
 
   const auto & node_synchronizer = dof_manager.getMesh().getNodeSynchronizer();
   const auto & node_communications = node_synchronizer.getCommunications();
 
   std::set<UInt> relevant_nodes;
   std::map<UInt, std::vector<UInt>> nodes_per_proc[2];
   for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
        ++sr_it) {
     auto sit = node_communications.begin_scheme(*sr_it);
     auto send = node_communications.end_scheme(*sr_it);
 
     for (; sit != send; ++sit) {
       auto proc = sit->first;
       const auto & scheme = sit->second;
       for (auto node : nodes_list) {
-        if (scheme.find(node) == -1)
+        if (scheme.find(node) == UInt(-1))
           continue;
         relevant_nodes.insert(node);
         nodes_per_proc[*sr_it][proc].push_back(node);
       }
     }
   }
 
   std::map<UInt, std::vector<UInt>> dofs_per_proc[2];
   for (auto & dof_id : dof_ids) {
     const auto & associated_nodes = dof_manager.getDOFsAssociatedNodes(dof_id);
     const auto & local_equation_numbers =
         dof_manager.getEquationsNumbers(dof_id);
 
     for (auto tuple : zip(associated_nodes, local_equation_numbers)) {
       UInt assoc_node;
       UInt local_eq_num;
       std::tie(assoc_node, local_eq_num) = tuple;
 
       for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
            ++sr_it) {
         for (auto & pair : nodes_per_proc[*sr_it]) {
           if (std::find(pair.second.end(), pair.second.end(), assoc_node) !=
               pair.second.end()) {
             dofs_per_proc[*sr_it][pair.first].push_back(local_eq_num);
           }
         }
       }
     }
   }
 
   for (auto sr_it = send_recv_t::begin(); sr_it != send_recv_t::end();
            ++sr_it) {
     for (auto & pair : dofs_per_proc[*sr_it]) {
       std::sort(pair.second.begin(), pair.second.end(),
                 [this] (UInt la, UInt lb) -> bool {
                   UInt ga = dof_manager.localToGlobalEquationNumber(la);
                   UInt gb = dof_manager.localToGlobalEquationNumber(lb);
                   return ga < gb;
                 });
 
       auto & scheme = communications.getScheme(pair.first, *sr_it);
       for(auto leq : pair.second) {
         scheme.push_back(leq);
       }
     }
   }
   dof_changed = true;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/synchronizer/dof_synchronizer_inline_impl.cc b/src/synchronizer/dof_synchronizer_inline_impl.cc
index 922aa12b5..94a786155 100644
--- a/src/synchronizer/dof_synchronizer_inline_impl.cc
+++ b/src/synchronizer/dof_synchronizer_inline_impl.cc
@@ -1,300 +1,300 @@
 /**
  * @file   dof_synchronizer_inline_impl.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 17 2011
  * @date last modification: Tue Dec 09 2014
  *
  * @brief  DOFSynchronizer inline implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "communication_buffer.hh"
 #include "data_accessor.hh"
 #include "dof_manager_default.hh"
 #include "dof_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_DOF_SYNCHRONIZER_INLINE_IMPL_CC__
 #define __AKANTU_DOF_SYNCHRONIZER_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFSynchronizer::gather(const Array<T> & to_gather, Array<T> & gathered) {
   if (this->hasChanged())
     initScatterGatherCommunicationScheme();
 
   AKANTU_DEBUG_ASSERT(this->rank == UInt(this->root),
                       "This function cannot be called on a slave processor");
-  AKANTU_DEBUG_ASSERT(to_gather.getSize() ==
+  AKANTU_DEBUG_ASSERT(to_gather.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The array to gather does not have the correct size");
-  AKANTU_DEBUG_ASSERT(gathered.getSize() == this->dof_manager.getSystemSize(),
+  AKANTU_DEBUG_ASSERT(gathered.size() == this->dof_manager.getSystemSize(),
                       "The gathered array does not have the correct size");
 
   if (this->nb_proc == 1) {
     gathered.copy(to_gather, true);
 
     AKANTU_DEBUG_OUT();
     return;
   }
 
   std::map<UInt, CommunicationBuffer> buffers;
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p == UInt(this->root))
       continue;
 
     auto receive_it = this->master_receive_dofs.find(p);
     AKANTU_DEBUG_ASSERT(receive_it != this->master_receive_dofs.end(),
                         "Could not find the receive list for dofs of proc "
                             << p);
     const Array<UInt> & receive_dofs = receive_it->second;
-    if (receive_dofs.getSize() == 0)
+    if (receive_dofs.size() == 0)
       continue;
 
     CommunicationBuffer & buffer = buffers[p];
 
-    buffer.resize(receive_dofs.getSize() * to_gather.getNbComponent() *
+    buffer.resize(receive_dofs.size() * to_gather.getNbComponent() *
                   sizeof(T));
 
     AKANTU_DEBUG_INFO(
         "Preparing to receive data for "
-        << receive_dofs.getSize() << " dofs from processor " << p << " "
+        << receive_dofs.size() << " dofs from processor " << p << " "
         << Tag::genTag(p, this->root, Tag::_GATHER, this->hash_id));
 
     requests.push_back(communicator.asyncReceive(
         buffer, p, Tag::genTag(p, this->root, Tag::_GATHER, this->hash_id)));
   }
 
   auto data_gathered_it = gathered.begin(to_gather.getNbComponent());
 
   { // copy master data
     auto data_to_gather_it = to_gather.begin(to_gather.getNbComponent());
     for (auto local_dof : root_dofs) {
       UInt global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
 
       Vector<T> dof_data_gathered = data_gathered_it[global_dof];
       Vector<T> dof_data_to_gather = data_to_gather_it[local_dof];
       dof_data_gathered = dof_data_to_gather;
     }
   }
 
   UInt rr = UInt(-1);
   while ((rr = communicator.waitAny(requests)) != UInt(-1)) {
     CommunicationRequest & request = requests[rr];
     UInt sender = request.getSource();
 
     AKANTU_DEBUG_ASSERT(this->master_receive_dofs.find(sender) !=
                                 this->master_receive_dofs.end() &&
                             buffers.find(sender) != buffers.end(),
                         "Missing infos concerning proc " << sender);
 
     const Array<UInt> & receive_dofs =
         this->master_receive_dofs.find(sender)->second;
     CommunicationBuffer & buffer = buffers[sender];
 
     for (auto global_dof : receive_dofs) {
       Vector<T> dof_data = data_gathered_it[global_dof];
       buffer >> dof_data;
     }
 
     requests.erase(requests.begin() + rr);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void DOFSynchronizer::gather(const Array<T> & to_gather) {
   AKANTU_DEBUG_IN();
 
   if (this->hasChanged())
     initScatterGatherCommunicationScheme();
 
   AKANTU_DEBUG_ASSERT(this->rank != UInt(this->root),
                       "This function cannot be called on the root processor");
-  AKANTU_DEBUG_ASSERT(to_gather.getSize() ==
+  AKANTU_DEBUG_ASSERT(to_gather.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The array to gather does not have the correct size");
 
-  if (this->root_dofs.getSize() == 0) {
+  if (this->root_dofs.size() == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
-  CommunicationBuffer buffer(this->root_dofs.getSize() *
+  CommunicationBuffer buffer(this->root_dofs.size() *
                              to_gather.getNbComponent() * sizeof(T));
 
   auto data_it = to_gather.begin(to_gather.getNbComponent());
   for (auto dof : this->root_dofs) {
     Vector<T> data = data_it[dof];
     buffer << data;
   }
 
   AKANTU_DEBUG_INFO("Gathering data for "
-                    << to_gather.getSize() << " dofs on processor "
+                    << to_gather.size() << " dofs on processor "
                     << this->root << " "
                     << Tag::genTag(this->rank, 0, Tag::_GATHER, this->hash_id));
 
   communicator.send(buffer, this->root,
                     Tag::genTag(this->rank, 0, Tag::_GATHER, this->hash_id));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFSynchronizer::scatter(Array<T> & scattered,
                               const Array<T> & to_scatter) {
   AKANTU_DEBUG_IN();
 
   if (this->hasChanged())
     initScatterGatherCommunicationScheme();
   AKANTU_DEBUG_ASSERT(this->rank == UInt(this->root),
                       "This function cannot be called on a slave processor");
-  AKANTU_DEBUG_ASSERT(scattered.getSize() ==
+  AKANTU_DEBUG_ASSERT(scattered.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The scattered array does not have the correct size");
-  AKANTU_DEBUG_ASSERT(to_scatter.getSize() == this->dof_manager.getSystemSize(),
+  AKANTU_DEBUG_ASSERT(to_scatter.size() == this->dof_manager.getSystemSize(),
                       "The array to scatter does not have the correct size");
 
   if (this->nb_proc == 1) {
     scattered.copy(to_scatter, true);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   std::map<UInt, CommunicationBuffer> buffers;
   std::vector<CommunicationRequest> requests;
 
   for (UInt p = 0; p < nb_proc; ++p) {
     auto data_to_scatter_it = to_scatter.begin(to_scatter.getNbComponent());
 
     if (p == this->rank) {
       auto data_scattered_it = scattered.begin(to_scatter.getNbComponent());
 
       // copy the data for the local processor
       for (auto local_dof : root_dofs) {
         auto global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
 
         Vector<T> dof_data_to_scatter = data_to_scatter_it[global_dof];
         Vector<T> dof_data_scattered = data_scattered_it[local_dof];
         dof_data_scattered = dof_data_to_scatter;
       }
 
       continue;
     }
 
     const Array<UInt> & receive_dofs =
         this->master_receive_dofs.find(p)->second;
 
     // prepare the send buffer
     CommunicationBuffer & buffer = buffers[p];
-    buffer.resize(receive_dofs.getSize() * scattered.getNbComponent() *
+    buffer.resize(receive_dofs.size() * scattered.getNbComponent() *
                   sizeof(T));
 
     // pack the data
     for (auto global_dof : receive_dofs) {
       Vector<T> dof_data_to_scatter = data_to_scatter_it[global_dof];
       buffer << dof_data_to_scatter;
     }
 
     // send the data
     requests.push_back(communicator.asyncSend(
         buffer, p, Tag::genTag(p, 0, Tag::_SCATTER, this->hash_id)));
   }
 
   // wait a clean communications
   communicator.waitAll(requests);
   communicator.freeCommunicationRequest(requests);
 
   // synchronize slave and ghost nodes
   synchronize(scattered);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> void DOFSynchronizer::scatter(Array<T> & scattered) {
   AKANTU_DEBUG_IN();
 
   if (this->hasChanged())
     this->initScatterGatherCommunicationScheme();
   AKANTU_DEBUG_ASSERT(this->rank != UInt(this->root),
                       "This function cannot be called on the root processor");
-  AKANTU_DEBUG_ASSERT(scattered.getSize() ==
+  AKANTU_DEBUG_ASSERT(scattered.size() ==
                           this->dof_manager.getLocalSystemSize(),
                       "The scattered array does not have the correct size");
 
   // prepare the data
   auto data_scattered_it = scattered.begin(scattered.getNbComponent());
-  CommunicationBuffer buffer(this->root_dofs.getSize() *
+  CommunicationBuffer buffer(this->root_dofs.size() *
                              scattered.getNbComponent() * sizeof(T));
 
   // receive the data
   communicator.receive(
       buffer, this->root,
       Tag::genTag(this->rank, 0, Tag::_SCATTER, this->hash_id));
 
   // unpack the data
   for (auto local_dof : root_dofs) {
     Vector<T> dof_data_scattered = data_scattered_it[local_dof];
     buffer >> dof_data_scattered;
   }
 
   // synchronize the ghosts
   synchronize(scattered);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFSynchronizer::synchronize(Array<T> & dof_values_to_synchronize) const {
   AKANTU_DEBUG_IN();
 
   SimpleUIntDataAccessor<T> data_accessor(dof_values_to_synchronize,
                                           _gst_whatever);
   this->synchronizeOnce(data_accessor, _gst_whatever);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <class> class Op, typename T>
 void DOFSynchronizer::reduceSynchronize(Array<T> & dof_vector) const {
   AKANTU_DEBUG_IN();
 
   ReduceUIntDataAccessor<Op, T> data_accessor(dof_vector, _gst_whatever);
   this->synchronizeOnce(data_accessor, _gst_whatever);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
 
 #endif /* __AKANTU_DOF_SYNCHRONIZER_INLINE_IMPL_CC__ */
diff --git a/src/synchronizer/element_info_per_processor.cc b/src/synchronizer/element_info_per_processor.cc
index 5bbaffe58..efd12cd1b 100644
--- a/src/synchronizer/element_info_per_processor.cc
+++ b/src/synchronizer/element_info_per_processor.cc
@@ -1,111 +1,111 @@
 /**
  * @file   element_info_per_processor.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Mar 11 14:56:42 2016
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_info_per_processor.hh"
 #include "element_synchronizer.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iostream>
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ElementInfoPerProc::ElementInfoPerProc(ElementSynchronizer & synchronizer,
                                        UInt message_cnt, UInt root,
                                        ElementType type)
     : MeshAccessor(synchronizer.getMesh()), synchronizer(synchronizer),
       rank(synchronizer.getCommunicator().whoAmI()),
       nb_proc(synchronizer.getCommunicator().getNbProc()), root(root),
       type(type), message_count(message_cnt), mesh(synchronizer.getMesh()),
       comm(synchronizer.getCommunicator()) { }
 
 /* -------------------------------------------------------------------------- */
 void ElementInfoPerProc::fillCommunicationScheme(
     const Array<UInt> & partition) {
   AKANTU_DEBUG_IN();
 
   Element element;
   element.type = this->type;
   element.kind = Mesh::getKind(this->type);
 
   Communications<Element> & communications =
       this->synchronizer.getCommunications();
 
   Array<UInt>::const_scalar_iterator part = partition.begin();
 
   std::map<UInt, Array<Element> > send_array_per_proc;
   for (UInt lel = 0; lel < nb_local_element; ++lel) {
     UInt nb_send = *part;
     ++part;
 
     element.element = lel;
     element.ghost_type = _not_ghost;
     for (UInt p = 0; p < nb_send; ++p, ++part) {
       UInt proc = *part;
 
       AKANTU_DEBUG(dblAccessory, "Must send : " << element << " to proc "
                    << proc);
       send_array_per_proc[proc].push_back(element);
     }
   }
 
   for (auto & send_schemes : send_array_per_proc) {
-    if (send_schemes.second.getSize() == 0) continue;
+    if (send_schemes.second.size() == 0) continue;
     auto & scheme = communications.createSendScheme(send_schemes.first);
     scheme.append(send_schemes.second);
   }
 
   std::map<UInt, Array<Element> > recv_array_per_proc;
 
   for (UInt gel = 0; gel < nb_ghost_element; ++gel, ++part) {
     UInt proc = *part;
     element.element = gel;
     element.ghost_type = _ghost;
     AKANTU_DEBUG(dblAccessory, "Must recv : " << element << " from proc "
                  << proc);
     recv_array_per_proc[proc].push_back(element);
   }
 
   for (auto & recv_schemes : recv_array_per_proc) {
-    if (recv_schemes.second.getSize() == 0) continue;
+    if (recv_schemes.second.size() == 0) continue;
     auto & scheme = communications.createRecvScheme(recv_schemes.first);
     scheme.append(recv_schemes.second);
   }
 
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/synchronizer/element_synchronizer.cc b/src/synchronizer/element_synchronizer.cc
index 868a30c3b..5bba47f79 100644
--- a/src/synchronizer/element_synchronizer.cc
+++ b/src/synchronizer/element_synchronizer.cc
@@ -1,407 +1,407 @@
 /**
  * @file   element_synchronizer.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Sep 01 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  implementation of a  communicator using a static_communicator for
  * real
  * send/receive
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_synchronizer.hh"
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iostream>
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #if defined(AKANTU_DEBUG_TOOLS)
 #include "aka_debug_tools.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ElementSynchronizer::ElementSynchronizer(Mesh & mesh,
                                          const ID & id, MemoryID memory_id,
                                          bool register_to_event_manager,
                                          EventHandlerPriority event_priority)
     : SynchronizerImpl<Element>(id, memory_id, mesh.getCommunicator()), mesh(mesh),
       prank_to_element("prank_to_element", id, memory_id) {
 
   AKANTU_DEBUG_IN();
 
   if (register_to_event_manager)
     this->mesh.registerEventHandler(*this, event_priority);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementSynchronizer::~ElementSynchronizer() = default;
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::substituteElements(
     const std::map<Element, Element> & old_to_new_elements) {
   // substitute old elements with new ones
 
   auto subsitute =
       [&old_to_new_elements](Communications<Element>::scheme_iterator it,
                              Communications<Element>::scheme_iterator end) {
         std::map<Element, Element>::const_iterator found_element_it;
         std::map<Element, Element>::const_iterator found_element_end =
             old_to_new_elements.end();
 
         for (; it != end; ++it) {
           Array<Element> & list = it->second;
-          for (UInt el = 0; el < list.getSize(); ++el) {
+          for (UInt el = 0; el < list.size(); ++el) {
             found_element_it = old_to_new_elements.find(list(el));
             if (found_element_it != found_element_end)
               list(el) = found_element_it->second;
           }
         }
       };
 
   subsitute(communications.begin_recv_scheme(),
             communications.end_recv_scheme());
   subsitute(communications.begin_send_scheme(),
             communications.end_send_scheme());
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::onElementsChanged(
     const Array<Element> & old_elements_list,
     const Array<Element> & new_elements_list,
     __attribute__((unused)) const ElementTypeMapArray<UInt> & new_numbering,
     __attribute__((unused)) const ChangedElementsEvent & event) {
   // create a map to link old elements to new ones
   std::map<Element, Element> old_to_new_elements;
 
-  for (UInt el = 0; el < old_elements_list.getSize(); ++el) {
+  for (UInt el = 0; el < old_elements_list.size(); ++el) {
     AKANTU_DEBUG_ASSERT(old_to_new_elements.find(old_elements_list(el)) ==
                             old_to_new_elements.end(),
                         "The same element cannot appear twice in the list");
 
     old_to_new_elements[old_elements_list(el)] = new_elements_list(el);
   }
 
   substituteElements(old_to_new_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::onElementsRemoved(
     const Array<Element> & element_to_remove,
     const ElementTypeMapArray<UInt> & new_numbering,
     __attribute__((unused)) const RemovedElementsEvent & event) {
   AKANTU_DEBUG_IN();
   this->removeElements(element_to_remove);
   this->renumberElements(new_numbering);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::buildPrankToElement() {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   prank_to_element.initialize(mesh, _spatial_dimension = spatial_dimension,
                               _element_kind = _ek_not_defined,
                               _with_nb_element = true,
                               _default_value = rank);
 
   /// assign prank to all ghost elements
   Communications<Element>::scheme_iterator recv_it =
       communications.begin_recv_scheme();
   Communications<Element>::scheme_iterator recv_end =
       communications.end_recv_scheme();
   for (; recv_it != recv_end; ++recv_it) {
     auto & recv = recv_it->second;
     auto proc = recv_it->first;
 
     for (auto & element : recv) {
       auto & prank_to_el = prank_to_element(element.type, element.ghost_type);
       prank_to_el(element.element) = proc;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::filterElementsByKind(
     ElementSynchronizer * new_synchronizer, ElementKind kind) {
   AKANTU_DEBUG_IN();
 
   auto filter_list = [&kind](Array<Element> & list, Array<Element> & new_list) {
     list.resize(0);
     new_list.resize(0);
 
     Array<Element> copy = list;
     Array<Element>::const_scalar_iterator it = copy.begin();
     Array<Element>::const_scalar_iterator end = copy.end();
     for (; it != end; ++it) {
       const Element & el = *it;
       if (el.kind == kind) {
         new_list.push_back(el);
       } else {
         list.push_back(el);
       }
     }
   };
 
   Communications<Element>::scheme_iterator recv_it =
       communications.begin_recv_scheme();
   Communications<Element>::scheme_iterator recv_end =
       communications.end_recv_scheme();
   for (; recv_it != recv_end; ++recv_it) {
     UInt proc = recv_it->first;
     Array<Element> & recv = recv_it->second;
     Array<Element> & new_recv =
         new_synchronizer->communications.createRecvScheme(proc);
 
     filter_list(recv, new_recv);
   }
 
   Communications<Element>::scheme_iterator send_it =
       communications.begin_send_scheme();
   Communications<Element>::scheme_iterator send_end =
       communications.end_send_scheme();
   for (; send_it != send_end; ++send_it) {
     UInt proc = send_it->first;
     Array<Element> & send = send_it->second;
     Array<Element> & new_send =
         new_synchronizer->communications.createSendScheme(proc);
 
     filter_list(send, new_send);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::reset() {
   AKANTU_DEBUG_IN();
 
   communications.resetSchemes();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::removeElements(
     const Array<Element> & element_to_remove) {
   AKANTU_DEBUG_IN();
 
   std::vector<CommunicationRequest> send_requests;
   std::map<UInt, Array<UInt>> list_of_elements_per_proc;
 
   auto filter_list = [](const Array<UInt> & keep, Array<Element> & list) {
     Array<Element> new_list;
-    for (UInt e = 0; e < keep.getSize() - 1; ++e) {
+    for (UInt e = 0; e < keep.size() - 1; ++e) {
       Element & el = list(keep(e));
       new_list.push_back(el);
     }
     list.copy(new_list);
   };
 
   // Handling ghost elements
   Communications<Element>::scheme_iterator recv_it =
       communications.begin_recv_scheme();
   Communications<Element>::scheme_iterator recv_end =
       communications.end_recv_scheme();
   for (; recv_it != recv_end; ++recv_it) {
     Array<Element> & recv = recv_it->second;
     UInt proc = recv_it->first;
 
     Array<UInt> & keep_list = list_of_elements_per_proc[proc];
 
     Array<Element>::const_iterator<Element> rem_it = element_to_remove.begin();
     Array<Element>::const_iterator<Element> rem_end = element_to_remove.end();
 
     Array<Element>::const_scalar_iterator it = recv.begin();
     Array<Element>::const_scalar_iterator end = recv.end();
     for (UInt e = 0; it != end; ++it, ++e) {
       const Element & el = *it;
       Array<Element>::const_iterator<Element> pos =
           std::find(rem_it, rem_end, el);
       if (pos == rem_end) {
         keep_list.push_back(e);
       }
     }
 
     keep_list.push_back(UInt(-1)); // To no send empty arrays
 
     Tag tag = Tag::genTag(proc, 0, Tag::_MODIFY_SCHEME, this->hash_id);
     AKANTU_DEBUG_INFO("Sending a message of size "
-                      << keep_list.getSize() << " to proc " << proc << " TAG("
+                      << keep_list.size() << " to proc " << proc << " TAG("
                       << tag << ")");
     send_requests.push_back(this->communicator.asyncSend(keep_list, proc, tag));
 
-    UInt old_size = recv.getSize();
+    UInt old_size = recv.size();
     filter_list(keep_list, recv);
 
     AKANTU_DEBUG_INFO("I had " << old_size << " elements to recv from proc "
-                               << proc << " and " << keep_list.getSize()
-                               << " elements to keep. I have " << recv.getSize()
+                               << proc << " and " << keep_list.size()
+                               << " elements to keep. I have " << recv.size()
                                << " elements left.");
   }
 
   Communications<Element>::scheme_iterator send_it =
       communications.begin_send_scheme();
   Communications<Element>::scheme_iterator send_end =
       communications.end_send_scheme();
   for (; send_it != send_end; ++send_it) {
     UInt proc = send_it->first;
     Array<Element> send = send_it->second;
 
     CommunicationStatus status;
     Tag tag = Tag::genTag(rank, 0, Tag::_MODIFY_SCHEME, this->hash_id);
     AKANTU_DEBUG_INFO("Getting number of elements of proc "
                       << proc << " to keep - TAG(" << tag << ")");
     this->communicator.probe<UInt>(proc, tag, status);
-    Array<UInt> keep_list(status.getSize());
+    Array<UInt> keep_list(status.size());
 
     AKANTU_DEBUG_INFO("Receiving list of elements ("
-                      << keep_list.getSize() << " elements) to keep for proc "
+                      << keep_list.size() << " elements) to keep for proc "
                       << proc << " TAG(" << tag << ")");
     this->communicator.receive(keep_list, proc, tag);
 
-    UInt old_size = send.getSize();
+    UInt old_size = send.size();
     filter_list(keep_list, send);
 
     AKANTU_DEBUG_INFO("I had " << old_size << " elements to send to proc "
-                               << proc << " and " << keep_list.getSize()
-                               << " elements to keep. I have " << send.getSize()
+                               << proc << " and " << keep_list.size()
+                               << " elements to keep. I have " << send.size()
                                << " elements left.");
   }
 
   this->communicator.waitAll(send_requests);
   this->communicator.freeCommunicationRequest(send_requests);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::renumberElements(
     const ElementTypeMapArray<UInt> & new_numbering) {
 
   auto renumber =
       [&new_numbering](Communications<Element>::scheme_iterator it,
                        Communications<Element>::scheme_iterator end) {
         for (; it != end; ++it) {
           Array<Element> & list = it->second;
           Array<Element>::scalar_iterator el_it = list.begin();
           Array<Element>::scalar_iterator el_end = list.end();
           for (; el_it != el_end; ++el_it) {
             Element & el = *el_it;
             el.element = new_numbering(el.type, el.ghost_type)(el.element);
           }
         }
       };
 
   renumber(communications.begin_recv_scheme(),
            communications.end_recv_scheme());
   renumber(communications.begin_send_scheme(),
            communications.end_send_scheme());
 }
 
 /* -------------------------------------------------------------------------- */
 UInt ElementSynchronizer::sanityCheckDataSize(
     const Array<Element> & elements, const SynchronizationTag &) const {
-  return (elements.getSize() * mesh.getSpatialDimension() * sizeof(Real) +
+  return (elements.size() * mesh.getSpatialDimension() * sizeof(Real) +
           sizeof(SynchronizationTag));
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::packSanityCheckData(
     CommunicationDescriptor<Element> & comm_desc) const {
   CommunicationBuffer & buffer = comm_desc.getBuffer();
   buffer << comm_desc.getTag();
 
   Communications<Element>::Scheme & send_element = comm_desc.getScheme();
 
   /// pack barycenters in debug mode
   Array<Element>::const_iterator<Element> bit = send_element.begin();
   Array<Element>::const_iterator<Element> bend = send_element.end();
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
     Vector<Real> barycenter(mesh.getSpatialDimension());
     mesh.getBarycenter(element.element, element.type, barycenter.storage(),
                        element.ghost_type);
     buffer << barycenter;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementSynchronizer::unpackSanityCheckData(
     CommunicationDescriptor<Element> & comm_desc) const {
   CommunicationBuffer & buffer = comm_desc.getBuffer();
   const SynchronizationTag & tag = comm_desc.getTag();
 
   SynchronizationTag t;
   buffer >> t;
 
   AKANTU_DEBUG_ASSERT(
       t == tag, "The tag received does not correspond to the tag expected");
 
   Communications<Element>::Scheme & recv_element = comm_desc.getScheme();
   Array<Element>::const_iterator<Element> bit = recv_element.begin();
   Array<Element>::const_iterator<Element> bend = recv_element.end();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
 
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
 
     Vector<Real> barycenter_loc(spatial_dimension);
     mesh.getBarycenter(element.element, element.type, barycenter_loc.storage(),
                        element.ghost_type);
     Vector<Real> barycenter(spatial_dimension);
     buffer >> barycenter;
     for (UInt i = 0; i < spatial_dimension; ++i) {
       if (!Math::are_float_equal(barycenter_loc(i), barycenter(i)))
         AKANTU_DEBUG_ERROR("Unpacking an unknown value for the element: "
                            << element << "(barycenter[" << i
                            << "] = " << barycenter_loc(i) << " and buffer[" << i
                            << "] = " << barycenter(i) << ") ["
                            << std::abs(barycenter(i) - barycenter_loc(i))
                            << "] - tag: " << tag);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
diff --git a/src/synchronizer/filtered_synchronizer.cc b/src/synchronizer/filtered_synchronizer.cc
index e61910d00..809266d8c 100644
--- a/src/synchronizer/filtered_synchronizer.cc
+++ b/src/synchronizer/filtered_synchronizer.cc
@@ -1,174 +1,174 @@
 /**
  * @file   filtered_synchronizer.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Mathilde Radiguet <mathilde.radiguet@epfl.ch>
  *
  * @date creation: Wed Sep 18 2013
  * @date last modification: Sat Jul 11 2015
  *
  * @brief  filtered synchronizer
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "filtered_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 FilteredSynchronizer::FilteredSynchronizer(Mesh & mesh, SynchronizerID id,
                                            MemoryID memory_id)
     : ElementSynchronizer(mesh, id, memory_id) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 FilteredSynchronizer * FilteredSynchronizer::createFilteredSynchronizer(
     const ElementSynchronizer & d_synchronizer, SynchElementFilter & filter) {
   AKANTU_DEBUG_IN();
 
   FilteredSynchronizer & f_synchronizer = *(new FilteredSynchronizer(
       d_synchronizer.mesh, d_synchronizer.id + ":filtered",
       d_synchronizer.memory_id));
 
   f_synchronizer.setupSynchronizer(d_synchronizer, filter);
 
   AKANTU_DEBUG_OUT();
   return &f_synchronizer;
 }
 
 /* -------------------------------------------------------------------------- */
 void FilteredSynchronizer::setupSynchronizer(
     const ElementSynchronizer & d_synchronizer, SynchElementFilter & filter) {
   AKANTU_DEBUG_IN();
 
   std::vector<CommunicationRequest> isend_requests;
   std::map<UInt, Array<UInt> > keep_element_recv;
 
   auto rs_it = d_synchronizer.communications.begin_recv_scheme();
   auto rs_end = d_synchronizer.communications.end_recv_scheme();
 
   // Filter the recv list and communicate it to the sender processor
   for (; rs_it != rs_end; ++rs_it) {
     const auto & scheme = rs_it->second;
     auto & proc = rs_it->first;
 
     Array<UInt> & keep_element = keep_element_recv[proc];
     auto & new_scheme = this->communications.createRecvScheme(proc);
 
     UInt el_pos = 0;
     for (const auto & element : scheme) {
       if (filter(element)) {
         new_scheme.push_back(element);
         keep_element.push_back(el_pos);
       }
       ++el_pos;
     }
 
     keep_element.push_back(-1); // just to be sure to send
                                 // something due to some shitty
                                 // MPI implementation who do not
                                 // know what to do with a 0 size
                                 // send
 
     Tag tag = Tag::genTag(this->rank, 0, RECEIVE_LIST_TAG);
-    AKANTU_DEBUG_INFO("I have " << keep_element.getSize() - 1
+    AKANTU_DEBUG_INFO("I have " << keep_element.size() - 1
                                 << " elements to still receive from processor "
                                 << proc << " (communication tag : " << tag
                                 << ")");
     isend_requests.push_back(communicator.asyncSend(keep_element, proc, tag));
   }
 
   auto ss_it = d_synchronizer.communications.begin_send_scheme();
   auto ss_end = d_synchronizer.communications.end_send_scheme();
 
   // Receive the element to remove from the sender scheme
   for (; ss_it != ss_end; ++ss_it) {
     const auto & scheme = rs_it->second;
     auto & proc = rs_it->first;
 
     auto & new_scheme = this->communications.createSendScheme(proc);
 
     Tag tag = Tag::genTag(proc, 0, RECEIVE_LIST_TAG);
     AKANTU_DEBUG_INFO("Waiting list of elements to keep from processor "
                       << proc << " (communication tag : " << tag << ")");
 
     CommunicationStatus status;
     communicator.probe<UInt>(proc, tag, status);
 
-    Array<UInt> keep_element(status.getSize());
+    Array<UInt> keep_element(status.size());
 
     AKANTU_DEBUG_INFO("I have "
-                      << keep_element.getSize() - 1
+                      << keep_element.size() - 1
                       << " elements to keep in my send list to processor "
                       << proc << " (communication tag : " << tag << ")");
 
     communicator.receive(keep_element, proc, tag);
 
-    for (UInt i = 0; i < keep_element.getSize() - 1; ++i) {
+    for (UInt i = 0; i < keep_element.size() - 1; ++i) {
       new_scheme.push_back(scheme(keep_element(i)));
     }
   }
 
   communicator.waitAll(isend_requests);
   communicator.freeCommunicationRequest(isend_requests);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void FilteredSynchronizer::updateElementList(
     Array<Element> * source_elements, Array<Element> * destination_elements,
     SynchElementFilter & filter) {
   AKANTU_DEBUG_IN();
 
   // loop over procs
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p == this->rank)
       continue;
 
     // access the element for this proc
     const Array<Element> & unfiltered_elements = source_elements[p];
     Array<Element> & filtered_elements = destination_elements[p];
 
     // iterator to loop over all source elements
     Array<Element>::const_iterator<Element> it = unfiltered_elements.begin();
     Array<Element>::const_iterator<Element> end = unfiltered_elements.end();
 
     // if filter accepts this element, push it into the destination elements
     for (; it != end; ++it) {
       const Element & element = *it;
       if (filter(element)) {
         filtered_elements.push_back(element);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
diff --git a/src/synchronizer/grid_synchronizer.cc b/src/synchronizer/grid_synchronizer.cc
index 1959db5e8..cd521a566 100644
--- a/src/synchronizer/grid_synchronizer.cc
+++ b/src/synchronizer/grid_synchronizer.cc
@@ -1,538 +1,538 @@
 /**
  * @file   grid_synchronizer.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Oct 03 2011
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  implementation of the grid synchronizer
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "grid_synchronizer.hh"
 #include "aka_grid_dynamic.hh"
 #include "fe_engine.hh"
 #include "integration_point.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "static_communicator.hh"
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class E>
 void GridSynchronizer::createGridSynchronizer(
     const SpatialGrid<E> & grid) {
   AKANTU_DEBUG_IN();
 
   const StaticCommunicator & comm = this->mesh.getCommunicator();
   UInt nb_proc = comm.getNbProc();
   UInt my_rank = comm.whoAmI();
 
   if (nb_proc == 1) return;
 
   UInt spatial_dimension = this->mesh.getSpatialDimension();
 
   Tensor3<Real> bounding_boxes(spatial_dimension, 2, nb_proc);
   Matrix<Real> my_bounding_box = bounding_boxes(my_rank);
 
   const Vector<Real> & lower = grid.getLowerBounds();
   const Vector<Real> & upper = grid.getUpperBounds();
   const Vector<Real> & spacing = grid.getSpacing();
 
   Vector<Real>(my_bounding_box(0)) = lower - spacing;
   Vector<Real>(my_bounding_box(1)) = upper + spacing;
 
   AKANTU_DEBUG_INFO(
       "Exchange of bounding box to detect the overlapping regions.");
 
   comm.allGather(bounding_boxes);
 
   std::vector<bool> intersects_proc(nb_proc);
   std::fill(intersects_proc.begin(), intersects_proc.end(), true);
 
   Matrix<Int> first_cells(spatial_dimension, nb_proc);
   Matrix<Int> last_cells(spatial_dimension, nb_proc);
 
   std::map<UInt, ElementTypeMapArray<UInt>> element_per_proc;
 
   // check the overlapping between my box and the one from other processors
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p == my_rank)
       continue;
 
     Matrix<Real> proc_bounding_box = bounding_boxes(p);
 
     bool intersects = false;
     Vector<Int> first_cell_p = first_cells(p);
     Vector<Int> last_cell_p = last_cells(p);
     for (UInt s = 0; s < spatial_dimension; ++s) {
       // check overlapping of grid
       intersects =
           Math::intersects(my_bounding_box(s, 0), my_bounding_box(s, 1),
                            proc_bounding_box(s, 0), proc_bounding_box(s, 1));
 
       intersects_proc[p] = intersects_proc[p] & intersects;
 
       if (intersects) {
         AKANTU_DEBUG_INFO("I intersects with processor "
                           << p << " in direction " << s);
 
         // is point 1 of proc p in the dimension s in the range ?
         bool point1 =
             Math::is_in_range(proc_bounding_box(s, 0), my_bounding_box(s, 0),
                               my_bounding_box(s, 1));
 
         // is point 2 of proc p in the dimension s in the range ?
         bool point2 =
             Math::is_in_range(proc_bounding_box(s, 1), my_bounding_box(s, 0),
                               my_bounding_box(s, 1));
 
         Real start = 0.;
         Real end = 0.;
 
         if (point1 && !point2) {
           /* |-----------|         my_bounding_box(i)
            *       |-----------|   proc_bounding_box(i)
            *       1           2
            */
           start = proc_bounding_box(s, 0);
           end = my_bounding_box(s, 1);
 
           AKANTU_DEBUG_INFO("Intersection scheme 1 in direction "
                             << s << " with processor " << p << " [" << start
                             << ", " << end << "]");
         } else if (point1 && point2) {
           /* |-----------------|   my_bounding_box(i)
            *   |-----------|       proc_bounding_box(i)
            *   1           2
            */
           start = proc_bounding_box(s, 0);
           end = proc_bounding_box(s, 1);
 
           AKANTU_DEBUG_INFO("Intersection scheme 2 in direction "
                             << s << " with processor " << p << " [" << start
                             << ", " << end << "]");
         } else if (!point1 && point2) {
           /*       |-----------|   my_bounding_box(i)
            * |-----------|         proc_bounding_box(i)
            * 1           2
            */
           start = my_bounding_box(s, 0);
           end = proc_bounding_box(s, 1);
 
           AKANTU_DEBUG_INFO("Intersection scheme 3 in direction "
                             << s << " with processor " << p << " [" << start
                             << ", " << end << "]");
         } else {
           /*   |-----------|       my_bounding_box(i)
            * |-----------------|   proc_bounding_box(i)
            * 1                 2
            */
           start = my_bounding_box(s, 0);
           end = my_bounding_box(s, 1);
 
           AKANTU_DEBUG_INFO("Intersection scheme 4 in direction "
                             << s << " with processor " << p << " [" << start
                             << ", " << end << "]");
         }
 
         first_cell_p(s) = grid.getCellID(start, s);
         last_cell_p(s) = grid.getCellID(end, s);
       }
     }
 
     // create the list of cells in the overlapping
     using CellID = typename SpatialGrid<E>::CellID;
 
     std::vector<CellID> cell_ids;
 
     if (intersects_proc[p]) {
       AKANTU_DEBUG_INFO("I intersects with processor " << p);
 
       CellID cell_id(spatial_dimension);
 
       // for (UInt i = 0; i < spatial_dimension; ++i) {
       //   if(first_cell_p[i] != 0) --first_cell_p[i];
       //   if(last_cell_p[i] != 0) ++last_cell_p[i];
       // }
 
       for (Int fd = first_cell_p(0); fd <= last_cell_p(0); ++fd) {
         cell_id.setID(0, fd);
         if (spatial_dimension == 1) {
           cell_ids.push_back(cell_id);
         } else {
           for (Int sd = first_cell_p(1); sd <= last_cell_p(1); ++sd) {
             cell_id.setID(1, sd);
             if (spatial_dimension == 2) {
               cell_ids.push_back(cell_id);
             } else {
               for (Int ld = first_cell_p(2); ld <= last_cell_p(2); ++ld) {
                 cell_id.setID(2, ld);
                 cell_ids.push_back(cell_id);
               }
             }
           }
         }
       }
 
       // get the list of elements in the cells of the overlapping
       std::set<Element> to_send;
       for (auto & cur_cell_id : cell_ids) {
         auto & cell = grid.getCell(cur_cell_id);
         for (auto & element : cell) {
           to_send.insert(element);
         }
       }
 
       AKANTU_DEBUG_INFO("I have prepared " << to_send.size()
                                            << " elements to send to processor "
                                            << p);
       auto & scheme = this->getCommunications().createSendScheme(p);
       std::stringstream sstr;
       sstr << "element_per_proc_" << p;
       element_per_proc.emplace(
           std::piecewise_construct, std::forward_as_tuple(p),
           std::forward_as_tuple(sstr.str(), id, memory_id));
 
       ElementTypeMapArray<UInt> & elempproc = element_per_proc[p];
 
       for (auto elem : to_send) {
         ElementType type = elem.type;
         UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
         // /!\ this part must be slow due to the access in the
         // ElementTypeMapArray<UInt>
         if (!elempproc.exists(type, _not_ghost))
           elempproc.alloc(0, nb_nodes_per_element, type, _not_ghost);
 
         Vector<UInt> global_connect(nb_nodes_per_element);
         Vector<UInt> local_connect = mesh.getConnectivity(type).begin(
             nb_nodes_per_element)[elem.element];
 
         for (UInt i = 0; i < nb_nodes_per_element; ++i) {
           global_connect(i) = mesh.getNodeGlobalId(local_connect(i));
           AKANTU_DEBUG_ASSERT(
               global_connect(i) < mesh.getNbGlobalNodes(),
               "This global node send in the connectivity does not seem correct "
                   << global_connect(i) << " corresponding to "
                   << local_connect(i) << " from element " << elem.element);
         }
 
         elempproc(type).push_back(global_connect);
         scheme.push_back(elem);
       }
     }
   }
 
   AKANTU_DEBUG_INFO("I have finished to compute intersection,"
                     << " no it's time to communicate with my neighbors");
 
   /**
    * Sending loop, sends the connectivity asynchronously to all concerned proc
    */
   std::vector<CommunicationRequest> isend_requests;
   Tensor3<UInt> space(2, _max_element_type, nb_proc);
 
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p == my_rank)
       continue;
 
     if (not intersects_proc[p])
       continue;
 
     Matrix<UInt> info_proc = space(p);
     auto & elempproc = element_per_proc[p];
     UInt count = 0;
 
     for (auto type : elempproc.elementTypes(_all_dimensions, _not_ghost)) {
       Array<UInt> & conn = elempproc(type, _not_ghost);
 
       Vector<UInt> info = info_proc((UInt)type);
       info[0] = (UInt)type;
-      info[1] = conn.getSize() * conn.getNbComponent();
+      info[1] = conn.size() * conn.getNbComponent();
 
       AKANTU_DEBUG_INFO(
-          "I have " << conn.getSize() << " elements of type " << type
+          "I have " << conn.size() << " elements of type " << type
                     << " to send to processor " << p << " (communication tag : "
                     << Tag::genTag(my_rank, count, DATA_TAG) << ")");
 
       isend_requests.push_back(
           comm.asyncSend(info, p, Tag::genTag(my_rank, count, SIZE_TAG)));
 
       if (info[1] != 0)
         isend_requests.push_back(comm.asyncSend<UInt>(
             conn, p, Tag::genTag(my_rank, count, DATA_TAG)));
 
       ++count;
     }
 
     Vector<UInt> info = info_proc((UInt)_not_defined);
     info[0] = (UInt)_not_defined;
     info[1] = 0;
     isend_requests.push_back(
         comm.asyncSend(info, p, Tag::genTag(my_rank, count, SIZE_TAG)));
   }
 
   /**
    * Receives the connectivity and store them in the ghosts elements
    */
   auto & global_nodes_ids = const_cast<Array<UInt> &>(mesh.getGlobalNodesIds());
   auto & nodes_type = const_cast<Array<NodeType> &>(
       const_cast<const Mesh &>(mesh).getNodesType());
 
   std::vector<CommunicationRequest> isend_nodes_requests;
   Vector<UInt> nb_nodes_to_recv(nb_proc);
 
   UInt nb_total_nodes_to_recv = 0;
-  UInt nb_current_nodes = global_nodes_ids.getSize();
+  UInt nb_current_nodes = global_nodes_ids.size();
 
   NewNodesEvent new_nodes;
   NewElementsEvent new_elements;
 
   std::map<UInt, std::vector<UInt>> ask_nodes_per_proc;
 
   for (UInt p = 0; p < nb_proc; ++p) {
     nb_nodes_to_recv(p) = 0;
     if (p == my_rank)
       continue;
 
     if (!intersects_proc[p])
       continue;
 
     auto & scheme = this->getCommunications().createRecvScheme(p);
 
     ask_nodes_per_proc.emplace(
         std::piecewise_construct, std::forward_as_tuple(p),
         std::forward_as_tuple(0));
 
     auto & ask_nodes = ask_nodes_per_proc[p];
     UInt count = 0;
 
     ElementType type = _not_defined;
     do {
       Vector<UInt> info(2);
       comm.receive(info, p, Tag::genTag(p, count, SIZE_TAG));
 
       type = (ElementType) info[0];
 
       if (type != _not_defined) {
         UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
         UInt nb_element = info[1] / nb_nodes_per_element;
 
         Array<UInt> tmp_conn(nb_element, nb_nodes_per_element);
         tmp_conn.clear();
         if (info[1] != 0)
           comm.receive<UInt>(tmp_conn, p, Tag::genTag(p, count, DATA_TAG));
 
         AKANTU_DEBUG_INFO("I will receive "
                           << nb_element << " elements of type "
                           << ElementType(info[0]) << " from processor " << p
                           << " (communication tag : "
                           << Tag::genTag(p, count, DATA_TAG) << ")");
 
         auto & ghost_connectivity =
             const_cast<Array<UInt> &>(mesh.getConnectivity(type, _ghost));
 
-        UInt nb_ghost_element = ghost_connectivity.getSize();
+        UInt nb_ghost_element = ghost_connectivity.size();
         Element element(type, 0, _ghost);
 
         Vector<UInt> conn(nb_nodes_per_element);
         for (UInt el = 0; el < nb_element; ++el) {
           UInt nb_node_to_ask_for_elem = 0;
 
           for (UInt n = 0; n < nb_nodes_per_element; ++n) {
             UInt gn = tmp_conn(el, n);
             UInt ln = global_nodes_ids.find(gn);
 
             AKANTU_DEBUG_ASSERT(gn < mesh.getNbGlobalNodes(),
                                 "This global node seems not correct "
                                     << gn << " from element " << el << " node "
                                     << n);
 
             if (ln == UInt(-1)) {
               global_nodes_ids.push_back(gn);
               nodes_type.push_back(_nt_pure_gost); // pure ghost node
               ln = nb_current_nodes;
 
               new_nodes.getList().push_back(ln);
               ++nb_current_nodes;
               ask_nodes.push_back(gn);
               ++nb_node_to_ask_for_elem;
             }
             conn[n] = ln;
           }
 
           // all the nodes are already known locally, the element should
           // already exists
           auto c = UInt(-1);
           if (nb_node_to_ask_for_elem == 0) {
             c = ghost_connectivity.find(conn);
             element.element = c;
           }
 
           if (c == UInt(-1)) {
             element.element = nb_ghost_element;
             ++nb_ghost_element;
             ghost_connectivity.push_back(conn);
             new_elements.getList().push_back(element);
           }
 
           scheme.push_back(element);
         }
       }
       count++;
     } while (type != _not_defined);
 
     AKANTU_DEBUG_INFO("I have "
                       << ask_nodes.size()
                       << " missing nodes for elements coming from processor "
                       << p << " (communication tag : "
                       << Tag::genTag(my_rank, 0, ASK_NODES_TAG) << ")");
 
     ask_nodes.push_back(UInt(-1));
 
     isend_nodes_requests.push_back(
         comm.asyncSend(ask_nodes, p, Tag::genTag(my_rank, 0, ASK_NODES_TAG)));
     nb_nodes_to_recv(p) = ask_nodes.size() - 1;
     nb_total_nodes_to_recv += nb_nodes_to_recv(p);
   }
 
   comm.waitAll(isend_requests);
   comm.freeCommunicationRequest(isend_requests);
 
   /**
    * Sends requested nodes to proc
    */
   auto & nodes = const_cast<Array<Real> &>(mesh.getNodes());
-  UInt nb_nodes = nodes.getSize();
+  UInt nb_nodes = nodes.size();
 
   std::vector<CommunicationRequest> isend_coordinates_requests;
   std::map<UInt, Array<Real>> nodes_to_send_per_proc;
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p == my_rank || !intersects_proc[p])
       continue;
 
     Array<UInt> asked_nodes;
     CommunicationStatus status;
     AKANTU_DEBUG_INFO("Waiting list of nodes to send to processor "
                       << p << "(communication tag : "
                       << Tag::genTag(p, 0, ASK_NODES_TAG) << ")");
 
     comm.probe<UInt>(p, Tag::genTag(p, 0, ASK_NODES_TAG), status);
-    UInt nb_nodes_to_send = status.getSize();
+    UInt nb_nodes_to_send = status.size();
     asked_nodes.resize(nb_nodes_to_send);
 
     AKANTU_DEBUG_INFO("I have " << nb_nodes_to_send - 1
                                 << " nodes to send to processor " << p
                                 << " (communication tag : "
                                 << Tag::genTag(p, 0, ASK_NODES_TAG) << ")");
 
     AKANTU_DEBUG_INFO("Getting list of nodes to send to processor "
                       << p << " (communication tag : "
                       << Tag::genTag(p, 0, ASK_NODES_TAG) << ")");
 
     comm.receive(asked_nodes, p, Tag::genTag(p, 0, ASK_NODES_TAG));
 
     nb_nodes_to_send--;
     asked_nodes.resize(nb_nodes_to_send);
 
     nodes_to_send_per_proc.emplace(
         std::piecewise_construct, std::forward_as_tuple(p),
         std::forward_as_tuple(0, spatial_dimension));
 
     auto & nodes_to_send = nodes_to_send_per_proc[p];
     auto node_it = nodes.begin(spatial_dimension);
 
     for (UInt n = 0; n < nb_nodes_to_send; ++n) {
       UInt ln = global_nodes_ids.find(asked_nodes(n));
       AKANTU_DEBUG_ASSERT(ln != UInt(-1), "The node ["
                                               << asked_nodes(n)
                                               << "] requested by proc " << p
                                               << " was not found locally!");
       nodes_to_send.push_back(node_it + ln);
     }
 
     if (nb_nodes_to_send != 0) {
       AKANTU_DEBUG_INFO("Sending the "
                         << nb_nodes_to_send << " nodes to processor " << p
                         << " (communication tag : "
                         << Tag::genTag(p, 0, SEND_NODES_TAG) << ")");
 
       isend_coordinates_requests.push_back(comm.asyncSend(
           nodes_to_send, p, Tag::genTag(my_rank, 0, SEND_NODES_TAG)));
     }
 #if not defined(AKANTU_NDEBUG)
     else {
       AKANTU_DEBUG_INFO("No nodes to send to processor " << p);
     }
 #endif
   }
 
   comm.waitAll(isend_nodes_requests);
   comm.freeCommunicationRequest(isend_nodes_requests);
 
   nodes.resize(nb_total_nodes_to_recv + nb_nodes);
   for (UInt p = 0; p < nb_proc; ++p) {
     if ((p != my_rank) && (nb_nodes_to_recv(p) > 0)) {
       AKANTU_DEBUG_INFO("Receiving the "
                         << nb_nodes_to_recv(p) << " nodes from processor " << p
                         << " (communication tag : "
                         << Tag::genTag(p, 0, SEND_NODES_TAG) << ")");
 
       Vector<Real> nodes_to_recv(nodes.storage() + nb_nodes * spatial_dimension,
                                  nb_nodes_to_recv(p) * spatial_dimension);
       comm.receive(nodes_to_recv, p, Tag::genTag(p, 0, SEND_NODES_TAG));
       nb_nodes += nb_nodes_to_recv(p);
     }
 #if not defined(AKANTU_NDEBUG)
     else {
       if (p != my_rank) {
         AKANTU_DEBUG_INFO("No nodes to receive from processor " << p);
       }
     }
 #endif
   }
 
   comm.waitAll(isend_coordinates_requests);
   comm.freeCommunicationRequest(isend_coordinates_requests);
 
   mesh.sendEvent(new_nodes);
   mesh.sendEvent(new_elements);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template void GridSynchronizer::createGridSynchronizer<IntegrationPoint>(
     const SpatialGrid<IntegrationPoint> & grid);
 
 template void GridSynchronizer::createGridSynchronizer<Element>(
     const SpatialGrid<Element> & grid);
 
 } // namespace akantu
diff --git a/src/synchronizer/master_element_info_per_processor.cc b/src/synchronizer/master_element_info_per_processor.cc
index 15742b202..194c058d6 100644
--- a/src/synchronizer/master_element_info_per_processor.cc
+++ b/src/synchronizer/master_element_info_per_processor.cc
@@ -1,482 +1,482 @@
 /**
  * @file   master_element_info_per_processor.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Mar 11 14:57:13 2016
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "mesh_iterators.hh"
 #include "element_group.hh"
 #include "element_info_per_processor.hh"
 #include "element_synchronizer.hh"
 #include "mesh_utils.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iostream>
 #include <map>
 #include <tuple>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 MasterElementInfoPerProc::MasterElementInfoPerProc(
     ElementSynchronizer & synchronizer, UInt message_cnt, UInt root,
     ElementType type, const MeshPartition & partition)
     : ElementInfoPerProc(synchronizer, message_cnt, root, type),
       partition(partition), all_nb_local_element(nb_proc, 0),
       all_nb_ghost_element(nb_proc, 0), all_nb_element_to_send(nb_proc, 0) {
   Vector<UInt> size(5);
   size(0) = (UInt)type;
 
   if (type != _not_defined) {
     nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     nb_element = mesh.getNbElement(type);
     const Array<UInt> & partition_num =
         this->partition.getPartition(this->type, _not_ghost);
     const CSR<UInt> & ghost_partition =
         this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
     for (UInt el = 0; el < nb_element; ++el) {
       this->all_nb_local_element[partition_num(el)]++;
       for (CSR<UInt>::const_iterator part = ghost_partition.begin(el);
            part != ghost_partition.end(el); ++part) {
         this->all_nb_ghost_element[*part]++;
       }
       this->all_nb_element_to_send[partition_num(el)] +=
           ghost_partition.getNbCols(el) + 1;
     }
 
     /// tag info
     std::vector<std::string> tag_names;
     this->getMeshData().getTagNames(tag_names, type);
     this->nb_tags = tag_names.size();
 
     size(4) = nb_tags;
 
     for (UInt p = 0; p < nb_proc; ++p) {
       if (p != root) {
         size(1) = this->all_nb_local_element[p];
         size(2) = this->all_nb_ghost_element[p];
         size(3) = this->all_nb_element_to_send[p];
         AKANTU_DEBUG_INFO(
             "Sending connectivities informations to proc "
             << p << " TAG("
             << Tag::genTag(this->rank, this->message_count, Tag::_SIZES)
             << ")");
         comm.send(size, p,
                   Tag::genTag(this->rank, this->message_count, Tag::_SIZES));
       } else {
         this->nb_local_element = this->all_nb_local_element[p];
         this->nb_ghost_element = this->all_nb_ghost_element[p];
       }
     }
   } else {
     for (UInt p = 0; p < this->nb_proc; ++p) {
       if (p != this->root) {
         AKANTU_DEBUG_INFO(
             "Sending empty connectivities informations to proc "
             << p << " TAG("
             << Tag::genTag(this->rank, this->message_count, Tag::_SIZES)
             << ")");
         comm.send(size, p,
                   Tag::genTag(this->rank, this->message_count, Tag::_SIZES));
       }
     }
   }
 }
 
 /* ------------------------------------------------------------------------ */
 void MasterElementInfoPerProc::synchronizeConnectivities() {
   const Array<UInt> & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const CSR<UInt> & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   std::vector<Array<UInt>> buffers(this->nb_proc);
 
   auto conn_it = this->mesh.getConnectivity(this->type, _not_ghost)
                      .begin(this->nb_nodes_per_element);
   auto conn_end = this->mesh.getConnectivity(this->type, _not_ghost)
                       .end(this->nb_nodes_per_element);
 
   /// copying the local connectivity
   auto part_it = partition_num.begin();
   for (; conn_it != conn_end; ++conn_it, ++part_it) {
     const auto & conn = *conn_it;
     for (UInt i = 0; i < conn.size(); ++i) {
       buffers[*part_it].push_back(conn[i]);
     }
   }
 
   /// copying the connectivity of ghost element
   conn_it = this->mesh.getConnectivity(this->type, _not_ghost)
                 .begin(this->nb_nodes_per_element);
   for (UInt el = 0; conn_it != conn_end; ++el, ++conn_it) {
     for (auto part = ghost_partition.begin(el); part != ghost_partition.end(el);
          ++part) {
       UInt proc = *part;
       const Vector<UInt> & conn = *conn_it;
       for (UInt i = 0; i < conn.size(); ++i) {
         buffers[proc].push_back(conn[i]);
       }
     }
   }
 
 #ifndef AKANTU_NDEBUG
   for (UInt p = 0; p < this->nb_proc; ++p) {
     UInt size = this->nb_nodes_per_element *
                 (this->all_nb_local_element[p] + this->all_nb_ghost_element[p]);
     AKANTU_DEBUG_ASSERT(
-        buffers[p].getSize() == size,
+        buffers[p].size() == size,
         "The connectivity data packed in the buffer are not correct");
   }
 #endif
 
   /// send all connectivity and ghost information to all processors
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p != this->root) {
       AKANTU_DEBUG_INFO(
           "Sending connectivities to proc "
           << p << " TAG("
           << Tag::genTag(this->rank, this->message_count, Tag::_CONNECTIVITY)
           << ")");
       requests.push_back(comm.asyncSend(
           buffers[p], p,
           Tag::genTag(this->rank, this->message_count, Tag::_CONNECTIVITY)));
     }
   }
 
   Array<UInt> & old_nodes = this->getNodesGlobalIds();
 
   /// create the renumbered connectivity
   AKANTU_DEBUG_INFO("Renumbering local connectivities");
   MeshUtils::renumberMeshNodes(mesh, buffers[root], all_nb_local_element[root],
                                all_nb_ghost_element[root], type, old_nodes);
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
 }
 
 /* ------------------------------------------------------------------------ */
 void MasterElementInfoPerProc::synchronizePartitions() {
   const Array<UInt> & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const CSR<UInt> & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   std::vector<Array<UInt>> buffers(this->partition.getNbPartition());
 
   /// splitting the partition information to send them to processors
   Vector<UInt> count_by_proc(nb_proc, 0);
   for (UInt el = 0; el < nb_element; ++el) {
     UInt proc = partition_num(el);
     buffers[proc].push_back(ghost_partition.getNbCols(el));
 
     UInt i(0);
     for (CSR<UInt>::const_iterator part = ghost_partition.begin(el);
          part != ghost_partition.end(el); ++part, ++i) {
       buffers[proc].push_back(*part);
     }
   }
 
   for (UInt el = 0; el < nb_element; ++el) {
     UInt i(0);
     for (CSR<UInt>::const_iterator part = ghost_partition.begin(el);
          part != ghost_partition.end(el); ++part, ++i) {
       buffers[*part].push_back(partition_num(el));
     }
   }
 
 #ifndef AKANTU_NDEBUG
   for (UInt p = 0; p < this->nb_proc; ++p) {
     AKANTU_DEBUG_ASSERT(
-        buffers[p].getSize() ==
+        buffers[p].size() ==
             (this->all_nb_ghost_element[p] + this->all_nb_element_to_send[p]),
         "Data stored in the buffer are most probably wrong");
   }
 #endif
 
   std::vector<CommunicationRequest> requests;
   /// last data to compute the communication scheme
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p != this->root) {
       AKANTU_DEBUG_INFO(
           "Sending partition informations to proc "
           << p << " TAG("
           << Tag::genTag(this->rank, this->message_count, Tag::_PARTITIONS)
           << ")");
       requests.push_back(comm.asyncSend(
           buffers[p], p,
           Tag::genTag(this->rank, this->message_count, Tag::_PARTITIONS)));
     }
   }
 
   if (Mesh::getSpatialDimension(this->type) ==
       this->mesh.getSpatialDimension()) {
     AKANTU_DEBUG_INFO("Creating communications scheme");
     this->fillCommunicationScheme(buffers[this->rank]);
   }
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterElementInfoPerProc::synchronizeTags() {
   AKANTU_DEBUG_IN();
 
   if (this->nb_tags == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
   UInt mesh_data_sizes_buffer_length;
   MeshData & mesh_data = this->getMeshData();
 
   /// tag info
   std::vector<std::string> tag_names;
   mesh_data.getTagNames(tag_names, type);
   // Make sure the tags are sorted (or at least not in random order),
   // because they come from a map !!
   std::sort(tag_names.begin(), tag_names.end());
 
   // Sending information about the tags in mesh_data: name, data type and
   // number of components of the underlying array associated to the current
   // type
   DynamicCommunicationBuffer mesh_data_sizes_buffer;
   std::vector<std::string>::const_iterator names_it = tag_names.begin();
   std::vector<std::string>::const_iterator names_end = tag_names.end();
   for (; names_it != names_end; ++names_it) {
     mesh_data_sizes_buffer << *names_it;
     mesh_data_sizes_buffer << mesh_data.getTypeCode(*names_it);
     mesh_data_sizes_buffer << mesh_data.getNbComponent(*names_it, type);
   }
 
-  mesh_data_sizes_buffer_length = mesh_data_sizes_buffer.getSize();
+  mesh_data_sizes_buffer_length = mesh_data_sizes_buffer.size();
   AKANTU_DEBUG_INFO(
       "Broadcasting the size of the information about the mesh data tags: ("
       << mesh_data_sizes_buffer_length << ").");
   comm.broadcast(mesh_data_sizes_buffer_length, root);
   AKANTU_DEBUG_INFO(
       "Broadcasting the information about the mesh data tags, addr "
       << (void *)mesh_data_sizes_buffer.storage());
 
   if (mesh_data_sizes_buffer_length != 0)
     comm.broadcast(mesh_data_sizes_buffer, root);
 
   if (mesh_data_sizes_buffer_length != 0) {
     // Sending the actual data to each processor
     DynamicCommunicationBuffer * buffers =
         new DynamicCommunicationBuffer[nb_proc];
     std::vector<std::string>::const_iterator names_it = tag_names.begin();
     std::vector<std::string>::const_iterator names_end = tag_names.end();
 
     // Loop over each tag for the current type
     for (; names_it != names_end; ++names_it) {
       // Type code of the current tag (i.e. the tag named *names_it)
       this->fillTagBuffer(buffers, *names_it);
     }
 
     std::vector<CommunicationRequest> requests;
     for (UInt p = 0; p < nb_proc; ++p) {
       if (p != root) {
         AKANTU_DEBUG_INFO("Sending "
-                          << buffers[p].getSize()
+                          << buffers[p].size()
                           << " bytes of mesh data to proc " << p << " TAG("
                           << Tag::genTag(this->rank, this->message_count,
                                          Tag::_MESH_DATA)
                           << ")");
 
         requests.push_back(comm.asyncSend(
             buffers[p], p,
             Tag::genTag(this->rank, this->message_count, Tag::_MESH_DATA)));
       }
     }
 
     names_it = tag_names.begin();
     // Loop over each tag for the current type
     for (; names_it != names_end; ++names_it) {
       // Reinitializing the mesh data on the master
       this->fillMeshData(buffers[root], *names_it,
                          mesh_data.getTypeCode(*names_it),
                          mesh_data.getNbComponent(*names_it, type));
     }
 
     comm.waitAll(requests);
     comm.freeCommunicationRequest(requests);
     requests.clear();
     delete[] buffers;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void MasterElementInfoPerProc::fillTagBufferTemplated(
     DynamicCommunicationBuffer * buffers, const std::string & tag_name) {
   MeshData & mesh_data = this->getMeshData();
 
   const Array<T> & data = mesh_data.getElementalDataArray<T>(tag_name, type);
   const Array<UInt> & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const CSR<UInt> & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   // Not possible to use the iterator because it potentially triggers the
   // creation of complex
   // type templates (such as akantu::Vector< std::vector<Element> > which don't
   // implement the right interface
   // (e.g. operator<< in that case).
   // typename Array<T>::template const_iterator< Vector<T> > data_it  =
   // data.begin(data.getNbComponent());
   // typename Array<T>::template const_iterator< Vector<T> > data_end =
   // data.end(data.getNbComponent());
 
   const T * data_it = data.storage();
-  const T * data_end = data.storage() + data.getSize() * data.getNbComponent();
+  const T * data_end = data.storage() + data.size() * data.getNbComponent();
   const UInt * part = partition_num.storage();
 
   /// copying the data, element by element
   for (; data_it != data_end; ++part) {
     for (UInt j(0); j < data.getNbComponent(); ++j, ++data_it) {
       buffers[*part] << *data_it;
     }
   }
 
   data_it = data.storage();
   /// copying the data for the ghost element
   for (UInt el(0); data_it != data_end;
        data_it += data.getNbComponent(), ++el) {
     CSR<UInt>::const_iterator it = ghost_partition.begin(el);
     CSR<UInt>::const_iterator end = ghost_partition.end(el);
     for (; it != end; ++it) {
       UInt proc = *it;
       for (UInt j(0); j < data.getNbComponent(); ++j) {
         buffers[proc] << data_it[j];
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterElementInfoPerProc::fillTagBuffer(
     DynamicCommunicationBuffer * buffers, const std::string & tag_name) {
   MeshData & mesh_data = this->getMeshData();
 
 #define AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA(r, extra_param, elem)          \
   case BOOST_PP_TUPLE_ELEM(2, 0, elem): {                                      \
     this->fillTagBufferTemplated<BOOST_PP_TUPLE_ELEM(2, 1, elem)>(buffers,     \
                                                                   tag_name);   \
     break;                                                                     \
   }
 
   MeshDataTypeCode data_type_code = mesh_data.getTypeCode(tag_name);
   switch (data_type_code) {
     BOOST_PP_SEQ_FOR_EACH(AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA, ,
                           AKANTU_MESH_DATA_TYPES)
   default:
     AKANTU_DEBUG_ERROR("Could not obtain the type of tag" << tag_name << "!");
     break;
   }
 #undef AKANTU_DISTRIBUTED_SYNHRONIZER_TAG_DATA
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterElementInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   DynamicCommunicationBuffer * buffers =
       new DynamicCommunicationBuffer[nb_proc];
 
   using ElementToGroup = std::vector<std::vector<std::string>>;
   ElementToGroup element_to_group;
   element_to_group.resize(nb_element);
 
   for (auto & eg : ElementGroupsIterable(mesh)) {
     const std::string & name = eg.getName();
 
     for (const auto & element : eg.getElements(type, _not_ghost)) {
       element_to_group[element].push_back(name);
     }
 
     auto eit = eg.begin(type, _not_ghost);
     if (eit != eg.end(type, _not_ghost))
       const_cast<Array<UInt> &>(eg.getElements(type)).empty();
   }
 
   const auto & partition_num =
       this->partition.getPartition(this->type, _not_ghost);
   const auto & ghost_partition =
       this->partition.getGhostPartitionCSR()(this->type, _not_ghost);
 
   /// copying the data, element by element
   ElementToGroup::const_iterator data_it = element_to_group.begin();
   ElementToGroup::const_iterator data_end = element_to_group.end();
   for (auto pair : zip(partition_num, element_to_group)) {
     buffers[std::get<0>(pair)] << std::get<1>(pair);
   }
 
   data_it = element_to_group.begin();
   /// copying the data for the ghost element
   for (UInt el(0); data_it != data_end; ++data_it, ++el) {
     CSR<UInt>::const_iterator it = ghost_partition.begin(el);
     CSR<UInt>::const_iterator end = ghost_partition.end(el);
     for (; it != end; ++it) {
       UInt proc = *it;
       buffers[proc] << *data_it;
     }
   }
 
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < this->nb_proc; ++p) {
     if (p == this->rank)
       continue;
     AKANTU_DEBUG_INFO("Sending element groups to proc "
                       << p << " TAG("
                       << Tag::genTag(this->rank, p, Tag::_ELEMENT_GROUP)
                       << ")");
     requests.push_back(comm.asyncSend(
         buffers[p], p, Tag::genTag(this->rank, p, Tag::_ELEMENT_GROUP)));
   }
 
   this->fillElementGroupsFromBuffer(buffers[this->rank]);
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
   requests.clear();
   delete[] buffers;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/synchronizer/node_info_per_processor.cc b/src/synchronizer/node_info_per_processor.cc
index 5f461736c..ca87cd64c 100644
--- a/src/synchronizer/node_info_per_processor.cc
+++ b/src/synchronizer/node_info_per_processor.cc
@@ -1,500 +1,500 @@
 /**
  * @file   node_info_per_processor.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Mar 11 15:49:43 2016
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "node_info_per_processor.hh"
 #include "node_group.hh"
 #include "node_synchronizer.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NodeInfoPerProc::NodeInfoPerProc(NodeSynchronizer & synchronizer,
                                  UInt message_cnt, UInt root)
     : MeshAccessor(synchronizer.getMesh()), synchronizer(synchronizer),
       comm(synchronizer.getCommunicator()), rank(comm.whoAmI()),
       nb_proc(comm.getNbProc()), root(root), mesh(synchronizer.getMesh()),
       spatial_dimension(synchronizer.getMesh().getSpatialDimension()),
       message_count(message_cnt) {}
 
 /* -------------------------------------------------------------------------- */
 template <class CommunicationBuffer>
 void NodeInfoPerProc::fillNodeGroupsFromBuffer(CommunicationBuffer & buffer) {
   AKANTU_DEBUG_IN();
 
   std::vector<std::vector<std::string>> node_to_group;
 
   buffer >> node_to_group;
 
   AKANTU_DEBUG_ASSERT(node_to_group.size() == mesh.getNbGlobalNodes(),
                       "Not the good amount of nodes where transmitted");
 
   const auto & global_nodes = mesh.getGlobalNodesIds();
 
   auto nbegin = global_nodes.begin();
   auto nit = global_nodes.begin();
   auto nend = global_nodes.end();
   for (; nit != nend; ++nit) {
     std::vector<std::string>::iterator it = node_to_group[*nit].begin();
     std::vector<std::string>::iterator end = node_to_group[*nit].end();
 
     for (; it != end; ++it) {
       mesh.getNodeGroup(*it).add(nit - nbegin, false);
     }
   }
 
   GroupManager::const_node_group_iterator ngi = mesh.node_group_begin();
   GroupManager::const_node_group_iterator nge = mesh.node_group_end();
   for (; ngi != nge; ++ngi) {
     NodeGroup & ng = *(ngi->second);
     ng.optimize();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::fillNodesType() {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = mesh.getNbNodes();
   Array<NodeType> & nodes_type = this->getNodesType();
 
   Array<UInt> nodes_set(nb_nodes);
   nodes_set.set(0);
 
   enum NodeSet {
     NORMAL_SET = 1,
     GHOST_SET = 2,
   };
 
   Array<bool> already_seen(nb_nodes, 1, false);
 
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
     GhostType gt = (GhostType)g;
     UInt set = NORMAL_SET;
     if (gt == _ghost)
       set = GHOST_SET;
 
     already_seen.set(false);
     Mesh::type_iterator it =
         mesh.firstType(_all_dimensions, gt, _ek_not_defined);
     Mesh::type_iterator end =
         mesh.lastType(_all_dimensions, gt, _ek_not_defined);
     for (; it != end; ++it) {
       ElementType type = *it;
 
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
       UInt nb_element = mesh.getNbElement(type, gt);
       Array<UInt>::const_vector_iterator conn_it =
           mesh.getConnectivity(type, gt).begin(nb_nodes_per_element);
 
       for (UInt e = 0; e < nb_element; ++e, ++conn_it) {
         const Vector<UInt> & conn = *conn_it;
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           AKANTU_DEBUG_ASSERT(conn(n) < nb_nodes,
                               "Node " << conn(n)
                                       << " bigger than number of nodes "
                                       << nb_nodes);
           if (!already_seen(conn(n))) {
             nodes_set(conn(n)) += set;
             already_seen(conn(n)) = true;
           }
         }
       }
     }
   }
 
   for (UInt i = 0; i < nb_nodes; ++i) {
     if (nodes_set(i) == NORMAL_SET)
       nodes_type(i) = _nt_normal;
     else if (nodes_set(i) == GHOST_SET)
       nodes_type(i) = _nt_pure_gost;
     else if (nodes_set(i) == (GHOST_SET + NORMAL_SET))
       nodes_type(i) = _nt_master;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeInfoPerProc::fillCommunicationScheme(const Array<UInt> & master_info) {
   AKANTU_DEBUG_IN();
 
   Communications<UInt> & communications =
       this->synchronizer.getCommunications();
 
   { // send schemes
-    auto it = master_info.begin_reinterpret(2, master_info.getSize() / 2);
-    auto end = master_info.end_reinterpret(2, master_info.getSize() / 2);
+    auto it = master_info.begin_reinterpret(2, master_info.size() / 2);
+    auto end = master_info.end_reinterpret(2, master_info.size() / 2);
 
     std::map<UInt, Array<UInt>> send_array_per_proc;
 
     for (; it != end; ++it) {
       const Vector<UInt> & send_info = *it;
 
       send_array_per_proc[send_info(0)].push_back(send_info(1));
     }
 
     for (auto & send_schemes : send_array_per_proc) {
       auto & scheme = communications.createSendScheme(send_schemes.first);
 
       auto & sends = send_schemes.second;
       std::sort(sends.begin(), sends.end());
       std::transform(sends.begin(), sends.end(), sends.begin(),
                      [this](UInt g) -> UInt { return mesh.getNodeLocalId(g); });
       scheme.copy(sends);
     }
   }
 
   { // receive schemes
     const Array<NodeType> & nodes_type = this->getNodesType();
 
     std::map<UInt, Array<UInt>> recv_array_per_proc;
 
     UInt node = 0;
     for (auto & node_type : nodes_type) {
       if (Int(node_type) >= 0) {
         recv_array_per_proc[node_type].push_back(mesh.getNodeGlobalId(node));
       }
       ++node;
     }
 
     for (auto & recv_schemes : recv_array_per_proc) {
       auto & scheme = communications.createRecvScheme(recv_schemes.first);
 
       auto & recvs = recv_schemes.second;
       std::sort(recvs.begin(), recvs.end());
       std::transform(recvs.begin(), recvs.end(), recvs.begin(),
                      [this](UInt g) -> UInt { return mesh.getNodeLocalId(g); });
 
       scheme.copy(recvs);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 MasterNodeInfoPerProc::MasterNodeInfoPerProc(NodeSynchronizer & synchronizer,
                                              UInt message_cnt, UInt root)
     : NodeInfoPerProc(synchronizer, message_cnt, root) {
   UInt nb_global_nodes = this->mesh.getNbGlobalNodes();
   this->comm.broadcast(nb_global_nodes, this->root);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeNodes() {
   this->nodes_per_proc.resize(nb_proc);
   this->nb_nodes_per_proc.resize(nb_proc);
 
   Array<Real> local_nodes(0, spatial_dimension);
   Array<Real> & nodes = this->getNodes();
 
   for (UInt p = 0; p < nb_proc; ++p) {
     UInt nb_nodes = 0;
     //      UInt * buffer;
     Array<Real> * nodes_to_send;
 
     Array<UInt> & nodespp = nodes_per_proc[p];
     if (p != root) {
       nodes_to_send = new Array<Real>(0, spatial_dimension);
       AKANTU_DEBUG_INFO("Receiving number of nodes from proc "
                         << p << " " << Tag::genTag(p, 0, Tag::_NB_NODES));
       comm.receive(nb_nodes, p, Tag::genTag(p, 0, Tag::_NB_NODES));
       nodespp.resize(nb_nodes);
       this->nb_nodes_per_proc(p) = nb_nodes;
 
       AKANTU_DEBUG_INFO("Receiving list of nodes from proc "
                         << p << " " << Tag::genTag(p, 0, Tag::_NODES));
       comm.receive(nodespp, p, Tag::genTag(p, 0, Tag::_NODES));
     } else {
       Array<UInt> & local_ids = this->getNodesGlobalIds();
-      this->nb_nodes_per_proc(p) = local_ids.getSize();
+      this->nb_nodes_per_proc(p) = local_ids.size();
       nodespp.copy(local_ids);
       nodes_to_send = &local_nodes;
     }
 
     Array<UInt>::const_scalar_iterator it = nodespp.begin();
     Array<UInt>::const_scalar_iterator end = nodespp.end();
     /// get the coordinates for the selected nodes
     for (; it != end; ++it) {
       Vector<Real> coord(nodes.storage() + spatial_dimension * *it,
                          spatial_dimension);
       nodes_to_send->push_back(coord);
     }
 
     if (p != root) { /// send them for distant processors
       AKANTU_DEBUG_INFO("Sending coordinates to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 0, Tag::_COORDINATES));
       comm.send(*nodes_to_send, p,
                 Tag::genTag(this->rank, 0, Tag::_COORDINATES));
       delete nodes_to_send;
     }
   }
 
   /// construct the local nodes coordinates
   nodes.copy(local_nodes);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeTypes() {
   //           <global_id,     <proc, local_id> >
   std::multimap<UInt, std::pair<UInt, UInt>> nodes_to_proc;
   std::vector<Array<NodeType>> nodes_type_per_proc(nb_proc);
 
   // arrays containing pairs of (proc, node)
   std::vector<Array<UInt>> nodes_to_send_per_proc(nb_proc);
   for (UInt p = 0; p < nb_proc; ++p) {
     nodes_type_per_proc[p].resize(nb_nodes_per_proc(p));
   }
 
   this->fillNodesType();
 
   for (UInt p = 0; p < nb_proc; ++p) {
     auto & nodes_types = nodes_type_per_proc[p];
     if (p != root) {
       AKANTU_DEBUG_INFO(
           "Receiving first nodes types from proc "
           << p << " "
           << Tag::genTag(this->rank, this->message_count, Tag::_NODES_TYPE));
       comm.receive(nodes_types, p, Tag::genTag(p, 0, Tag::_NODES_TYPE));
     } else {
       nodes_types.copy(this->getNodesType());
     }
 
     // stack all processors claiming to be master for a node
     for (UInt local_node = 0; local_node < nb_nodes_per_proc(p); ++local_node) {
       if (nodes_types(local_node) == _nt_master) {
         UInt global_node = nodes_per_proc[p](local_node);
         nodes_to_proc.insert(std::make_pair(global_node, std::make_pair(p, local_node)));
       }
     }
   }
 
   for (UInt i = 0; i < mesh.getNbGlobalNodes(); ++i) {
     auto it_range = nodes_to_proc.equal_range(i);
     if (it_range.first == nodes_to_proc.end() || it_range.first->first != i)
       continue;
 
     // pick the first processor out of the multi-map as the actual master
     UInt master_proc = (it_range.first)->second.first;
     for (auto it_node = it_range.first; it_node != it_range.second; ++it_node) {
       UInt proc = it_node->second.first;
       UInt node = it_node->second.second;
       if (proc != master_proc) {
         // store the info on all the slaves for a given master
         nodes_type_per_proc[proc](node) = NodeType(master_proc);
         nodes_to_send_per_proc[master_proc].push_back(proc);
         nodes_to_send_per_proc[master_proc].push_back(i);
       }
     }
   }
 
 
   std::vector<CommunicationRequest> requests_send_type;
   std::vector<CommunicationRequest> requests_send_master_info;
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p != root) {
       AKANTU_DEBUG_INFO("Sending nodes types to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
       requests_send_type.push_back(
           comm.asyncSend(nodes_type_per_proc[p], p,
                          Tag::genTag(this->rank, 0, Tag::_NODES_TYPE)));
 
       auto & nodes_to_send = nodes_to_send_per_proc[p];
 
       /// push back an element to avoid a send of size 0
       nodes_to_send.push_back(-1);
 
       AKANTU_DEBUG_INFO("Sending nodes master info to proc "
                         << p << " "
                         << Tag::genTag(this->rank, 1, Tag::_NODES_TYPE));
       requests_send_master_info.push_back(
           comm.asyncSend(nodes_to_send, p,
                          Tag::genTag(this->rank, 1, Tag::_NODES_TYPE)));
     } else {
       this->getNodesType().copy(nodes_type_per_proc[p]);
 
       this->fillCommunicationScheme(nodes_to_send_per_proc[root]);
     }
   }
 
   comm.waitAll(requests_send_type);
   comm.freeCommunicationRequest(requests_send_type);
   requests_send_type.clear();
 
   comm.waitAll(requests_send_master_info);
   comm.freeCommunicationRequest(requests_send_master_info);
 }
 
 /* -------------------------------------------------------------------------- */
 void MasterNodeInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   UInt nb_total_nodes = mesh.getNbGlobalNodes();
 
   DynamicCommunicationBuffer buffer;
 
   typedef std::vector<std::vector<std::string>> NodeToGroup;
   NodeToGroup node_to_group;
   node_to_group.resize(nb_total_nodes);
 
   GroupManager::const_node_group_iterator ngi = mesh.node_group_begin();
   GroupManager::const_node_group_iterator nge = mesh.node_group_end();
   for (; ngi != nge; ++ngi) {
     NodeGroup & ng = *(ngi->second);
 
     std::string name = ngi->first;
 
     NodeGroup::const_node_iterator nit = ng.begin();
     NodeGroup::const_node_iterator nend = ng.end();
     for (; nit != nend; ++nit) {
       node_to_group[*nit].push_back(name);
     }
 
     nit = ng.begin();
     if (nit != nend)
       ng.empty();
   }
 
   buffer << node_to_group;
 
   std::vector<CommunicationRequest> requests;
   for (UInt p = 0; p < nb_proc; ++p) {
     if (p == this->rank)
       continue;
     AKANTU_DEBUG_INFO("Sending node groups to proc "
                       << p << " "
                       << Tag::genTag(this->rank, p, Tag::_NODE_GROUP));
     requests.push_back(comm.asyncSend(
         buffer, p, Tag::genTag(this->rank, p, Tag::_NODE_GROUP)));
   }
 
   this->fillNodeGroupsFromBuffer(buffer);
 
   comm.waitAll(requests);
   comm.freeCommunicationRequest(requests);
   requests.clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 SlaveNodeInfoPerProc::SlaveNodeInfoPerProc(NodeSynchronizer & synchronizer,
                                            UInt message_cnt, UInt root)
     : NodeInfoPerProc(synchronizer, message_cnt, root) {
   UInt nb_global_nodes = 0;
   comm.broadcast(nb_global_nodes, root);
   this->setNbGlobalNodes(nb_global_nodes);
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeNodes() {
   AKANTU_DEBUG_INFO("Sending list of nodes to proc "
                     << root << " " << Tag::genTag(this->rank, 0, Tag::_NB_NODES)
                     << " " << Tag::genTag(this->rank, 0, Tag::_NODES));
   Array<UInt> & local_ids = this->getNodesGlobalIds();
   Array<Real> & nodes = this->getNodes();
 
-  UInt nb_nodes = local_ids.getSize();
+  UInt nb_nodes = local_ids.size();
   comm.send(nb_nodes, root, Tag::genTag(this->rank, 0, Tag::_NB_NODES));
   comm.send(local_ids, root, Tag::genTag(this->rank, 0, Tag::_NODES));
 
   /* --------<<<<-COORDINATES---------------------------------------------- */
   nodes.resize(nb_nodes);
   AKANTU_DEBUG_INFO("Receiving coordinates from proc "
                     << root << " " << Tag::genTag(root, 0, Tag::_COORDINATES));
   comm.receive(nodes, root, Tag::genTag(root, 0, Tag::_COORDINATES));
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeTypes() {
   this->fillNodesType();
 
   Array<NodeType> & nodes_types = this->getNodesType();
 
   AKANTU_DEBUG_INFO("Sending first nodes types to proc "
                     << root << ""
                     << Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
   comm.send(nodes_types, root, Tag::genTag(this->rank, 0, Tag::_NODES_TYPE));
 
   AKANTU_DEBUG_INFO("Receiving nodes types from proc "
                     << root << " " << Tag::genTag(root, 0, Tag::_NODES_TYPE));
   comm.receive(nodes_types, root, Tag::genTag(root, 0, Tag::_NODES_TYPE));
 
 
   AKANTU_DEBUG_INFO("Receiving nodes master info from proc "
                     << root << " " << Tag::genTag(root, 1, Tag::_NODES_TYPE));
   CommunicationStatus status;
   comm.probe<UInt>(root, Tag::genTag(root, 1, Tag::_NODES_TYPE), status);
 
-  Array<UInt> nodes_master_info(status.getSize());
+  Array<UInt> nodes_master_info(status.size());
 
   comm.receive(nodes_master_info, root,
                Tag::genTag(root, 1, Tag::_NODES_TYPE));
 
-  nodes_master_info.resize(nodes_master_info.getSize() - 1);
+  nodes_master_info.resize(nodes_master_info.size() - 1);
 
   this->fillCommunicationScheme(nodes_master_info);
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveNodeInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Receiving node groups from proc "
                     << root << " "
                     << Tag::genTag(root, this->rank, Tag::_NODE_GROUP));
 
   CommunicationStatus status;
   comm.probe<char>(root, Tag::genTag(root, this->rank, Tag::_NODE_GROUP),
                    status);
 
-  CommunicationBuffer buffer(status.getSize());
+  CommunicationBuffer buffer(status.size());
   comm.receive(buffer, root, Tag::genTag(root, this->rank, Tag::_NODE_GROUP));
 
   this->fillNodeGroupsFromBuffer(buffer);
 
   AKANTU_DEBUG_OUT();
 }
 
 } // akantu
diff --git a/src/synchronizer/real_static_communicator.hh b/src/synchronizer/real_static_communicator.hh
index ea35d9dc3..cdc1bbc13 100644
--- a/src/synchronizer/real_static_communicator.hh
+++ b/src/synchronizer/real_static_communicator.hh
@@ -1,153 +1,151 @@
 /**
  * @file   real_static_communicator.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jun 14 2010
  * @date last modification: Wed Jan 13 2016
  *
  * @brief  empty class just for inheritance
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_REAL_STATIC_COMMUNICATOR_HH__
 #define __AKANTU_REAL_STATIC_COMMUNICATOR_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class InternalCommunicationRequest {
 public:
   InternalCommunicationRequest(UInt source, UInt dest);
   virtual ~InternalCommunicationRequest();
 
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   AKANTU_GET_MACRO(Source, source, UInt);
   AKANTU_GET_MACRO(Destination, destination, UInt);
 
 private:
   UInt source;
   UInt destination;
   UInt id;
   static UInt counter;
 };
 
 /* -------------------------------------------------------------------------- */
 class CommunicationRequest {
 public:
   CommunicationRequest(
       std::shared_ptr<InternalCommunicationRequest> request = nullptr)
       : request(std::move(request)) {}
 
   // CommunicationRequest(CommunicationRequest & other)
   //     : request(std::move(other.request)) {}
 
   // CommunicationRequest(CommunicationRequest && other)
   //     : request(std::move(other.request)) {}
 
   // CommunicationRequest & operator=(CommunicationRequest & other) {
   //   request = std::move(other.request);
   //   return *this;
   // }
 
   // CommunicationRequest & operator=(CommunicationRequest && other) {
   //   request = std::move(other.request);
   //   return *this;
   // }
 
   virtual void free() { request.reset(); }
 
   void printself(std::ostream & stream, int indent = 0) const {
     request->printself(stream, indent);
   };
 
   UInt getSource() const { return request->getSource(); }
   UInt getDestination() const { return request->getDestination(); }
 
   bool isFreed() const { return request.get() == nullptr; }
 
   InternalCommunicationRequest & getInternal() { return *request; }
 
 private:
   std::shared_ptr<InternalCommunicationRequest> request;
 };
 
 /* -------------------------------------------------------------------------- */
 class CommunicationStatus {
 public:
-  CommunicationStatus() : source(0), size(0), tag(0){};
-
   AKANTU_GET_MACRO(Source, source, Int);
-  AKANTU_GET_MACRO(Size, size, UInt);
+  UInt size() const { return size_; }
   AKANTU_GET_MACRO(Tag, tag, Int);
 
   AKANTU_SET_MACRO(Source, source, Int);
-  AKANTU_SET_MACRO(Size, size, UInt);
+  AKANTU_SET_MACRO(Size, size_, UInt);
   AKANTU_SET_MACRO(Tag, tag, Int);
 
 private:
-  Int source;
-  UInt size;
-  Int tag;
+  Int source{0};
+  UInt size_{0};
+  Int tag{0};
 };
 
 /* -------------------------------------------------------------------------- */
 /// Datatype to pack pairs for MPI_{MIN,MAX}LOC
 template <typename T1, typename T2> struct SCMinMaxLoc {
   T1 min_max;
   T2 loc;
 };
 
 /* -------------------------------------------------------------------------- */
 
 class StaticCommunicator;
 
 /* -------------------------------------------------------------------------- */
 class RealStaticCommunicator {
 public:
   RealStaticCommunicator(__attribute__((unused)) int & argc,
                          __attribute__((unused)) char **& argv) {
     prank = -1;
     psize = -1;
   };
   virtual ~RealStaticCommunicator(){};
 
   friend class StaticCommunicator;
 
   Int getNbProc() { return this->psize; }
   Int whoAmI() { return this->prank; }
 
 protected:
   Int prank;
   Int psize;
 };
 
 } // akantu
 
 #endif /* __AKANTU_REAL_STATIC_COMMUNICATOR_HH__ */
diff --git a/src/synchronizer/slave_element_info_per_processor.cc b/src/synchronizer/slave_element_info_per_processor.cc
index 78c764065..88c3e9f55 100644
--- a/src/synchronizer/slave_element_info_per_processor.cc
+++ b/src/synchronizer/slave_element_info_per_processor.cc
@@ -1,197 +1,197 @@
 /**
  * @file   slave_element_info_per_processor.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Fri Mar 11 14:59:21 2016
  *
  * @brief
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "element_info_per_processor.hh"
 #include "element_synchronizer.hh"
 #include "mesh_utils.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <iostream>
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 SlaveElementInfoPerProc::SlaveElementInfoPerProc(
     ElementSynchronizer & synchronizer, UInt message_cnt, UInt root)
     : ElementInfoPerProc(synchronizer, message_cnt, root, _not_defined) {
 
   Vector<UInt> size(5);
   comm.receive(size, this->root,
                Tag::genTag(this->root, this->message_count, Tag::_SIZES));
 
   this->type = (ElementType)size[0];
   this->nb_local_element = size[1];
   this->nb_ghost_element = size[2];
   this->nb_element_to_receive = size[3];
   this->nb_tags = size[4];
 
   if (this->type != _not_defined)
     this->nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 }
 
 /* -------------------------------------------------------------------------- */
 
 bool SlaveElementInfoPerProc::needSynchronize() {
   return this->type != _not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveElementInfoPerProc::synchronizeConnectivities() {
   Array<UInt> local_connectivity(
       (this->nb_local_element + this->nb_ghost_element) *
       this->nb_nodes_per_element);
 
   AKANTU_DEBUG_INFO("Receiving connectivities from proc " << root);
   comm.receive(
       local_connectivity, this->root,
       Tag::genTag(this->root, this->message_count, Tag::_CONNECTIVITY));
 
   Array<UInt> & old_nodes = this->getNodesGlobalIds();
   AKANTU_DEBUG_INFO("Renumbering local connectivities");
   MeshUtils::renumberMeshNodes(this->mesh, local_connectivity,
                                this->nb_local_element, this->nb_ghost_element,
                                this->type, old_nodes);
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveElementInfoPerProc::synchronizePartitions() {
   Array<UInt> local_partitions(this->nb_element_to_receive +
                                this->nb_ghost_element * 2);
   AKANTU_DEBUG_INFO("Receiving partition informations from proc " << root);
   this->comm.receive(local_partitions, this->root,
                      Tag::genTag(root, this->message_count, Tag::_PARTITIONS));
 
   if (Mesh::getSpatialDimension(this->type) ==
       this->mesh.getSpatialDimension()) {
     AKANTU_DEBUG_INFO("Creating communications scheme");
     this->fillCommunicationScheme(local_partitions);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveElementInfoPerProc::synchronizeTags() {
   AKANTU_DEBUG_IN();
 
   if (this->nb_tags == 0) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
   /* --------<<<<-TAGS------------------------------------------------- */
   UInt mesh_data_sizes_buffer_length = 0;
   CommunicationBuffer mesh_data_sizes_buffer;
 
   AKANTU_DEBUG_INFO(
       "Receiving the size of the information about the mesh data tags.");
   comm.broadcast(mesh_data_sizes_buffer_length, root);
 
   if (mesh_data_sizes_buffer_length != 0) {
     mesh_data_sizes_buffer.resize(mesh_data_sizes_buffer_length);
     AKANTU_DEBUG_INFO(
         "Receiving the information about the mesh data tags, addr "
         << (void *)mesh_data_sizes_buffer.storage());
     comm.broadcast(mesh_data_sizes_buffer, root);
     AKANTU_DEBUG_INFO("Size of the information about the mesh data: "
                       << mesh_data_sizes_buffer_length);
 
     std::vector<std::string> tag_names;
     std::vector<MeshDataTypeCode> tag_type_codes;
     std::vector<UInt> tag_nb_component;
     tag_names.resize(nb_tags);
     tag_type_codes.resize(nb_tags);
     tag_nb_component.resize(nb_tags);
     CommunicationBuffer mesh_data_buffer;
     UInt type_code_int;
     for (UInt i(0); i < nb_tags; ++i) {
       mesh_data_sizes_buffer >> tag_names[i];
       mesh_data_sizes_buffer >> type_code_int;
       tag_type_codes[i] = static_cast<MeshDataTypeCode>(type_code_int);
       mesh_data_sizes_buffer >> tag_nb_component[i];
     }
 
     std::vector<std::string>::const_iterator names_it = tag_names.begin();
     std::vector<std::string>::const_iterator names_end = tag_names.end();
 
     CommunicationStatus mesh_data_comm_status;
     AKANTU_DEBUG_INFO("Checking size of data to receive for mesh data TAG("
                       << Tag::genTag(root, this->message_count, Tag::_MESH_DATA)
                       << ")");
     comm.probe<char>(root,
                      Tag::genTag(root, this->message_count, Tag::_MESH_DATA),
                      mesh_data_comm_status);
-    UInt mesh_data_buffer_size(mesh_data_comm_status.getSize());
+    UInt mesh_data_buffer_size(mesh_data_comm_status.size());
     AKANTU_DEBUG_INFO("Receiving "
                       << mesh_data_buffer_size << " bytes of mesh data TAG("
                       << Tag::genTag(root, this->message_count, Tag::_MESH_DATA)
                       << ")");
     mesh_data_buffer.resize(mesh_data_buffer_size);
     comm.receive(mesh_data_buffer, root,
                  Tag::genTag(root, this->message_count, Tag::_MESH_DATA));
 
     // Loop over each tag for the current type
     UInt k(0);
     for (; names_it != names_end; ++names_it, ++k) {
       this->fillMeshData(mesh_data_buffer, *names_it, tag_type_codes[k],
                          tag_nb_component[k]);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SlaveElementInfoPerProc::synchronizeGroups() {
   AKANTU_DEBUG_IN();
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   UInt my_rank = comm.whoAmI();
 
   AKANTU_DEBUG_INFO("Receiving element groups from proc "
                     << root << " TAG("
                     << Tag::genTag(root, my_rank, Tag::_ELEMENT_GROUP) << ")");
 
   CommunicationStatus status;
   comm.probe<char>(root, Tag::genTag(root, my_rank, Tag::_ELEMENT_GROUP),
                    status);
 
-  CommunicationBuffer buffer(status.getSize());
+  CommunicationBuffer buffer(status.size());
   comm.receive(buffer, root, Tag::genTag(root, my_rank, Tag::_ELEMENT_GROUP));
 
   this->fillElementGroupsFromBuffer(buffer);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/synchronizer/static_communicator.hh b/src/synchronizer/static_communicator.hh
index 049363558..276e7bda6 100644
--- a/src/synchronizer/static_communicator.hh
+++ b/src/synchronizer/static_communicator.hh
@@ -1,436 +1,436 @@
 /**
  * @file   static_communicator.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Class handling the parallel communications
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_STATIC_COMMUNICATOR_HH__
 #define __AKANTU_STATIC_COMMUNICATOR_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_common.hh"
 #include "aka_event_handler_manager.hh"
 #include "communication_buffer.hh"
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_COMMUNICATOR_LIST_0 BOOST_PP_SEQ_NIL
 
 #include "static_communicator_dummy.hh"
 #define AKANTU_COMMUNICATOR_LIST_1                                             \
   BOOST_PP_SEQ_PUSH_BACK(                                                      \
       AKANTU_COMMUNICATOR_LIST_0,                                              \
       (_communicator_dummy, (StaticCommunicatorDummy, BOOST_PP_NIL)))
 
 #if defined(AKANTU_USE_MPI)
 #include "static_communicator_mpi.hh"
 #define AKANTU_COMMUNICATOR_LIST_ALL                                           \
   BOOST_PP_SEQ_PUSH_BACK(                                                      \
       AKANTU_COMMUNICATOR_LIST_1,                                              \
       (_communicator_mpi, (StaticCommunicatorMPI, BOOST_PP_NIL)))
 #else
 #define AKANTU_COMMUNICATOR_LIST_ALL AKANTU_COMMUNICATOR_LIST_1
 #endif // AKANTU_COMMUNICATOR_LIST
 
 #include "real_static_communicator.hh"
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class RealStaticCommunicator;
 
 struct FinalizeCommunicatorEvent {
   explicit FinalizeCommunicatorEvent(const StaticCommunicator & comm)
       : communicator(comm) {}
   const StaticCommunicator & communicator;
 };
 
 class CommunicatorEventHandler {
 public:
   virtual ~CommunicatorEventHandler() {}
   virtual void onCommunicatorFinalize() {}
 
 private:
   inline void sendEvent(const FinalizeCommunicatorEvent &) {
     onCommunicatorFinalize();
   }
 
   template <class EventHandler> friend class EventHandlerManager;
 };
 
 class StaticCommunicator
     : public EventHandlerManager<CommunicatorEventHandler> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 protected:
   StaticCommunicator(int & argc, char **& argv,
                      CommunicatorType type = _communicator_mpi);
 
 public:
   virtual ~StaticCommunicator();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   /* Point to Point                                                           */
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void receive(Array<T> & values, Int sender, Int tag) const {
     return this->receive(values.storage(),
-                         values.getSize() * values.getNbComponent(), sender,
+                         values.size() * values.getNbComponent(), sender,
                          tag);
   }
   template <typename T>
   inline void receive(Vector<T> & values, Int sender, Int tag) const {
     return this->receive(values.storage(), values.size(), sender, tag);
   }
   template <typename T>
   inline void receive(Matrix<T> & values, Int sender, Int tag) const {
     return this->receive(values.storage(), values.size(), sender, tag);
   }
   template <bool is_static>
   inline void receive(CommunicationBufferTemplated<is_static> & values,
                       Int sender, Int tag) const {
-    return this->receive(values.storage(), values.getSize(), sender, tag);
+    return this->receive(values.storage(), values.size(), sender, tag);
   }
   template <typename T>
   inline void receive(T & values, Int sender, Int tag) const {
     return this->receive(&values, 1, sender, tag);
   }
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void send(Array<T> & values, Int receiver, Int tag) const {
     return this->send(values.storage(),
-                      values.getSize() * values.getNbComponent(), receiver,
+                      values.size() * values.getNbComponent(), receiver,
                       tag);
   }
   template <typename T>
   inline void send(Vector<T> & values, Int receiver, Int tag) const {
     return this->send(values.storage(), values.size(), receiver, tag);
   }
   template <typename T>
   inline void send(Matrix<T> & values, Int receiver, Int tag) const {
     return this->send(values.storage(), values.size(), receiver, tag);
   }
   template <bool is_static>
   inline void send(CommunicationBufferTemplated<is_static> & values,
                    Int receiver, Int tag) const {
-    return this->send(values.storage(), values.getSize(), receiver, tag);
+    return this->send(values.storage(), values.size(), receiver, tag);
   }
   template <typename T>
   inline void send(T & values, Int receiver, Int tag) const {
     return this->send(&values, 1, receiver, tag);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline CommunicationRequest asyncSend(Array<T> & values, Int receiver,
                                         Int tag) const {
     return this->asyncSend(values.storage(),
-                           values.getSize() * values.getNbComponent(), receiver,
+                           values.size() * values.getNbComponent(), receiver,
                            tag);
   }
   template <typename T>
   inline CommunicationRequest asyncSend(std::vector<T> & values, Int receiver,
                                         Int tag) const {
     return this->asyncSend(values.data(), values.size(), receiver, tag);
   }
 
   template <typename T>
   inline CommunicationRequest asyncSend(Vector<T> & values, Int receiver,
                                         Int tag) const {
     return this->asyncSend(values.storage(), values.size(), receiver, tag);
   }
   template <typename T>
   inline CommunicationRequest asyncSend(Matrix<T> & values, Int receiver,
                                         Int tag) const {
     return this->asyncSend(values.storage(), values.size(), receiver, tag);
   }
   template <bool is_static>
   inline CommunicationRequest
   asyncSend(CommunicationBufferTemplated<is_static> & values, Int receiver,
             Int tag) const {
-    return this->asyncSend(values.storage(), values.getSize(), receiver, tag);
+    return this->asyncSend(values.storage(), values.size(), receiver, tag);
   }
   template <typename T>
   inline CommunicationRequest asyncSend(T & values, Int receiver,
                                         Int tag) const {
     return this->asyncSend(&values, 1, receiver, tag);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline CommunicationRequest asyncReceive(Array<T> & values, Int sender,
                                            Int tag) const {
     return this->asyncReceive(values.storage(),
-                              values.getSize() * values.getNbComponent(),
+                              values.size() * values.getNbComponent(),
                               sender, tag);
   }
   template <typename T>
   inline CommunicationRequest asyncReceive(std::vector<T> & values, Int sender,
                                            Int tag) const {
     return this->asyncReceive(values.data(), values.size(), sender, tag);
   }
 
   template <typename T, UInt ndim, class RetType>
   inline CommunicationRequest
   asyncReceive(TensorStorage<T, ndim, RetType> & values, Int sender,
                Int tag) const {
     return this->asyncReceive(values.storage(), values.size(), sender, tag);
   }
   template <bool is_static>
   inline CommunicationRequest
   asyncReceive(CommunicationBufferTemplated<is_static> & values, Int sender,
                Int tag) const {
-    return this->asyncReceive(values.storage(), values.getSize(), sender, tag);
+    return this->asyncReceive(values.storage(), values.size(), sender, tag);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void probe(Int sender, Int tag, CommunicationStatus & status) const;
 
   /* ------------------------------------------------------------------------ */
   /* Collectives                                                              */
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void allReduce(Array<T> & values,
                         const SynchronizerOperation & op) const {
     this->allReduce(values.storage(),
-                    values.getSize() * values.getNbComponent(), op);
+                    values.size() * values.getNbComponent(), op);
   }
   template <typename T>
   inline void allReduce(Vector<T> & values,
                         const SynchronizerOperation & op) const {
     this->allReduce(values.storage(), values.size(), op);
   }
   template <typename T>
   inline void allReduce(Matrix<T> & values,
                         const SynchronizerOperation & op) const {
     this->allReduce(values.storage(), values.size(), op);
   }
   template <typename T>
   inline void allReduce(T & values, const SynchronizerOperation & op) const {
     this->allReduce(&values, 1, op);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T> inline void allGather(Array<T> & values) const {
     AKANTU_DEBUG_ASSERT(UInt(this->real_static_communicator->getNbProc()) ==
-                            values.getSize(),
+                            values.size(),
                         "The array size is not correct");
     this->allGather(values.storage(), values.getNbComponent());
   }
 
   template <typename T> inline void allGather(Vector<T> & values) const {
     AKANTU_DEBUG_ASSERT(UInt(this->real_static_communicator->getNbProc()) ==
                             values.size(),
                         "The vector size is not correct");
     this->allGather(values.storage(), 1);
   }
 
   template <typename T> inline void allGather(Tensor3<T> & values) const {
     AKANTU_DEBUG_ASSERT(UInt(this->real_static_communicator->getNbProc()) ==
                             values.size(2),
                         "The tensor size is not correct");
     this->allGather(values.storage(), values.size(0) * values.size(1));
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void allGatherV(Array<T> & values, Array<Int> sizes) const {
     this->allGatherV(values.storage(), sizes.storage());
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void reduce(Array<T> & values, const SynchronizerOperation & op,
                      int root = 0) const {
-    this->reduce(values.storage(), values.getSize() * values.getNbComponent(),
+    this->reduce(values.storage(), values.size() * values.getNbComponent(),
                  op, root);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void gather(Vector<T> & values, int root = 0) const {
     this->gather(values.storage(), values.getNbComponent(), root);
   }
   template <typename T> inline void gather(T values, int root = 0) const {
     this->gather(&values, 1, root);
   }
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void gather(Vector<T> & values, Array<T> & gathered) const {
-    AKANTU_DEBUG_ASSERT(values.getSize() == gathered.getNbComponent(),
+    AKANTU_DEBUG_ASSERT(values.size() == gathered.getNbComponent(),
                         "The array size is not correct");
     gathered.resize(this->real_static_communicator->getNbProc());
-    this->gather(values.data(), values.getSize(), gathered.storage(),
+    this->gather(values.data(), values.size(), gathered.storage(),
                  gathered.getNbComponent());
   }
 
   template <typename T>
   inline void gather(T values, Array<T> & gathered) const {
     this->gather(&values, 1, gathered.storage(), 1);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void gatherV(Array<T> & values, Array<Int> sizes, int root = 0) const {
     this->gatherV(values.storage(), sizes.storage(), root);
   }
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void broadcast(Array<T> & values, int root = 0) const {
     this->broadcast(values.storage(),
-                    values.getSize() * values.getNbComponent(), root);
+                    values.size() * values.getNbComponent(), root);
   }
   template <bool is_static>
   inline void broadcast(CommunicationBufferTemplated<is_static> & values,
                         int root = 0) const {
-    this->broadcast(values.storage(), values.getSize(), root);
+    this->broadcast(values.storage(), values.size(), root);
   }
   template <typename T> inline void broadcast(T & values, int root = 0) const {
     this->broadcast(&values, 1, root);
   }
 
   /* ------------------------------------------------------------------------ */
   inline void barrier() const;
 
   /* ------------------------------------------------------------------------ */
   /* Request handling                                                         */
   /* ------------------------------------------------------------------------ */
   inline bool testRequest(CommunicationRequest & request) const;
 
   inline void wait(CommunicationRequest & request) const;
   inline void waitAll(std::vector<CommunicationRequest> & requests) const;
   inline UInt waitAny(std::vector<CommunicationRequest> & requests) const;
 
   inline void freeCommunicationRequest(CommunicationRequest & request) const;
   inline void
   freeCommunicationRequest(std::vector<CommunicationRequest> & requests) const;
 
 protected:
   template <typename T>
   inline void send(T * buffer, Int size, Int receiver, Int tag) const;
   template <typename T>
   inline void receive(T * buffer, Int size, Int sender, Int tag) const;
 
   template <typename T>
   inline CommunicationRequest asyncSend(T * buffer, Int size, Int receiver,
                                         Int tag) const;
   template <typename T>
   inline CommunicationRequest asyncReceive(T * buffer, Int size, Int sender,
                                            Int tag) const;
 
   template <typename T>
   inline void allReduce(T * values, int nb_values,
                         const SynchronizerOperation & op) const;
 
   template <typename T> inline void allGather(T * values, int nb_values) const;
   template <typename T>
   inline void allGatherV(T * values, int * nb_values) const;
 
   template <typename T>
   inline void reduce(T * values, int nb_values,
                      const SynchronizerOperation & op, int root = 0) const;
   template <typename T>
   inline void gather(T * values, int nb_values, int root = 0) const;
 
   template <typename T>
   inline void gather(T * values, int nb_values, T * gathered,
                      int nb_gathered = 0) const;
 
   template <typename T>
   inline void gatherV(T * values, int * nb_values, int root = 0) const;
 
   template <typename T>
   inline void broadcast(T * values, int nb_values, int root = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   virtual Int getNbProc() const { return real_static_communicator->psize; };
   virtual Int whoAmI() const { return real_static_communicator->prank; };
 
   AKANTU_GET_MACRO(RealStaticCommunicator, *real_static_communicator,
                    const RealStaticCommunicator &);
   AKANTU_GET_MACRO_NOT_CONST(RealStaticCommunicator, *real_static_communicator,
                              RealStaticCommunicator &);
 
   template <class Comm> Comm & getRealStaticCommunicator() {
     return dynamic_cast<Comm &>(*real_static_communicator);
   }
 
   static StaticCommunicator &
   getStaticCommunicator(CommunicatorType type = _communicator_mpi);
 
   static StaticCommunicator &
   getStaticCommunicator(int & argc, char **& argv,
                         CommunicatorType type = _communicator_mpi);
 
   static StaticCommunicator * getStaticCommunicatorDummy();
 
   static bool isInstantiated() { return is_instantiated; };
 
   int getMaxTag() const;
   int getMinTag() const;
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   static bool is_instantiated;
 
   static StaticCommunicator * static_communicator;
 
   RealStaticCommunicator * real_static_communicator;
 
   CommunicatorType real_type;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions ArrayBase                                                */
 /* -------------------------------------------------------------------------- */
 inline std::ostream & operator<<(std::ostream & stream,
                                  const CommunicationRequest & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "static_communicator_inline_impl.hh"
 
 #endif /* __AKANTU_STATIC_COMMUNICATOR_HH__ */
diff --git a/src/synchronizer/synchronizer_impl_tmpl.hh b/src/synchronizer/synchronizer_impl_tmpl.hh
index 74ab420dc..745956dee 100644
--- a/src/synchronizer/synchronizer_impl_tmpl.hh
+++ b/src/synchronizer/synchronizer_impl_tmpl.hh
@@ -1,286 +1,286 @@
 /**
  * @file   synchronizer_impl_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Aug 24 13:29:47 2016
  *
  * @brief  Implementation of the SynchronizerImpl
  *
  * @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 "synchronizer_impl.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SYNCHRONIZER_IMPL_TMPL_HH__
 #define __AKANTU_SYNCHRONIZER_IMPL_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 SynchronizerImpl<Entity>::SynchronizerImpl(const ID & id, MemoryID memory_id,
                                            const StaticCommunicator & comm)
     : Synchronizer(id, memory_id, comm), communications(comm) {}
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void SynchronizerImpl<Entity>::synchronizeOnceImpl(
     DataAccessor<Entity> & data_accessor,
     const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   // no need to synchronize
   if (this->nb_proc == 1) {
     AKANTU_DEBUG_OUT();
     return;
   }
 
   typedef std::vector<CommunicationRequest> CommunicationRequests;
   typedef std::map<UInt, CommunicationBuffer> CommunicationBuffers;
 
   CommunicationRequests send_requests, recv_requests;
   CommunicationBuffers send_buffers, recv_buffers;
 
   auto postComm = [&](const CommunicationSendRecv & sr,
                       CommunicationBuffers & buffers,
                       CommunicationRequests & requests) -> void {
     auto sit = this->communications.begin_scheme(sr);
     auto send = this->communications.end_scheme(sr);
 
     for (; sit != send; ++sit) {
       const auto & scheme = sit->second;
       auto & proc = sit->first;
 
       auto & buffer = buffers[proc];
       UInt buffer_size = data_accessor.getNbData(scheme, tag);
       buffer.resize(buffer_size);
 
       if (sr == _recv) {
         requests.push_back(communicator.asyncReceive(
             buffer, proc,
             Tag::genTag(this->rank, 0, Tag::_SYNCHRONIZE, this->hash_id)));
       } else {
         data_accessor.packData(buffer, scheme, tag);
         send_requests.push_back(communicator.asyncSend(
             buffer, proc,
             Tag::genTag(proc, 0, Tag::_SYNCHRONIZE, this->hash_id)));
       }
     }
   };
 
   // post the receive requests
   postComm(_recv, recv_buffers, recv_requests);
 
   // send the data
   postComm(_send, send_buffers, send_requests);
 
   // treat the receive requests
   UInt request_ready;
   while ((request_ready = communicator.waitAny(recv_requests)) != UInt(-1)) {
     CommunicationRequest & req = recv_requests[request_ready];
     UInt proc = req.getSource();
 
     CommunicationBuffer & buffer = recv_buffers[proc];
     const auto & scheme = this->communications.getScheme(proc, _recv);
 
     data_accessor.unpackData(buffer, scheme, tag);
 
     req.free();
     recv_requests.erase(recv_requests.begin() + request_ready);
   }
 
   communicator.waitAll(send_requests);
   communicator.freeCommunicationRequest(send_requests);
   //communicator.freeCommunicationRequest(recv_requests);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void SynchronizerImpl<Entity>::asynchronousSynchronizeImpl(
     const DataAccessor<Entity> & data_accessor,
     const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   if (!this->communications.hasCommunication(tag))
     this->computeBufferSize(data_accessor, tag);
 
   this->communications.incrementCounter(tag);
 
   // Posting the receive -------------------------------------------------------
   if (this->communications.hasPendingRecv(tag)) {
     AKANTU_CUSTOM_EXCEPTION_INFO(
         debug::CommunicationException(),
         "There must still be some pending receive communications."
             << " Tag is " << tag << " Cannot start new ones");
   }
 
   auto recv_it = this->communications.begin_recv(tag);
   auto recv_end = this->communications.end_recv(tag);
   for (; recv_it != recv_end; ++recv_it) {
     auto comm_desc = *recv_it;
     comm_desc.postRecv(this->hash_id);
   }
 
   // Posting the sends -------------------------------------------------------
   if (communications.hasPendingSend(tag)) {
     AKANTU_CUSTOM_EXCEPTION_INFO(
         debug::CommunicationException(),
         "There must be some pending sending communications."
             << " Tag is " << tag);
   }
 
   auto send_it = communications.begin_send(tag);
   auto send_end = communications.end_send(tag);
   for (; send_it != send_end; ++send_it) {
     auto comm_desc = *send_it;
     comm_desc.resetBuffer();
 
 #ifndef AKANTU_NDEBUG
     this->packSanityCheckData(comm_desc);
 #endif
 
     comm_desc.packData(data_accessor);
     comm_desc.postSend(this->hash_id);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void SynchronizerImpl<Entity>::waitEndSynchronizeImpl(
     DataAccessor<Entity> & data_accessor, const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
 #ifndef AKANTU_NDEBUG
   if (this->communications.begin_recv(tag) !=
       this->communications.end_recv(tag) &&
       !this->communications.hasPendingRecv(tag))
       AKANTU_CUSTOM_EXCEPTION_INFO(debug::CommunicationException(),
                                  "No pending communication with the tag \""
                                      << tag);
 #endif
 
   auto recv_end = this->communications.end_recv(tag);
   decltype(recv_end) recv_it;
 
   while ((recv_it = this->communications.waitAnyRecv(tag)) != recv_end) {
     auto comm_desc = *recv_it;
 #ifndef AKANTU_NDEBUG
     this->unpackSanityCheckData(comm_desc);
 #endif
 
     comm_desc.unpackData(data_accessor);
     comm_desc.resetBuffer();
     comm_desc.freeRequest();
   }
 
   this->communications.waitAllSend(tag);
   this->communications.freeSendRequests(tag);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void SynchronizerImpl<Entity>::computeAllBufferSizes(
     const DataAccessor<Entity> & data_accessor) {
   auto it = this->communications.begin_tag();
   auto end = this->communications.end_tag();
 
   for (; it != end; ++it) {
     auto tag = *it;
     this->computeBufferSize(data_accessor, tag);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void SynchronizerImpl<Entity>::computeBufferSizeImpl(
     const DataAccessor<Entity> & data_accessor,
     const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   this->communications.initializeCommunications(tag);
   AKANTU_DEBUG_ASSERT(communications.hasCommunication(tag) == true,
                       "Communications where not properly initialized");
 
   auto recv_it = this->communications.begin_recv_scheme();
   auto recv_end = this->communications.end_recv_scheme();
   for (; recv_it != recv_end; ++recv_it) {
     auto proc = recv_it->first;
     auto & scheme = recv_it->second;
     UInt srecv = 0;
 #ifndef AKANTU_NDEBUG
     srecv += this->sanityCheckDataSize(scheme, tag);
 #endif
     srecv += data_accessor.getNbData(scheme, tag);
     AKANTU_DEBUG_INFO("I have " << srecv << "(" << printMemorySize<char>(srecv)
-                                << " - " << scheme.getSize()
+                                << " - " << scheme.size()
                                 << " element(s)) data to receive from " << proc
                                 << " for tag " << tag);
     this->communications.setRecvCommunicationSize(tag, proc, srecv);
   }
 
   auto send_it = this->communications.begin_send_scheme();
   auto send_end = this->communications.end_send_scheme();
   for (; send_it != send_end; ++send_it) {
     auto proc = send_it->first;
     auto & scheme = send_it->second;
     UInt ssend = 0;
 #ifndef AKANTU_NDEBUG
     ssend += this->sanityCheckDataSize(scheme, tag);
 #endif
     ssend += data_accessor.getNbData(scheme, tag);
     AKANTU_DEBUG_INFO("I have " << ssend << "(" << printMemorySize<char>(ssend)
-                                << " - " << scheme.getSize()
+                                << " - " << scheme.size()
                                 << " element(s)) data to send to " << proc
                                 << " for tag " << tag);
     this->communications.setSendCommunicationSize(tag, proc, ssend);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 UInt SynchronizerImpl<Entity>::sanityCheckDataSize(
     const Array<Entity> &, const SynchronizationTag &) const {
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void SynchronizerImpl<Entity>::packSanityCheckData(
     CommunicationDescriptor<Entity> &) const {}
 
 /* -------------------------------------------------------------------------- */
 template <class Entity>
 void SynchronizerImpl<Entity>::unpackSanityCheckData(
     CommunicationDescriptor<Entity> &) const {}
 
 /* -------------------------------------------------------------------------- */
 } // akantu
 
 #endif /* __AKANTU_SYNCHRONIZER_IMPL_TMPL_HH__ */
diff --git a/test/test_common/test_vector/test_vector.cc b/test/test_common/test_vector/test_vector.cc
index 2b8fdf425..2198caa2a 100644
--- a/test/test_common/test_vector/test_vector.cc
+++ b/test/test_common/test_vector/test_vector.cc
@@ -1,78 +1,78 @@
 /**
  * @file   test_vector.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jun 29 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  test of the vector class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <cstdlib>
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_types.hh"
 #include "aka_array.hh"
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main() {
   int def_value[3];
   def_value[0] = 10;
   def_value[1] = 20;
   def_value[2] = 30;
 
   std::cout << "Creating a vector" << std::endl;
   Array<int> int_vect(10, 3, def_value, "test1");
 
-  for (unsigned int i = 5; i < int_vect.getSize(); ++i) {
+  for (unsigned int i = 5; i < int_vect.size(); ++i) {
     for (unsigned int j = 0; j < int_vect.getNbComponent(); ++j) {
       int_vect.storage()[i * int_vect.getNbComponent() + j] = def_value[j] * 10;
     }
   }
 
   std::cerr << int_vect;
 
   Vector<int> new_elem(3);
   new_elem(0) = 1;
   new_elem(1) = 2;
   new_elem(2) = 3;
   std::cout << "Testing push_back" << std::endl;
   int_vect.push_back(new_elem);
 
   int_vect.push_back(200);
 
   int_vect.erase(0);
 
   std::cerr << int_vect;
   akantu::Array<int> int_vect0(0, 3, def_value, "test2");
   std::cerr << int_vect0;
   int_vect0.push_back(new_elem);
   std::cerr << int_vect0;
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_fe_engine/test_facet_element_mapping.cc b/test/test_fe_engine/test_facet_element_mapping.cc
index 0dccaed58..afc98b762 100644
--- a/test/test_fe_engine/test_facet_element_mapping.cc
+++ b/test/test_fe_engine/test_facet_element_mapping.cc
@@ -1,120 +1,120 @@
 /**
  * @file   test_facet_element_mapping.cc
  *
  * @author Dana Christen <dana.christen@gmail.com>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Mon Jul 13 2015
  *
  * @brief  Test of the MeshData class
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "mesh.hh"
 #include "mesh_utils.hh"
 #include "aka_common.hh"
 #include "aka_error.hh"
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <string>
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 using namespace std;
 
 int main(int argc, char *argv[]) {
 // Testing the subelement-to-element mappings
   UInt spatial_dimension(3);
 
   akantu::initialize(argc, argv);
 
   Mesh mesh(spatial_dimension, "my_mesh");
   mesh.read("./cube_physical_names.msh");
 
   typedef Array< std::vector<Element> > ElemToSubelemMapping;
   typedef Array<Element>                SubelemToElemMapping;
 
   std::cout << "ELEMENT-SUBELEMENT MAPPING:" << std::endl;
 
   for (ghost_type_t::iterator git = ghost_type_t::begin();  git != ghost_type_t::end(); ++git) {
     Mesh::type_iterator tit  = mesh.firstType(spatial_dimension, *git);
     Mesh::type_iterator tend = mesh.lastType(spatial_dimension, *git);
 
     std::cout << "  " << "Ghost type: " << *git << std::endl;
     for (;tit != tend; ++tit) {
 
       const SubelemToElemMapping & subelement_to_element = mesh.getSubelementToElement(*tit, *git);
       std::cout << "  " << "  " << "Element type: " << *tit << std::endl;
 
       std::cout << "  " << "  " << "  " << "subelement_to_element:" << std::endl;
       subelement_to_element.printself(std::cout, 8);
 
-      for(UInt i(0); i < subelement_to_element.getSize(); ++i) {
+      for(UInt i(0); i < subelement_to_element.size(); ++i) {
         std::cout << "        ";
         for(UInt j(0); j < mesh.getNbFacetsPerElement(*tit); ++j) {
           if(subelement_to_element(i, j) != ElementNull) {
             subelement_to_element(i, j).printself(std::cout);
             std::cout << ", ";
           } else {
             std::cout << "ElementNull" << ", ";
           }
         }
         std::cout << "for element " << i << std::endl;
       }
     }
 
     tit  = mesh.firstType(spatial_dimension -1, *git);
     tend = mesh.lastType(spatial_dimension -1 , *git);
 
     for (;tit != tend; ++tit) {
 
       const ElemToSubelemMapping & element_to_subelement = mesh.getElementToSubelement(*tit, *git);
       std::cout << "  " << "  " << "Element type: " << *tit << std::endl;
 
       std::cout << "  " << "  " << "  " << "element_to_subelement:" << std::endl;
       element_to_subelement.printself(std::cout, 8);
 
-      for(UInt i(0); i < element_to_subelement.getSize(); ++i) {
+      for(UInt i(0); i < element_to_subelement.size(); ++i) {
         const std::vector<Element> & vec = element_to_subelement(i);
       std::cout << "          " ;
         std::cout << "item " << i << ": [ ";
         if(vec.size() > 0) {
           for(UInt j(0); j < vec.size(); ++j) {
             if(vec[j] != ElementNull) {
               std::cout << vec[j] << ", ";
             } else {
               std::cout << "ElementNull" << ", ";
             }
           }
         } else {
           std::cout << "empty, " ;
         }
       std::cout << "]" << ", " << std::endl;
       }
       std::cout << std::endl;
     }
 
   }
 
   return 0;
 }
 
diff --git a/test/test_fe_engine/test_gradient.cc b/test/test_fe_engine/test_gradient.cc
index 27a972529..bba6656c4 100644
--- a/test/test_fe_engine/test_gradient.cc
+++ b/test/test_fe_engine/test_gradient.cc
@@ -1,144 +1,144 @@
 /**
  * @file   test_gradient.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Peter Spijker <peter.spijker@epfl.ch>
  *
  * @date creation: Fri Sep 03 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  test of the fem class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  * @section DESCRIPTION
  *
  * This code is computing the gradient of a linear field and check that it gives
  * a constant result.  It also compute the gradient the  coordinates of the mesh
  * and check that it gives the identity
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "shape_lagrange.hh"
 #include "integrator_gauss.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstdlib>
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   akantu::initialize(argc, argv);
   debug::setDebugLevel(dblTest);
 
   const ElementType type = TYPE;
   UInt dim = ElementClass<type>::getSpatialDimension();
 
   Real eps = 1e-12;
   std::cout << "Epsilon : " << eps << std::endl;
 
   Mesh my_mesh(dim);
 
   std::stringstream meshfilename;
   meshfilename << type << ".msh";
   my_mesh.read(meshfilename.str());
 
   FEEngine * fem = new FEEngineTemplate<IntegratorGauss, ShapeLagrange>(
       my_mesh, dim, "my_fem");
 
   fem->initShapeFunctions();
 
   Real alpha[2][3] = {{13, 23, 31}, {11, 7, 5}};
 
   /// create the 2 component field
   const Array<Real> & position = fem->getMesh().getNodes();
   Array<Real> const_val(fem->getMesh().getNbNodes(), 2, "const_val");
 
   UInt nb_element = my_mesh.getNbElement(type);
   UInt nb_quadrature_points = fem->getNbIntegrationPoints(type) * nb_element;
 
   Array<Real> grad_on_quad(nb_quadrature_points, 2 * dim, "grad_on_quad");
-  for (UInt i = 0; i < const_val.getSize(); ++i) {
+  for (UInt i = 0; i < const_val.size(); ++i) {
     const_val(i, 0) = 0;
     const_val(i, 1) = 0;
 
     for (UInt d = 0; d < dim; ++d) {
       const_val(i, 0) += alpha[0][d] * position(i, d);
       const_val(i, 1) += alpha[1][d] * position(i, d);
     }
   }
 
   /// compute the gradient
   fem->gradientOnIntegrationPoints(const_val, grad_on_quad, 2, type);
 
   // std::cout << "Linear array on nodes : " << const_val << std::endl;
   // std::cout << "Gradient on quad : " << grad_on_quad << std::endl;
 
   /// check the results
   Array<Real>::matrix_iterator it = grad_on_quad.begin(2, dim);
   Array<Real>::matrix_iterator it_end = grad_on_quad.end(2, dim);
   for (; it != it_end; ++it) {
     for (UInt d = 0; d < dim; ++d) {
       Matrix<Real> & grad = *it;
       if (!(std::abs(grad(0, d) - alpha[0][d]) < eps) ||
           !(std::abs(grad(1, d) - alpha[1][d]) < eps)) {
         std::cout << "Error gradient is not correct " << (*it)(0, d) << " "
                   << alpha[0][d] << " (" << std::abs((*it)(0, d) - alpha[0][d])
                   << ")"
                   << " - " << (*it)(1, d) << " " << alpha[1][d] << " ("
                   << std::abs((*it)(1, d) - alpha[1][d]) << ")"
                   << " - " << d << std::endl;
         std::cout << *it << std::endl;
         exit(EXIT_FAILURE);
       }
     }
   }
 
   // compute gradient of coordinates
   Array<Real> grad_coord_on_quad(nb_quadrature_points, dim * dim,
                                  "grad_coord_on_quad");
   fem->gradientOnIntegrationPoints(my_mesh.getNodes(), grad_coord_on_quad,
                                    my_mesh.getSpatialDimension(), type);
 
   // std::cout << "Node positions : " << my_mesh.getNodes() << std::endl;
   // std::cout << "Gradient of nodes : " << grad_coord_on_quad << std::endl;
 
   Array<Real>::matrix_iterator itp = grad_coord_on_quad.begin(dim, dim);
   Array<Real>::matrix_iterator itp_end = grad_coord_on_quad.end(dim, dim);
 
   for (; itp != itp_end; ++itp) {
     for (UInt i = 0; i < dim; ++i) {
       for (UInt j = 0; j < dim; ++j) {
         if (!(std::abs((*itp)(i, j) - (i == j)) < eps)) {
           std::cout << *itp << std::endl;
           exit(EXIT_FAILURE);
         }
       }
     }
   }
 
   delete fem;
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_fe_engine/test_integrate.cc b/test/test_fe_engine/test_integrate.cc
index 87bfd0847..f9ca9251d 100644
--- a/test/test_fe_engine/test_integrate.cc
+++ b/test/test_fe_engine/test_integrate.cc
@@ -1,105 +1,105 @@
 /**
  * @file   test_integrate.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Peter Spijker <peter.spijker@epfl.ch>
  *
  * @date creation: Fri Sep 03 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  test of the fem class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "shape_lagrange.hh"
 #include "integrator_gauss.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstdlib>
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   akantu::initialize(argc, argv);
 
   debug::setDebugLevel(dblTest);
 
   const ElementType type = TYPE;
   UInt dim = ElementClass<type>::getSpatialDimension();
 
   Real eps = 3e-13;
   std::cout << "Epsilon : " << eps << std::endl;
 
   Mesh my_mesh(dim);
 
   std::stringstream meshfilename; meshfilename << type << ".msh";
   my_mesh.read(meshfilename.str());
 
   FEEngine *fem = new FEEngineTemplate<IntegratorGauss,ShapeLagrange>(my_mesh, dim, "my_fem");
 
   fem->initShapeFunctions();
 
   UInt nb_element = my_mesh.getNbElement(type);
   UInt nb_quadrature_points = fem->getNbIntegrationPoints(type) * nb_element;
 
   Array<Real> const_val(fem->getMesh().getNbNodes(), 2, "const_val");
   Array<Real> val_on_quad(nb_quadrature_points, 2 , "val_on_quad");
 
-  for (UInt i = 0; i < const_val.getSize(); ++i) {
+  for (UInt i = 0; i < const_val.size(); ++i) {
     const_val.storage()[i * 2 + 0] = 1.;
     const_val.storage()[i * 2 + 1] = 2.;
   }
 
   //interpolate function on quadrature points
   fem->interpolateOnIntegrationPoints(const_val, val_on_quad, 2, type);
 
   //integrate function on elements
   akantu::Array<akantu::Real> int_val_on_elem(nb_element, 2, "int_val_on_elem");
   fem->integrate(val_on_quad, int_val_on_elem, 2, type);
 
   // get global integration value
   Real value[2] = {0,0};
   std::cout << "Val on quads : " << val_on_quad << std::endl;
   std::cout << "Integral on elements : " << int_val_on_elem << std::endl;
 
   for (UInt i = 0; i < fem->getMesh().getNbElement(type); ++i) {
     value[0] += int_val_on_elem.storage()[2*i];
     value[1] += int_val_on_elem.storage()[2*i+1];
   }
 
   std::cout << "integral on the mesh of 1 is " << value[0] << " and of 2 is " << value[1] << std::endl;
 
   delete fem;
   finalize();
 
   if(!(std::abs(value[0] - 1.) < eps && std::abs(value[1] - 2.) < eps)) {
     std::cout << "|1 - " << value[0] << "| = " << std::abs(value[0] - 1.) << std::endl
 	      << "|2 - " << value[1] << "| = " << std::abs(value[1] - 2.) << std::endl;
     return EXIT_FAILURE;
   }
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_fe_engine/test_interpolate.cc b/test/test_fe_engine/test_interpolate.cc
index f1ef48cdb..9b8d626fd 100644
--- a/test/test_fe_engine/test_interpolate.cc
+++ b/test/test_fe_engine/test_interpolate.cc
@@ -1,92 +1,92 @@
 /**
  * @file   test_interpolate.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Sep 03 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  test of the fem class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "shape_lagrange.hh"
 #include "integrator_gauss.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstdlib>
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   akantu::initialize(argc, argv);
 
   debug::setDebugLevel(dblTest);
   const ElementType type = TYPE;
   UInt dim = ElementClass<type>::getSpatialDimension();
 
   Real eps = 3e-13;
   std::cout << "Epsilon : " << eps << std::endl;
 
   Mesh my_mesh(dim);
 
   std::stringstream meshfilename; meshfilename << type << ".msh";
   my_mesh.read(meshfilename.str());
 
   FEEngine *fem = new FEEngineTemplate<IntegratorGauss,ShapeLagrange>(my_mesh, dim, "my_fem");
 
   fem->initShapeFunctions();
 
   Array<Real> const_val(fem->getMesh().getNbNodes(), 2, "const_val");
 
   UInt nb_element = my_mesh.getNbElement(type);
   UInt nb_quadrature_points = fem->getNbIntegrationPoints(type) * nb_element;
 
   Array<Real> val_on_quad(nb_quadrature_points, 2, "val_on_quad");
 
-  for (UInt i = 0; i < const_val.getSize(); ++i) {
+  for (UInt i = 0; i < const_val.size(); ++i) {
     const_val.storage()[i * 2 + 0] = 1.;
     const_val.storage()[i * 2 + 1] = 2.;
   }
 
   fem->interpolateOnIntegrationPoints(const_val, val_on_quad, 2, type);
 
   std::cout << "Interpolation of array : " << const_val << std::endl;
   std::cout << "Gives on quads : " << val_on_quad << std::endl;
 
   // interpolate coordinates
   Array<Real> coord_on_quad(nb_quadrature_points, my_mesh.getSpatialDimension(), "coord_on_quad");
 
   fem->interpolateOnIntegrationPoints(my_mesh.getNodes(),
 				     coord_on_quad,
 				     my_mesh.getSpatialDimension(),
 				     type);
   std::cout << "Interpolations of node coordinates : " << my_mesh.getNodes() << std::endl;
   std::cout << "Gives : " << coord_on_quad << std::endl;
 
   delete fem;
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_geometry/test_segment_intersection_triangle_3.cc b/test/test_geometry/test_segment_intersection_triangle_3.cc
index bdf95a508..af6b1ccb2 100644
--- a/test/test_geometry/test_segment_intersection_triangle_3.cc
+++ b/test/test_geometry/test_segment_intersection_triangle_3.cc
@@ -1,145 +1,145 @@
 /**
  * @file   test_segment_intersection_triangle_3.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Clement Roux <clement.roux@epfl.ch>
  *
  * @date creation: Fri Feb 27 2015
  * @date last modification: Thu Jan 14 2016
  *
  * @brief  Tests the interface mesh generation
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #include "aka_common.hh"
 
 #include "mesh_segment_intersector.hh"
 #include "mesh_sphere_intersector.hh"
 #include "geom_helper_functions.hh"
 #include "mesh_geom_common.hh"
 
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 typedef Cartesian K;
 typedef Spherical SK;
 
 /* -------------------------------------------------------------------------- */
 
 int main (int argc, char * argv[]) {
   initialize("", argc, argv);
   debug::setDebugLevel(dblError);
 
   Math::setTolerance(1e-10);
 
   Mesh mesh(2), interface_mesh(2, "interface_mesh");
   mesh.read("test_geometry_triangle.msh");
 
   MeshSegmentIntersector<2, _triangle_3> intersector(mesh, interface_mesh);
   intersector.constructData();
 
   // Testing a segment going out of the mesh
   K::Point_3 a(0, 0.25, 0),
              b(1, 0.25, 0),
              c(0.25, 0, 0),
              d(0.25, 1, 0);
 
   K::Segment_3 h_interface(a, b),
                v_interface(c, d);
 
   std::list<K::Segment_3> interface_list;
   interface_list.push_back(h_interface);
   interface_list.push_back(v_interface);
 
   intersector.computeIntersectionQueryList(interface_list);
 
   if (interface_mesh.getNbElement(_segment_2) != 4)
     return EXIT_FAILURE;
 
   Vector<Real> bary(2);
   Element test;
   test.element = 0;
   test.type = _segment_2;
   
   interface_mesh.getBarycenter(test, bary);
   Real first_bary[] = {0.125, 0.25};
 
   if (!Math::are_vector_equal(2, bary.storage(), first_bary))
     return EXIT_FAILURE;
 
   // Testing a segment completely inside an element
   K::Point_3 e(0.1, 0.33, 0),
              f(0.1, 0.67, 0);
   K::Segment_3 inside_segment(e, f);
   intersector.computeIntersectionQuery(inside_segment);
 
   test.element = interface_mesh.getNbElement(_segment_2) - 1;
   interface_mesh.getBarycenter(test, bary);
 
   Real second_bary[] = {0.1, 0.5};
 
   if (!Math::are_vector_equal(2, bary.storage(), second_bary))
     return EXIT_FAILURE;
 
 #if 0
   // Spherical kernel testing the addition of nodes
-  std::cout << "initial mesh size = " << mesh.getNodes().getSize() << " nodes" << std::endl;
+  std::cout << "initial mesh size = " << mesh.getNodes().size() << " nodes" << std::endl;
 
   SK::Sphere_3 sphere(SK::Point_3(0, 1, 0), 0.2*0.2);
   SK::Sphere_3 sphere2(SK::Point_3(1, 0, 0), 0.4999999999);
   MeshSphereIntersector<2, _triangle_3> intersector_sphere(mesh);
   intersector_sphere.constructData();
 
   std::list<SK::Sphere_3> sphere_list;
   sphere_list.push_back(sphere);
   sphere_list.push_back(sphere2);
 
   intersector_sphere.computeIntersectionQueryList(sphere_list);
-  std::cout << "final mesh size = " << mesh.getNodes().getSize() << std::endl;
+  std::cout << "final mesh size = " << mesh.getNodes().size() << std::endl;
 
   const Array<UInt> new_node_triangle_3 = intersector_sphere.getNewNodePerElem();
   const Array<Real> & nodes = mesh.getNodes();
   std::cout << "New nodes :" << std::endl;
   std::cout << "node 5, x=" << nodes(4,0) << ", y=" << nodes(4,1) << std::endl;
   std::cout << "node 6, x=" << nodes(5,0) << ", y=" << nodes(5,1) << std::endl;
   std::cout << "node 7, x=" << nodes(6,0) << ", y=" << nodes(6,1) << std::endl;
 
   if ( (new_node_triangle_3(0,0) != 1) || (new_node_triangle_3(1,0) != 2)){
-    for(UInt k=0; k != new_node_triangle_3.getSize(); ++k){
+    for(UInt k=0; k != new_node_triangle_3.size(); ++k){
       std::cout << new_node_triangle_3(k,0) << " new nodes in element " << k << ", node(s): "
 		<< new_node_triangle_3(k,1) << ", " << new_node_triangle_3(k,3)
 		<< ", on segment(s):" << new_node_triangle_3(k,2) << ", "
 		<< new_node_triangle_3(k,4) << std::endl;
     }
     return EXIT_FAILURE;
   }
 #endif
 
   finalize();
   return EXIT_SUCCESS;
 }
 
 
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_20.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_20.cc
index 2934e326c..6f333311e 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_20.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_20.cc
@@ -1,143 +1,143 @@
 /**
  * @file   test_buildfacets_hexahedron_20.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with hexahedrons
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
   const ElementType type = _hexahedron_20;
 
   Mesh mesh(spatial_dimension);
   mesh.read("hexahedron_20.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   // debug::setDebugLevel(dblDump);
   // std::cout << mesh << std::endl;
   // std::cout << mesh_facets << std::endl;
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
   const ElementType type_subsubfacet = mesh.getFacetType(type_subfacet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel3 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_subfacet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subsubfacet);
 
 
   std::cout << "ElementToSubelement3" << std::endl;
-  for (UInt i = 0; i < el_to_subel3.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel3.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel3(i)[j].type << " " << el_to_subel3(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel2(i).size(); ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subsubfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el3 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type_facet);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_subfacet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement3" << std::endl;
-  for (UInt i = 0; i < subel_to_el3.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 6; ++j){
       std::cout << subel_to_el3(i, j).type << " " << subel_to_el3(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_8.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_8.cc
index 21f6a9261..f2f522c5d 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_8.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_hexahedron_8.cc
@@ -1,144 +1,144 @@
 /**
  * @file   test_buildfacets_hexahedron_8.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with hexahedrons
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
   const ElementType type = _hexahedron_8;
 
   Mesh mesh(spatial_dimension);
   mesh.read("hexahedron_8.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   // debug::setDebugLevel(dblDump);
   // std::cout << mesh << std::endl;
   // std::cout << mesh_facets << std::endl;
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
   const ElementType type_subsubfacet = mesh.getFacetType(type_subfacet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel3 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_subfacet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subsubfacet);
 
 
   std::cout << "ElementToSubelement3" << std::endl;
-  for (UInt i = 0; i < el_to_subel3.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel3.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel3(i)[j].type << " " << el_to_subel3(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel2(i).size(); ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subsubfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el3 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type_facet);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_subfacet);
 
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement3" << std::endl;
-  for (UInt i = 0; i < subel_to_el3.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 6; ++j){
       std::cout << subel_to_el3(i, j).type << " " << subel_to_el3(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_linear.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_linear.cc
index e9d6975a8..53d66cd95 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_linear.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_linear.cc
@@ -1,128 +1,128 @@
 /**
  * @file   test_buildfacets_mixed2d_linear.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with quadrangles
  * and triangles
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 2;
   const ElementType type1 = _quadrangle_4;
   const ElementType type2 = _triangle_3;
 
   Mesh mesh(spatial_dimension);
   mesh.read("mixed2d_linear.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet = mesh.getFacetType(type1);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subfacet);
 
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el2_1 = mesh_facets.getSubelementToElement(type1);
   const Array<Element> & subel_to_el2_2 = mesh_facets.getSubelementToElement(type2);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_facet);
 
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2_1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_1.size(); ++i) {
     std::cout << type1 << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2_1(i, j).type << " " << subel_to_el2_1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
-  for (UInt i = 0; i < subel_to_el2_2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_2.size(); ++i) {
     std::cout << type2 << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2_2(i, j).type << " " << subel_to_el2_2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_quadratic.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_quadratic.cc
index e13f63e65..ab9dbc264 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_quadratic.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed2d_quadratic.cc
@@ -1,128 +1,128 @@
 /**
  * @file   test_buildfacets_mixed2d_quadratic.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with quadrangles
  * and triangles
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 2;
   const ElementType type1 = _quadrangle_8;
   const ElementType type2 = _triangle_6;
 
   Mesh mesh(spatial_dimension);
   mesh.read("mixed2d_quadratic.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet = mesh.getFacetType(type1);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subfacet);
 
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el2_1 = mesh_facets.getSubelementToElement(type1);
   const Array<Element> & subel_to_el2_2 = mesh_facets.getSubelementToElement(type2);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_facet);
 
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2_1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_1.size(); ++i) {
     std::cout << type1 << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2_1(i, j).type << " " << subel_to_el2_1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
-  for (UInt i = 0; i < subel_to_el2_2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_2.size(); ++i) {
     std::cout << type2 << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2_2(i, j).type << " " << subel_to_el2_2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_linear.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_linear.cc
index 452d24767..7e4b17574 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_linear.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_linear.cc
@@ -1,167 +1,167 @@
 /**
  * @file   test_buildfacets_mixed3d_linear.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with hexahedrons
  * and pentahedrons
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
   const ElementType type1 = _hexahedron_8;
   const ElementType type2 = _pentahedron_6;
 
   Mesh mesh(spatial_dimension);
   mesh.read("mixed3d_linear.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet1 = mesh.getFacetType(type1);
   const ElementType type_facet2 = mesh.getFacetType(type2);
   const ElementType type_subfacet = mesh.getFacetType(type_facet1);
   const ElementType type_subsubfacet = mesh.getFacetType(type_subfacet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel3_1 = mesh_facets.getElementToSubelement(type_facet1);
   const Array< std::vector<Element> > & el_to_subel3_2 = mesh_facets.getElementToSubelement(type_facet2);
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_subfacet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subsubfacet);
 
   std::cout << "ElementToSubelement3" << std::endl;
-  for (UInt i = 0; i < el_to_subel3_1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel3_1.size(); ++i) {
     std::cout << type_facet1 << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel3_1(i)[j].type << " " << el_to_subel3_1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
-  for (UInt i = 0; i < el_to_subel3_2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel3_2.size(); ++i) {
     std::cout << type_facet2 << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel3_2(i)[j].type << " " << el_to_subel3_2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel2(i).size(); ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subsubfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el3_1 = mesh_facets.getSubelementToElement(type1);
   const Array<Element> & subel_to_el3_2 = mesh_facets.getSubelementToElement(type2);
   const Array<Element> & subel_to_el2_1 = mesh_facets.getSubelementToElement(type_facet1);
   const Array<Element> & subel_to_el2_2 = mesh_facets.getSubelementToElement(type_facet2);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_subfacet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement3" << std::endl;
-  for (UInt i = 0; i < subel_to_el3_1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3_1.size(); ++i) {
     std::cout << type1 << " " << i << " connected to ";
     for (UInt j = 0; j < 6; ++j){
       std::cout << subel_to_el3_1(i, j).type << " " << subel_to_el3_1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
-  for (UInt i = 0; i < subel_to_el3_2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3_2.size(); ++i) {
     std::cout << type2 << " " << i << " connected to ";
     for (UInt j = 0; j < 5; ++j){
       std::cout << subel_to_el3_2(i, j).type << " " << subel_to_el3_2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2_1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_1.size(); ++i) {
     std::cout << type_facet1 << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2_1(i, j).type << " " << subel_to_el2_1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
-  for (UInt i = 0; i < subel_to_el2_2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_2.size(); ++i) {
     std::cout << type_facet2 << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2_2(i, j).type << " " << subel_to_el2_2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_quadratic.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_quadratic.cc
index ab397a3d0..6218e2332 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_quadratic.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_mixed3d_quadratic.cc
@@ -1,169 +1,169 @@
 /**
  * @file   test_buildfacets_mixed3d_quadratic.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with hexahedrons
  * and pentahedrons
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
   const ElementType type1 = _hexahedron_20;
   const ElementType type2 = _pentahedron_15;
 
   Mesh mesh(spatial_dimension);
   mesh.read("mixed3d_quadratic.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet1 = mesh.getFacetType(type1);
   const ElementType type_facet2 = mesh.getFacetType(type2);
   const ElementType type_subfacet = mesh.getFacetType(type_facet1);
   const ElementType type_subsubfacet = mesh.getFacetType(type_subfacet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel3_1 = mesh_facets.getElementToSubelement(type_facet1);
   const Array< std::vector<Element> > & el_to_subel3_2 = mesh_facets.getElementToSubelement(type_facet2);
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_subfacet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subsubfacet);
 
   std::cout << "ElementToSubelement3" << std::endl;
-  for (UInt i = 0; i < el_to_subel3_1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel3_1.size(); ++i) {
     std::cout << type_facet1 << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel3_1(i)[j].type << " " << el_to_subel3_1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
-  for (UInt i = 0; i < el_to_subel3_2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel3_2.size(); ++i) {
     std::cout << type_facet2 << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel3_2(i)[j].type << " " << el_to_subel3_2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel2(i).size(); ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subsubfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el3_1 = mesh_facets.getSubelementToElement(type1);
   const Array<Element> & subel_to_el3_2 = mesh_facets.getSubelementToElement(type2);
   const Array<Element> & subel_to_el2_1 = mesh_facets.getSubelementToElement(type_facet1);
   const Array<Element> & subel_to_el2_2 = mesh_facets.getSubelementToElement(type_facet2);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_subfacet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement3" << std::endl;
-  for (UInt i = 0; i < subel_to_el3_1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3_1.size(); ++i) {
     std::cout << type1 << " " << i << " connected to ";
     for (UInt j = 0; j < 6; ++j){
       std::cout << subel_to_el3_1(i, j).type << " " << subel_to_el3_1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
-  for (UInt i = 0; i < subel_to_el3_2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3_2.size(); ++i) {
     std::cout << type2 << " " << i << " connected to ";
     for (UInt j = 0; j < 5; ++j){
       std::cout << subel_to_el3_2(i, j).type << " " << subel_to_el3_2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2_1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_1.size(); ++i) {
     std::cout << type_facet1 << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2_1(i, j).type << " " << subel_to_el2_1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2_2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2_2.size(); ++i) {
     std::cout << type_facet2 << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2_2(i, j).type << " " << subel_to_el2_2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_15.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_15.cc
index 1b63049d6..edbc6368a 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_15.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_15.cc
@@ -1,148 +1,148 @@
 /**
  * @file   test_buildfacets_pentahedron_15.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Mon Sep 28 2015
  *
  * @brief  Test for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
   const ElementType type = _pentahedron_15;
 
   Mesh mesh(spatial_dimension);
   mesh.read("pentahedron_15.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   Vector<ElementType> types_facet = mesh.getAllFacetTypes(type);
   const ElementType type_subfacet = mesh.getFacetType(types_facet(0));
   const ElementType type_subsubfacet = mesh.getFacetType(type_subfacet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   for (UInt ft = 0; ft < types_facet.size(); ++ft) {
     ElementType type_facet = types_facet(ft);
     Array< std::vector<Element> > & el_to_subel3 = mesh_facets.getElementToSubelement(type_facet);
 
     std::cout << "ElementToSubelement3" << std::endl;
-    for (UInt i = 0; i < el_to_subel3.getSize(); ++i) {
+    for (UInt i = 0; i < el_to_subel3.size(); ++i) {
       std::cout << type_facet << " " << i << " connected to ";
       for (UInt j = 0; j < 2; ++j){
 	std::cout << el_to_subel3(i)[j].type << " " << el_to_subel3(i)[j].element << ", ";
       }
       std::cout << " " << std::endl;
     }
   }
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_subfacet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subsubfacet);
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel2(i).size(); ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subsubfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el3 = mesh_facets.getSubelementToElement(type);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement3" << std::endl;
-  for (UInt i = 0; i < subel_to_el3.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < subel_to_el3.getNbComponent(); ++j){
       std::cout << subel_to_el3(i, j).type << " " << subel_to_el3(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   for (UInt ft = 0; ft < types_facet.size(); ++ft) {
     ElementType type_facet = types_facet(ft);
     Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type_facet);
 
     std::cout << "SubelementToElement2" << std::endl;
-    for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+    for (UInt i = 0; i < subel_to_el2.size(); ++i) {
       std::cout << type_facet << " " << i << " connected to ";
       for (UInt j = 0; j < subel_to_el2.getNbComponent(); ++j){
 	std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
       }
       std::cout << " " << std::endl;
     }
   }
   
 
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_subfacet);
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < subel_to_el1.getNbComponent(); ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_6.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_6.cc
index 36b8b0033..c42d32ad9 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_6.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_pentahedron_6.cc
@@ -1,148 +1,148 @@
 /**
  * @file   test_buildfacets_pentahedron_6.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Mon Sep 28 2015
  *
  * @brief  Test for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
   const ElementType type = _pentahedron_6;
 
   Mesh mesh(spatial_dimension);
   mesh.read("pentahedron_6.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   Vector<ElementType> types_facet = mesh.getAllFacetTypes(type);
   const ElementType type_subfacet = mesh.getFacetType(types_facet(0));
   const ElementType type_subsubfacet = mesh.getFacetType(type_subfacet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   for (UInt ft = 0; ft < types_facet.size(); ++ft) {
     ElementType type_facet = types_facet(ft);
     Array< std::vector<Element> > & el_to_subel3 = mesh_facets.getElementToSubelement(type_facet);
 
     std::cout << "ElementToSubelement3" << std::endl;
-    for (UInt i = 0; i < el_to_subel3.getSize(); ++i) {
+    for (UInt i = 0; i < el_to_subel3.size(); ++i) {
       std::cout << type_facet << " " << i << " connected to ";
       for (UInt j = 0; j < 2; ++j){
 	std::cout << el_to_subel3(i)[j].type << " " << el_to_subel3(i)[j].element << ", ";
       }
       std::cout << " " << std::endl;
     }
   }
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_subfacet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subsubfacet);
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel2(i).size(); ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subsubfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el3 = mesh_facets.getSubelementToElement(type);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement3" << std::endl;
-  for (UInt i = 0; i < subel_to_el3.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < subel_to_el3.getNbComponent(); ++j){
       std::cout << subel_to_el3(i, j).type << " " << subel_to_el3(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   for (UInt ft = 0; ft < types_facet.size(); ++ft) {
     ElementType type_facet = types_facet(ft);
     Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type_facet);
 
     std::cout << "SubelementToElement2" << std::endl;
-    for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+    for (UInt i = 0; i < subel_to_el2.size(); ++i) {
       std::cout << type_facet << " " << i << " connected to ";
       for (UInt j = 0; j < subel_to_el2.getNbComponent(); ++j){
 	std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
       }
       std::cout << " " << std::endl;
     }
   }
   
 
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_subfacet);
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < subel_to_el1.getNbComponent(); ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_4.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_4.cc
index c8c002fe8..c1eac301f 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_4.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_4.cc
@@ -1,116 +1,116 @@
 /**
  * @file   test_buildfacets_quadrangle_4.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with quadrangles
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 2;
   const ElementType type = _quadrangle_4;
 
   Mesh mesh(spatial_dimension);
   mesh.read("quadrangle_4.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subfacet);
 
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_facet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_8.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_8.cc
index 513ac474d..2d46360bc 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_8.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_quadrangle_8.cc
@@ -1,116 +1,116 @@
 /**
  * @file   test_buildfacets_quadrangle_8.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with quadrangles
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 2;
   const ElementType type = _quadrangle_8;
 
   Mesh mesh(spatial_dimension);
   mesh.read("quadrangle_8.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subfacet);
 
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_facet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_tetrahedron_10.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_tetrahedron_10.cc
index 8b9767f68..cb4f19930 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_tetrahedron_10.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_tetrahedron_10.cc
@@ -1,143 +1,143 @@
 /**
  * @file   test_buildfacets_tetrahedron_10.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
   const ElementType type = _tetrahedron_10;
 
   Mesh mesh(spatial_dimension);
   mesh.read("tetrahedron_10.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   // debug::setDebugLevel(dblDump);
   // std::cout << mesh << std::endl;
   // std::cout << mesh_facets << std::endl;
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
   const ElementType type_subsubfacet = mesh.getFacetType(type_subfacet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel3 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_subfacet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subsubfacet);
 
 
   std::cout << "ElementToSubelement3" << std::endl;
-  for (UInt i = 0; i < el_to_subel3.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel3.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel3(i)[j].type << " " << el_to_subel3(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel2(i).size(); ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subsubfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el3 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type_facet);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_subfacet);
 
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement3" << std::endl;
-  for (UInt i = 0; i < subel_to_el3.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el3.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 4; ++j){
       std::cout << subel_to_el3(i, j).type << " " << subel_to_el3(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc
index 604241e37..06e5b546c 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_3.cc
@@ -1,116 +1,116 @@
 /**
  * @file   test_buildfacets_triangle_3.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with triangles
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 2;
   const ElementType type = _triangle_3;
 
   Mesh mesh(spatial_dimension);
   mesh.read("triangle_3.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subfacet);
 
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_facet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_6.cc b/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_6.cc
index b28d0c719..ed5fe2ea1 100644
--- a/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_6.cc
+++ b/test/test_mesh_utils/test_buildfacets/test_buildfacets_triangle_6.cc
@@ -1,116 +1,116 @@
 /**
  * @file   test_buildfacets_triangle_6.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  * @date last modification: Sat Sep 19 2015
  *
  * @brief  Test to check the building of the facets. Mesh with triangles
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 #include <limits>
 #include <fstream>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 2;
   const ElementType type = _triangle_6;
 
   Mesh mesh(spatial_dimension);
   mesh.read("triangle_6.msh");
   Mesh & mesh_facets = mesh.initMeshFacets("mesh_facets");
 
   MeshUtils::buildAllFacets(mesh, mesh_facets);
 
   const ElementType type_facet = mesh.getFacetType(type);
   const ElementType type_subfacet = mesh.getFacetType(type_facet);
 
   /* ------------------------------------------------------------------------ */
   /* Element to Subelement testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array< std::vector<Element> > & el_to_subel2 = mesh_facets.getElementToSubelement(type_facet);
   const Array< std::vector<Element> > & el_to_subel1 = mesh_facets.getElementToSubelement(type_subfacet);
 
 
   std::cout << "ElementToSubelement2" << std::endl;
-  for (UInt i = 0; i < el_to_subel2.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel2.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << el_to_subel2(i)[j].type << " " << el_to_subel2(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "ElementToSubelement1" << std::endl;
-  for (UInt i = 0; i < el_to_subel1.getSize(); ++i) {
+  for (UInt i = 0; i < el_to_subel1.size(); ++i) {
     std::cout << type_subfacet << " " << i << " connected to ";
     for (UInt j = 0; j < el_to_subel1(i).size(); ++j){
       std::cout << el_to_subel1(i)[j].type << " " << el_to_subel1(i)[j].element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   /* ------------------------------------------------------------------------ */
   /* Subelement to Element testing                                            */
   /* ------------------------------------------------------------------------ */
 
   const Array<Element> & subel_to_el2 = mesh_facets.getSubelementToElement(type);
   const Array<Element> & subel_to_el1 = mesh_facets.getSubelementToElement(type_facet);
 
   std::cout << " " << std::endl;
   std::cout << "SubelementToElement2" << std::endl;
-  for (UInt i = 0; i < subel_to_el2.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el2.size(); ++i) {
     std::cout << type << " " << i << " connected to ";
     for (UInt j = 0; j < 3; ++j){
       std::cout << subel_to_el2(i, j).type << " " << subel_to_el2(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
   std::cout << "SubelementToElement1" << std::endl;
-  for (UInt i = 0; i < subel_to_el1.getSize(); ++i) {
+  for (UInt i = 0; i < subel_to_el1.size(); ++i) {
     std::cout << type_facet << " " << i << " connected to ";
     for (UInt j = 0; j < 2; ++j){
       std::cout << subel_to_el1(i, j).type << " " << subel_to_el1(i, j).element << ", ";
     }
     std::cout << " " << std::endl;
   }
 
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_mesh_io/test_mesh_io_msh_physical_names.cc b/test/test_mesh_utils/test_mesh_io/test_mesh_io_msh_physical_names.cc
index bf2775f1e..8139c5d02 100644
--- a/test/test_mesh_utils/test_mesh_io/test_mesh_io_msh_physical_names.cc
+++ b/test/test_mesh_utils/test_mesh_io/test_mesh_io_msh_physical_names.cc
@@ -1,58 +1,58 @@
 /**
  * @file   test_mesh_io_msh_physical_names.cc
  *
  * @author Dana Christen <dana.christen@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  unit test for the MeshIOMSH physical names class
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include <iostream>
 #include <sstream>
 #include "aka_common.hh"
 #include "mesh.hh"
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char* argv[]) {
   UInt spatialDimension(3);
 
   akantu::initialize(argc, argv);
 
   Mesh mesh(spatialDimension);
 
   mesh.read("./cube_physical_names.msh");
   std::stringstream sstr;
 
   for(Mesh::type_iterator type_it = mesh.firstType(); type_it != mesh.lastType(); ++type_it) {
     const Array<std::string> & name_vec = mesh.getData<std::string>("physical_names", *type_it);
-    for(UInt i(0); i < name_vec.getSize(); i++) {
+    for(UInt i(0); i < name_vec.size(); i++) {
       std::cout << "Element " << i << " (of type " << *type_it << ") has physical name " << name_vec(i) << "." << std::endl;
     }
   }
 
   akantu::finalize();
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc b/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc
index a3d7bb111..bdd4aece5 100644
--- a/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc
+++ b/test/test_mesh_utils/test_segment_nodetype/test_segment_nodetype.cc
@@ -1,97 +1,97 @@
 /**
  * @file   test_segment_nodetype.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Sep 18 2015
  *
  * @brief  Test to verify that the node type is correctly associated to
  * the segments in parallel
  *
  * @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 "element_synchronizer.hh"
 #include "mesh_utils.hh"
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt spatial_dimension = 3;
   Mesh mesh(spatial_dimension);
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   // partition the mesh
   if (prank == 0) {
     mesh.read("mesh.msh");
   }
 
   mesh.distribute();
 
   // compute the node types for each segment
   Mesh & mesh_facets = mesh.initMeshFacets();
   MeshUtils::buildSegmentToNodeType(mesh, mesh_facets);
 
   // verify that the number of segments per node type makes sense
   std::map<Int, UInt> nb_facets_per_nodetype;
   UInt nb_segments = 0;
 
   for (auto ghost_type : ghost_types) {
     const Array<Int> & segment_to_nodetype =
         mesh_facets.getData<Int>("segment_to_nodetype", _segment_2, ghost_type);
 
     // count the number of segments per node type
     for (auto & stn : segment_to_nodetype) {
       if (nb_facets_per_nodetype.find(stn) == nb_facets_per_nodetype.end())
         nb_facets_per_nodetype[stn] = 1;
       else
         ++nb_facets_per_nodetype[stn];
     }
-    nb_segments += segment_to_nodetype.getSize();
+    nb_segments += segment_to_nodetype.size();
   }
 
   // checking the solution
   if (nb_segments != 24)
     AKANTU_DEBUG_ERROR("The number of segments is wrong");
 
   if (prank == 0) {
     if (nb_facets_per_nodetype[-1] != 3 || nb_facets_per_nodetype[-2] != 9 ||
         nb_facets_per_nodetype[-3] != 12)
       AKANTU_DEBUG_ERROR(
           "The segments of processor 0 have the wrong node type");
 
     if (nb_facets_per_nodetype.size() > 3)
       AKANTU_DEBUG_ERROR("Processor 0 cannot have any slave segment");
   }
 
   if (prank == psize - 1 &&
       nb_facets_per_nodetype.find(-2) != nb_facets_per_nodetype.end())
     AKANTU_DEBUG_ERROR("The last processor must not have any master facets");
 
   finalize();
   return 0;
 }
diff --git a/test/test_model/test_model_solver/test_model_solver.cc b/test/test_model/test_model_solver/test_model_solver.cc
index f8702519e..25f90687c 100644
--- a/test/test_model/test_model_solver/test_model_solver.cc
+++ b/test/test_model/test_model_solver/test_model_solver.cc
@@ -1,155 +1,156 @@
 /**
  * @file   test_dof_manager_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Feb 24 12:28:44 2016
  *
  * @brief  Test default dof manager
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_random_generator.hh"
 #include "dof_manager.hh"
 #include "dof_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_accessor.hh"
 #include "model_solver.hh"
 #include "non_linear_solver_newton_raphson.hh"
 #include "sparse_matrix.hh"
 #include "sparse_solver_mumps.hh"
 
 /* -------------------------------------------------------------------------- */
 #include "test_model_solver_my_model.hh"
 /* -------------------------------------------------------------------------- */
 #include <cmath>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 static void genMesh(Mesh & mesh, UInt nb_nodes);
 static void printResults(MyModel & model, UInt nb_nodes);
 
 Real F = -10;
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt prank = StaticCommunicator::getStaticCommunicator().whoAmI();
 
   std::cout << std::setprecision(7);
 
   UInt global_nb_nodes = 100;
   Mesh mesh(1);
 
   RandomGenerator<UInt>::seed(1);
 
   if (prank == 0) {
     genMesh(mesh, global_nb_nodes);
   }
 
   //std::cout << prank << RandGenerator<Real>::seed() << std::endl;
 
   mesh.distribute();
 
   MyModel model(F, mesh, false);
 
   model.getNewSolver("static", _tsst_static, _nls_newton_raphson);
   model.setIntegrationScheme("static", "disp", _ist_pseudo_time);
 
   NonLinearSolver & solver =
       model.getDOFManager().getNonLinearSolver("static");
   solver.set("max_iterations", 2);
 
 
   model.solveStep();
 
   dynamic_cast<NonLinearSolverNewtonRaphson &>(
       model.getDOFManager().getNonLinearSolver("static"))
       .getSolver()
       .analysis();
 
   printResults(model, global_nb_nodes);
 
   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);
+  mesh_accessor.setNbGlobalNodes(nb_nodes);
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     nodes(n, _x) = n * (1. / (nb_nodes - 1));
   }
 
   conn.resize(nb_nodes - 1);
   for (UInt n = 0; n < nb_nodes - 1; ++n) {
     conn(n, 0) = n;
     conn(n, 1) = n + 1;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void printResults(MyModel & model, UInt nb_nodes) {
   UInt prank = StaticCommunicator::getStaticCommunicator().whoAmI();
   auto & sync = dynamic_cast<DOFManagerDefault &>(model.getDOFManager())
     .getSynchronizer();
 
   if (prank == 0) {
     Array<Real> global_displacement(nb_nodes);
     Array<Real> global_forces(nb_nodes);
     Array<bool> global_blocked(nb_nodes);
 
     sync.gather(model.forces, global_forces);
     sync.gather(model.displacement, global_displacement);
     sync.gather(model.blocked, global_blocked);
 
     auto force_it = global_forces.begin();
     auto disp_it = global_displacement.begin();
     auto blocked_it = global_blocked.begin();
 
     std::cout << "node"
               << ", " << std::setw(8) << "disp"
               << ", " << std::setw(8) << "force"
               << ", " << std::setw(8) << "blocked" << std::endl;
 
     UInt node = 0;
     for (; disp_it != global_displacement.end();
          ++disp_it, ++force_it, ++blocked_it, ++node) {
       std::cout << node << ", " << std::setw(8) << *disp_it << ", "
                 << std::setw(8) << *force_it << ", " << std::setw(8)
                 << *blocked_it << std::endl;
 
       std::cout << std::flush;
     }
   } else {
     sync.gather(model.forces);
     sync.gather(model.displacement);
     sync.gather(model.blocked);
   }
 }
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 2c1e95045..c0fcaffd0 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,443 +1,447 @@
 /**
  * @file   test_dof_manager_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Feb 24 12:28:44 2016
  *
  * @brief  Test default dof manager
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
+#include "aka_iterators.hh"
 #include "data_accessor.hh"
 #include "dof_manager_default.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "model_solver.hh"
 #include "sparse_matrix.hh"
 #include "static_communicator.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, "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"),
+      : ModelSolver(mesh, "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);
 
     this->getDOFManager().getNewMatrix("K", _symmetric);
     this->getDOFManager().getNewMatrix("M", "K");
     this->getDOFManager().getNewMatrix("J", "K");
 
     this->getDOFManager().getNewLumpedMatrix("M");
 
     if (lumped) {
       this->assembleLumpedMass();
     } else {
       this->assembleMass();
       this->assembleStiffness();
     }
     this->assembleJacobian();
 
     displacement.set(0.);
     velocity.set(0.);
     acceleration.set(0.);
 
     forces.set(0.);
     blocked.set(false);
 
     UInt global_nb_nodes = mesh.getNbGlobalNodes();
-    for (UInt n = 0; n < nb_dofs; ++n) {
-      if (mesh.getNodeGlobalId(n) == (global_nb_nodes - 1))
+    for (auto && n : arange(nb_dofs)) {
+      auto global_id = mesh.getNodeGlobalId(n);
+      if (global_id == (global_nb_nodes - 1))
         forces(n, _x) = F;
 
-      if (mesh.getGlobalNodesIds()(n) == 0)
+      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);
   }
 
   void assembleLumpedMass(const GhostType & ghost_type) {
     Array<Real> & M = this->getDOFManager().getLumpedMatrix("M");
 
     Array<Real> m_all_el(this->mesh.getNbElement(_segment_2, ghost_type), 2);
 
     Array<Real>::vector_iterator 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);
   }
 
   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);
   }
 
   void assembleJacobian() {}
   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);
   }
 
   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 = StaticCommunicator::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);
+    //       UInt global_dof =
+    //       dof_manager_default.localToGlobalEquationNumber(local_dof);
     //       std::cout << local_dof << " [" << global_dof << " - "
-    //                 << dof_manager_default.getDOFType(local_dof) << "]: " << res
+    //                 << 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;
       }
 
       StaticCommunicator::getStaticCommunicator().allReduce(res, _so_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;
       }
 
       StaticCommunicator::getStaticCommunicator().allReduce(res, _so_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;
     }
 
     StaticCommunicator::getStaticCommunicator().allReduce(res, _so_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;
     }
 
     StaticCommunicator::getStaticCommunicator().allReduce(res, _so_sum);
     return res;
   }
 
   void predictor() {}
   void corrector() {}
 
   /* ------------------------------------------------------------------------ */
   UInt getNbData(const Array<Element> & elements,
                  const SynchronizationTag &) const {
-    return elements.getSize() * sizeof(Real);
+    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;
 
 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
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc
index b66df16a0..d790d026a 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic/test_cohesive_extrinsic_fatigue.cc
@@ -1,243 +1,243 @@
 /**
  * @file   test_cohesive_extrinsic_fatigue.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Feb 20 2015
  * @date last modification: Thu Jun 25 2015
  *
  * @brief  Test for the linear fatigue cohesive law
  *
  * @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 "material_cohesive_linear_fatigue.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include <limits>
 
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 // the following class contains an implementation of the 1D linear
 // fatigue cohesive law
 class MaterialFatigue {
 public:
   MaterialFatigue(Real delta_f, Real sigma_c, Real delta_c)
       : delta_f(delta_f), sigma_c(sigma_c), delta_c(delta_c), delta_prec(0),
         traction(sigma_c), delta_max(0),
         stiff_plus(std::numeric_limits<Real>::max()),
         tolerance(Math::getTolerance()){};
 
   Real computeTraction(Real delta) {
     if (delta - delta_c > -tolerance)
       traction = 0;
     else if (delta_max < tolerance && delta < tolerance)
       traction = sigma_c;
     else {
       Real delta_dot = delta - delta_prec;
 
       if (delta_dot > -tolerance) {
         stiff_plus *= 1 - delta_dot / delta_f;
         traction += stiff_plus * delta_dot;
         Real max_traction = sigma_c * (1 - delta / delta_c);
 
         if (traction - max_traction > -tolerance || delta_max < tolerance) {
           traction = max_traction;
           stiff_plus = traction / delta;
         }
       } else {
         Real stiff_minus = traction / delta_prec;
         stiff_plus += (stiff_plus - stiff_minus) * delta_dot / delta_f;
         traction += stiff_minus * delta_dot;
       }
     }
 
     delta_prec = delta;
     delta_max = std::max(delta, delta_max);
     return traction;
   }
 
 private:
   const Real delta_f;
   const Real sigma_c;
   const Real delta_c;
   Real delta_prec;
   Real traction;
   Real delta_max;
   Real stiff_plus;
   const Real tolerance;
 };
 
 void imposeOpening(SolidMechanicsModelCohesive &, Real);
 void arange(Array<Real> &, Real, Real, Real);
 
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize("material_fatigue.dat", argc, argv);
 
   Math::setTolerance(1e-13);
 
   const UInt spatial_dimension = 2;
   const ElementType type = _quadrangle_4;
 
   Mesh mesh(spatial_dimension);
   mesh.read("fatigue.msh");
 
   // init stuff
   const ElementType type_facet = Mesh::getFacetType(type);
   const ElementType type_cohesive =
       FEEngine::getCohesiveElementType(type_facet);
 
   SolidMechanicsModelCohesive model(mesh);
   model.initFull(
       SolidMechanicsModelCohesiveOptions(_explicit_lumped_mass, true));
 
   MaterialCohesiveLinearFatigue<2> & numerical_material =
       dynamic_cast<MaterialCohesiveLinearFatigue<2> &>(
           model.getMaterial("cohesive"));
 
   Real delta_f = numerical_material.getParam("delta_f");
   Real delta_c = numerical_material.getParam("delta_c");
   Real sigma_c = 1;
 
   const Array<Real> & traction_array =
       numerical_material.getTraction(type_cohesive);
 
   MaterialFatigue theoretical_material(delta_f, sigma_c, delta_c);
 
   // model.setBaseName("fatigue");
   // model.addDumpFieldVector("displacement");
   // model.addDumpField("stress");
   // model.dump();
 
   // stretch material
   Real strain = 1;
   Array<Real> & displacement = model.getDisplacement();
   const Array<Real> & position = mesh.getNodes();
 
   for (UInt n = 0; n < mesh.getNbNodes(); ++n)
     displacement(n, 0) = position(n, 0) * strain;
 
   model.assembleInternalForces();
   // model.dump();
 
   // insert cohesive elements
   model.checkCohesiveStress();
 
   // create the displacement sequence
   Real increment = 0.01;
 
   Array<Real> openings;
 
   arange(openings, 0, 0.5, increment);
   arange(openings, 0.5, 0.1, increment);
   arange(openings, 0.1, 0.7, increment);
   arange(openings, 0.7, 0.3, increment);
   arange(openings, 0.3, 0.6, increment);
   arange(openings, 0.6, 0.3, increment);
   arange(openings, 0.3, 0.7, increment);
   arange(openings, 0.7, 1.3, increment);
 
   const Array<UInt> & switches = numerical_material.getSwitches(type_cohesive);
 
   // std::ofstream edis("fatigue_edis.txt");
 
   // impose openings
-  for (UInt i = 0; i < openings.getSize(); ++i) {
+  for (UInt i = 0; i < openings.size(); ++i) {
 
     // compute numerical traction
     imposeOpening(model, openings(i));
     model.assembleInternalForces();
     // model.dump();
     Real numerical_traction = traction_array(0, 0);
 
     // compute theoretical traction
     Real theoretical_traction =
         theoretical_material.computeTraction(openings(i));
 
     // test traction
     if (std::abs(numerical_traction - theoretical_traction) > 1e-13)
       AKANTU_DEBUG_ERROR("The numerical traction "
                          << numerical_traction << " and theoretical traction "
                          << theoretical_traction << " are not coincident");
 
     // edis << model.getEnergy("dissipated") << std::endl;
   }
 
   if (switches(0) != 7)
     AKANTU_DEBUG_ERROR("The number of switches is wrong");
 
   std::cout << "OK: the test_cohesive_extrinsic_fatigue passed." << std::endl;
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 
 void imposeOpening(SolidMechanicsModelCohesive & model, Real opening) {
 
   UInt spatial_dimension = model.getSpatialDimension();
   Mesh & mesh = model.getFEEngine().getMesh();
   Array<Real> & position = mesh.getNodes();
   Array<Real> & displacement = model.getDisplacement();
   UInt nb_nodes = mesh.getNbNodes();
 
   Array<bool> update(nb_nodes);
   update.clear();
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension);
 
   for (; it != end; ++it) {
     ElementType type = *it;
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
     const Array<UInt> & connectivity = mesh.getConnectivity(type);
     Vector<Real> barycenter(spatial_dimension);
 
     for (UInt el = 0; el < nb_element; ++el) {
       mesh.getBarycenter(el, type, barycenter.storage());
       if (barycenter(0) > 1) {
         for (UInt n = 0; n < nb_nodes_per_element; ++n) {
           UInt node = connectivity(el, n);
           if (!update(node)) {
             displacement(node, 0) = opening + position(node, 0);
             update(node) = true;
           }
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void arange(Array<Real> & openings, Real begin, Real end, Real increment) {
   if (begin < end) {
     for (Real opening = begin; opening < end - increment / 2.;
          opening += increment)
       openings.push_back(opening);
   } else {
     for (Real opening = begin; opening > end + increment / 2.;
          opening -= increment)
       openings.push_back(opening);
   }
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc
index 141d59821..1c5ce3f3a 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_extrinsic_implicit/test_assembling_K_cohe_elements.cc
@@ -1,171 +1,171 @@
 /**
  * @file   test_assembling_K_cohe_elements.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  *
  * @date creation: Fri May 15 2015
  * @date last modification: Thu Aug 20 2015
  *
  * @brief  Test to check the correct matrix assembling for cohesive elements
  * with degenerated nodes
  *
  * @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 "dof_manager.hh"
 #include "non_linear_solver.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "sparse_matrix.hh"
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 #include <limits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize("material.dat", argc, argv);
 
   debug::setDebugLevel(dblWarning);
 
   const UInt spatial_dimension = 2;
   Real increment = 0.004;
   bool passed = true;
   Real tol = 1.0e-13;
 
   Mesh mesh(spatial_dimension);
   mesh.read("quadrangle.msh");
 
   SolidMechanicsModelCohesive model(mesh);
 
   /// model initialization
   model.initFull(SolidMechanicsModelCohesiveOptions(_static, true));
 
   ///  CohesiveElementInserter
   model.limitInsertion(_y, -0.001, 0.001);
   model.updateAutomaticInsertion();
 
   Array<bool> & boundary = model.getBlockedDOFs();
   Array<Real> & position = mesh.getNodes();
   Array<Real> & displacement = model.getDisplacement();
   // SparseMatrix & K_test = model.getStiffnessMatrix();
   Array<Real> K_verified(0, 3, "K_matrix_verified");
   Array<Real> K_test(0, 3, "K_matrix_test");
 
   /// load the verified stiffness matrix
   Vector<Real> tmp(3);
   UInt nb_lines;
 
   std::ifstream infile("K_matrix_verified.dat");
   std::string line;
   if (!infile.good())
     AKANTU_DEBUG_ERROR("Cannot open file K_matrix_verified.dat");
   else {
     for (UInt i = 0; i < 2; ++i) {
       getline(infile, line);
       std::stringstream sstr_data(line);
       if (i == 1) {
         sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
         nb_lines = tmp(2);
       }
     }
 
     for (UInt i = 0; i < nb_lines; ++i) {
       getline(infile, line);
       std::stringstream sstr_data(line);
       sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
       K_verified.push_back(tmp);
     }
   }
   infile.close();
 
   /// impose boundary conditions
   for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
     if (position(n, 1) < -0.99) {
       boundary(n, 1) = true;
       boundary(n, 0) = true;
     }
     if (position(n, 1) > 0.99 && position(n, 0) < -0.99)
       boundary(n, 1) = true;
   }
 
   /// solve step
   for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
     if (position(n, 1) > 0.99 && position(n, 0) < -0.99)
       displacement(n, 1) += increment;
   }
 
   auto & solver = model.getNonLinearSolver();
   solver.set("max_iterations", 10);
   solver.set("threshold", 1e-13);
 
   model.solveStep();
 
   model.getDOFManager().getMatrix("K").saveMatrix("K_matrix_test.dat");
 
   /// load the stiffness matrix to be tested
   std::ifstream infile2("K_matrix_test.dat");
   if (!infile2.good())
     AKANTU_DEBUG_ERROR("Cannot open file K_matrix_test.dat");
   else {
     for (UInt i = 0; i < 2; ++i) {
       getline(infile2, line);
       std::stringstream sstr_data(line);
       if (i == 1) {
         sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
         nb_lines = tmp(2);
       }
     }
 
     for (UInt i = 0; i < nb_lines; ++i) {
       getline(infile2, line);
       std::stringstream sstr_data(line);
       sstr_data >> tmp(0) >> tmp(1) >> tmp(2);
       K_test.push_back(tmp);
     }
   }
   infile2.close();
 
-  for (UInt i = 0; i < K_verified.getSize(); ++i) {
-    for (UInt j = 0; j < K_test.getSize(); ++j) {
+  for (UInt i = 0; i < K_verified.size(); ++i) {
+    for (UInt j = 0; j < K_test.size(); ++j) {
       if ((K_test(j, 0) == K_verified(i, 0)) &&
           (K_test(j, 1) == K_verified(i, 1))) {
         if (std::abs(K_verified(i, 2)) < tol) {
           if (std::abs(K_test(j, 2)) > tol)
             passed = false;
         } else {
           Real ratio = (std::abs(K_test(j, 2) - K_verified(i, 2))) /
                        (std::abs(K_verified(i, 2)));
           if (ratio > tol)
             passed = false;
         }
       }
     }
   }
 
   finalize();
 
   if (passed)
     return EXIT_SUCCESS;
   else
     return EXIT_FAILURE;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc
index 49ad5d256..02e268059 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_insertion/test_cohesive_insertion_along_physical_surfaces.cc
@@ -1,99 +1,99 @@
 /**
  * @file   test_cohesive_insertion_along_physical_surfaces.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  *
  * @date creation: Fri Aug 07 2015
  *
  * @brief  Test intrinsic insertion of cohesive elements along physical surfaces
  *
  * @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 <limits>
 #include <fstream>
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 #include "mesh_io.hh"
 #include "mesh_io_msh.hh"
 #include "mesh_utils.hh"
 #include "solid_mechanics_model_cohesive.hh"
 #include "material.hh"
 #include "material_cohesive.hh"
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char *argv[]) {
 
   initialize("input_file.dat", argc, argv);
 
   Math::setTolerance(1e-15);
   
   const UInt spatial_dimension = 3;
 
   Mesh mesh(spatial_dimension);
 
   mesh.read("3d_spherical_inclusion.msh");
   
   SolidMechanicsModelCohesive model(mesh);
   mesh.createGroupsFromMeshData<std::string>("physical_names");
   model.initFull(SolidMechanicsModelCohesiveOptions(_static));
   
   std::vector<std::string> surfaces_name = {"interface", "coh1", "coh2", "coh3", "coh4", "coh5"};
   UInt nb_surf = surfaces_name.size();
 
   Mesh::type_iterator it  = mesh.firstType(spatial_dimension, _not_ghost, _ek_cohesive);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension, _not_ghost, _ek_cohesive);
 
   for(; it != end; ++it) {
     for (UInt i = 0; i < nb_surf; ++i) {
       
-      UInt expected_insertion = mesh.getElementGroup(surfaces_name[i]).getElements(mesh.getFacetType(*it)).getSize();
-      UInt inserted_elements = model.getMaterial(surfaces_name[i]).getElementFilter()(*it).getSize();
+      UInt expected_insertion = mesh.getElementGroup(surfaces_name[i]).getElements(mesh.getFacetType(*it)).size();
+      UInt inserted_elements = model.getMaterial(surfaces_name[i]).getElementFilter()(*it).size();
       AKANTU_DEBUG_ASSERT((expected_insertion == inserted_elements),
 			  std::endl << "!!! Mismatch in insertion of surface named " 
 			  << surfaces_name[i] 
 			  << " --> " << inserted_elements << " inserted elements out of " 
 			  << expected_insertion << std::endl);
     }      
   }
 
   /*std::string paraview_folder = "paraview/test_intrinsic_insertion_along_physical_surfaces/"; 
   model.setDirectory(paraview_folder);
   model.setBaseName("bulk");
   model.addDumpField("partitions");
   model.dump();
   model.setDirectoryToDumper("cohesive elements", paraview_folder);
   model.setBaseNameToDumper("cohesive elements", "one_cohesive_element");
   model.addDumpFieldToDumper("cohesive elements", "partitions");
   model.addDumpFieldToDumper("cohesive elements", "material_index");
   model.dump("cohesive elements");
   */
 
   model.assembleStiffnessMatrix();
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic.cc
index cb4baac61..55512feca 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic.cc
@@ -1,183 +1,183 @@
 /**
  * @file   test_cohesive_intrinsic.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Mon Jan 18 2016
  *
  * @brief  Test for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 #include <limits>
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "material.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 #include "solid_mechanics_model_cohesive.hh"
 
 #include "dumper_paraview.hh"
 
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 static void updateDisplacement(SolidMechanicsModelCohesive &, Array<UInt> &,
                                ElementType, Real);
 
 int main(int argc, char * argv[]) {
   initialize("material.dat", argc, argv);
 
   debug::setDebugLevel(dblWarning);
 
   const UInt spatial_dimension = 2;
   const UInt max_steps = 350;
 
   const ElementType type = _triangle_6;
 
   Mesh mesh(spatial_dimension);
   mesh.read("triangle.msh");
 
   std::cout << mesh << std::endl;
   SolidMechanicsModelCohesive model(mesh);
 
   /// model initialization
   model.initFull();
 
   model.limitInsertion(_x, -0.26, -0.24);
   model.insertIntrinsicElements();
 
   mesh.write("mesh_cohesive.msh");
 
   Real time_step = model.getStableTimeStep() * 0.8;
   model.setTimeStep(time_step);
   //  std::cout << "Time step: " << time_step << std::endl;
 
   model.assembleMassLumped();
 
   Array<bool> & boundary = model.getBlockedDOFs();
   //  const Array<Real> & residual = model.getResidual();
 
   UInt nb_nodes = mesh.getNbNodes();
   UInt nb_element = mesh.getNbElement(type);
 
   /// boundary conditions
   for (UInt dim = 0; dim < spatial_dimension; ++dim) {
     for (UInt n = 0; n < nb_nodes; ++n) {
       boundary(n, dim) = true;
     }
   }
 
   model.assembleInternalForces();
 
   model.setBaseName("intrinsic");
   model.addDumpFieldVector("displacement");
   model.addDumpField("velocity");
   model.addDumpField("acceleration");
   model.addDumpField("internal_force");
   model.addDumpField("stress");
   model.addDumpField("strain");
   model.addDumpField("external_force");
   model.dump();
 
   model.setBaseNameToDumper("cohesive elements", "cohesive_elements_triangle");
   model.addDumpFieldVectorToDumper("cohesive elements", "displacement");
   model.addDumpFieldToDumper("cohesive elements", "damage");
   model.dump("cohesive elements");
 
   /// update displacement
   Array<UInt> elements;
   Real * bary = new Real[spatial_dimension];
   for (UInt el = 0; el < nb_element; ++el) {
     mesh.getBarycenter(el, type, bary);
     if (bary[0] > -0.25)
       elements.push_back(el);
   }
   delete[] bary;
 
   Real increment = 0.01;
 
   updateDisplacement(model, elements, type, increment);
 
   /// Main loop
   for (UInt s = 1; s <= max_steps; ++s) {
 
     model.solveStep();
 
     updateDisplacement(model, elements, type, increment);
 
     if (s % 1 == 0) {
       model.dump();
       model.dump("cohesive elements");
       std::cout << "passing step " << s << "/" << max_steps
                 << ", Ed = " << model.getEnergy("dissipated") << std::endl;
     }
   }
 
   Real Ed = model.getEnergy("dissipated");
 
   Real Edt = 2 * sqrt(2);
 
   std::cout << Ed << " " << Edt << std::endl;
 
   if (Ed < Edt * 0.999 || Ed > Edt * 1.001 || std::isnan(Ed)) {
     std::cout << "The dissipated energy is incorrect" << std::endl;
     return EXIT_FAILURE;
   }
 
   finalize();
 
   std::cout << "OK: test_cohesive_intrinsic was passed!" << std::endl;
   return EXIT_SUCCESS;
 }
 
 static void updateDisplacement(SolidMechanicsModelCohesive & model,
                                Array<UInt> & elements, ElementType type,
                                Real increment) {
 
   Mesh & mesh = model.getFEEngine().getMesh();
-  UInt nb_element = elements.getSize();
+  UInt nb_element = elements.size();
   UInt nb_nodes = mesh.getNbNodes();
   UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
   const Array<UInt> & connectivity = mesh.getConnectivity(type);
   Array<Real> & displacement = model.getDisplacement();
   Array<bool> update(nb_nodes);
   update.clear();
 
   for (UInt el = 0; el < nb_element; ++el) {
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt node = connectivity(elements(el), n);
       if (!update(node)) {
         displacement(node, 0) += increment;
         //	displacement(node, 1) += increment;
         update(node) = true;
       }
     }
   }
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_quadrangle.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_quadrangle.cc
index c9b5220b3..08c913841 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_quadrangle.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_quadrangle.cc
@@ -1,222 +1,222 @@
 /**
  * @file   test_cohesive_intrinsic_quadrangle.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Thu Dec 11 2014
  *
  * @brief  Intrinsic cohesive elements' test for quadrangles
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include <limits>
 #include <fstream>
 #include <iostream>
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 static void updateDisplacement(SolidMechanicsModelCohesive &,
 			       Array<UInt> &,
 			       ElementType,
 			       Real);
 
 int main(int argc, char *argv[]) {
   initialize("material.dat", argc, argv);
 
   const UInt spatial_dimension = 2;
   const UInt max_steps = 350;
 
   const ElementType type = _quadrangle_4;
 
   Mesh mesh(spatial_dimension);
   mesh.read("quadrangle.msh");
 
 
   // debug::setDebugLevel(dblDump);
   // std::cout << mesh << std::endl;
   // debug::setDebugLevel(dblWarning);
 
   SolidMechanicsModelCohesive model(mesh);
 
   /// model initialization
   model.initFull();
 
   model.limitInsertion(_x, -0.01, 0.01);
   model.insertIntrinsicElements();
 
   // mesh.write("mesh_cohesive_quadrangle.msh");
 
   // debug::setDebugLevel(dblDump);
   // std::cout << mesh << std::endl;
   // debug::setDebugLevel(dblWarning);
 
 
   Real time_step = model.getStableTimeStep()*0.8;
   model.setTimeStep(time_step);
   //  std::cout << "Time step: " << time_step << std::endl;
 
   model.assembleMassLumped();
 
 
   Array<bool> & boundary = model.getBlockedDOFs();
   //  const Array<Real> & residual = model.getResidual();
 
   UInt nb_nodes = mesh.getNbNodes();
   UInt nb_element = mesh.getNbElement(type);
 
   /// boundary conditions
   for (UInt dim = 0; dim < spatial_dimension; ++dim) {
     for (UInt n = 0; n < nb_nodes; ++n) {
       boundary(n, dim) = true;
     }
   }
 
   model.assembleInternalForces();
 
   model.setBaseName("intrinsic_quadrangle");
   model.addDumpFieldVector("displacement");
   model.addDumpField("velocity"    );
   model.addDumpField("acceleration");
   model.addDumpField("internal_force"    );
   model.addDumpField("stress");
   model.addDumpField("grad_u");
   model.addDumpField("external_force");
 
   model.setBaseNameToDumper("cohesive elements", "cohesive_elements_quadrangle");
   model.addDumpFieldVectorToDumper("cohesive elements", "displacement");
   model.addDumpFieldToDumper("cohesive elements", "damage");
 
   model.dump();
   model.dump("cohesive elements");
 
   /// update displacement
   Array<UInt> elements;
   Real * bary = new Real[spatial_dimension];
   for (UInt el = 0; el < nb_element; ++el) {
     mesh.getBarycenter(el, type, bary);
     if (bary[0] > 0.) elements.push_back(el);
   }
   delete[] bary;
 
   Real increment = 0.01;
 
   updateDisplacement(model, elements, type, increment);
 
   // for (UInt n = 0; n < nb_nodes; ++n) {
   //   if (position(n, 1) + displacement(n, 1) > 0) {
   //     if (position(n, 0) == 0) {
   // 	displacement(n, 1) -= 0.25;
   //     }
   //     if (position(n, 0) == 1) {
   // 	displacement(n, 1) += 0.25;
   //     }
   //   }
   // }
 
   // std::ofstream edis("edis.txt");
   // std::ofstream erev("erev.txt");
 
   /// Main loop
   for (UInt s = 1; s <= max_steps; ++s) {
     model.solveStep();
 
     updateDisplacement(model, elements, type, increment);
 
     if(s % 1 == 0) {
       model.dump();
       model.dump("cohesive elements");
       std::cout << "passing step " << s << "/" << max_steps << std::endl;
     }
 
     // // update displacement
     // for (UInt n = 0; n < nb_nodes; ++n) {
     //   if (position(n, 1) + displacement(n, 1) > 0) {
     // 	displacement(n, 0) -= 0.01;
     //   }
     // }
 
     //    Real Ed = dynamic_cast<MaterialCohesive&> (model.getMaterial(1)).getDissipatedEnergy();
     //    Real Er = dynamic_cast<MaterialCohesive&> (model.getMaterial(1)).getReversibleEnergy();
 
     // edis << s << " "
     // 	 << Ed << std::endl;
 
     // erev << s << " "
     // 	 << Er << std::endl;
 
   }
 
   // edis.close();
   // erev.close();
 
   Real Ed = model.getEnergy("dissipated");
 
   Real Edt = 1;
 
   std::cout << Ed << " " << Edt << std::endl;
 
   if (Ed < Edt * 0.999 || Ed > Edt * 1.001) {
     std::cout << "The dissipated energy is incorrect" << std::endl;
     return EXIT_FAILURE;
   }
 
   finalize();
 
   std::cout << "OK: test_cohesive_intrinsic_quadrangle was passed!" << std::endl;
   return EXIT_SUCCESS;
 }
 
 
 static void updateDisplacement(SolidMechanicsModelCohesive & model,
 			       Array<UInt> & elements,
 			       ElementType type,
 			       Real increment) {
 
   Mesh & mesh = model.getFEEngine().getMesh();
-  UInt nb_element = elements.getSize();
+  UInt nb_element = elements.size();
   UInt nb_nodes = mesh.getNbNodes();
   UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
   const Array<UInt> & connectivity = mesh.getConnectivity(type);
   Array<Real> & displacement = model.getDisplacement();
   Array<bool> update(nb_nodes);
   update.clear();
 
   for (UInt el = 0; el < nb_element; ++el) {
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt node = connectivity(elements(el), n);
       if (!update(node)) {
 	displacement(node, 0) += increment;
 	//	displacement(node, 1) += increment;
 	update(node) = true;
       }
     }
   }
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_tetrahedron.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_tetrahedron.cc
index 4dfa43ecc..b43a04742 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_tetrahedron.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_cohesive_intrinsic/test_cohesive_intrinsic_tetrahedron.cc
@@ -1,430 +1,430 @@
 /**
  * @file   test_cohesive_intrinsic_tetrahedron.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue Aug 27 2013
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Test for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <fstream>
 #include <iostream>
 #include <limits>
 
 /* -------------------------------------------------------------------------- */
 #include "material_cohesive.hh"
 #include "solid_mechanics_model_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 void updateDisplacement(SolidMechanicsModelCohesive &, Array<UInt> &,
                         ElementType, Vector<Real> &);
 
 bool checkTractions(SolidMechanicsModelCohesive & model, ElementType type,
                     Vector<Real> & opening, Vector<Real> & theoretical_traction,
                     Matrix<Real> & rotation);
 
 void findNodesToCheck(const Mesh & mesh, const Array<UInt> & elements,
                       ElementType type, Array<UInt> & nodes_to_check);
 
 bool checkEquilibrium(const Array<Real> & residual);
 
 bool checkResidual(const Array<Real> & residual, const Vector<Real> & traction,
                    const Array<UInt> & nodes_to_check,
                    const Matrix<Real> & rotation);
 
 int main(int argc, char * argv[]) {
   initialize("material_tetrahedron.dat", argc, argv);
 
   //  debug::setDebugLevel(dblDump);
 
   const UInt spatial_dimension = 3;
   const UInt max_steps = 60;
   const Real increment_constant = 0.01;
   Math::setTolerance(1.e-12);
 
   const ElementType type = _tetrahedron_10;
 
   Mesh mesh(spatial_dimension);
   mesh.read("tetrahedron.msh");
 
   SolidMechanicsModelCohesive model(mesh);
 
   /// model initialization
   model.initFull();
 
   model.limitInsertion(_x, -0.01, 0.01);
   model.insertIntrinsicElements();
 
   Array<bool> & boundary = model.getBlockedDOFs();
   boundary.set(true);
 
   UInt nb_element = mesh.getNbElement(type);
 
   model.assembleInternalForces();
 
   model.setBaseName("intrinsic_tetrahedron");
   model.addDumpFieldVector("displacement");
   model.addDumpField("internal_force");
   model.dump();
 
   model.setBaseNameToDumper("cohesive elements",
                             "cohesive_elements_tetrahedron");
   model.addDumpFieldVectorToDumper("cohesive elements", "displacement");
   model.addDumpFieldToDumper("cohesive elements", "damage");
   model.dump("cohesive elements");
 
   /// find elements to displace
   Array<UInt> elements;
   Real * bary = new Real[spatial_dimension];
   for (UInt el = 0; el < nb_element; ++el) {
     mesh.getBarycenter(el, type, bary);
     if (bary[0] > 0.01)
       elements.push_back(el);
   }
   delete[] bary;
 
   /// find nodes to check
   Array<UInt> nodes_to_check;
   findNodesToCheck(mesh, elements, type, nodes_to_check);
 
   /// rotate mesh
   Real angle = 1.;
 
   Matrix<Real> rotation(spatial_dimension, spatial_dimension);
   rotation.clear();
   rotation(0, 0) = std::cos(angle);
   rotation(0, 1) = std::sin(angle) * -1.;
   rotation(1, 0) = std::sin(angle);
   rotation(1, 1) = std::cos(angle);
   rotation(2, 2) = 1.;
 
   Vector<Real> increment_tmp(spatial_dimension);
   for (UInt dim = 0; dim < spatial_dimension; ++dim) {
     increment_tmp(dim) = (dim + 1) * increment_constant;
   }
 
   Vector<Real> increment(spatial_dimension);
   increment.mul<false>(rotation, increment_tmp);
 
   Array<Real> & position = mesh.getNodes();
   Array<Real> position_tmp(position);
 
   Array<Real>::iterator<Vector<Real>> position_it =
       position.begin(spatial_dimension);
   Array<Real>::iterator<Vector<Real>> position_end =
       position.end(spatial_dimension);
   Array<Real>::iterator<Vector<Real>> position_tmp_it =
       position_tmp.begin(spatial_dimension);
 
   for (; position_it != position_end; ++position_it, ++position_tmp_it)
     position_it->mul<false>(rotation, *position_tmp_it);
 
   model.dump();
   model.dump("cohesive elements");
 
   updateDisplacement(model, elements, type, increment);
 
   Real theoretical_Ed = 0;
 
   Vector<Real> opening(spatial_dimension);
   Vector<Real> traction(spatial_dimension);
   Vector<Real> opening_old(spatial_dimension);
   Vector<Real> traction_old(spatial_dimension);
 
   opening.clear();
   traction.clear();
   opening_old.clear();
   traction_old.clear();
 
   Vector<Real> Dt(spatial_dimension);
   Vector<Real> Do(spatial_dimension);
 
   const Array<Real> & residual = model.getInternalForce();
 
   /// Main loop
   for (UInt s = 1; s <= max_steps; ++s) {
 
     model.assembleInternalForces();
 
     opening += increment_tmp;
     if (checkTractions(model, type, opening, traction, rotation) ||
         checkEquilibrium(residual) ||
         checkResidual(residual, traction, nodes_to_check, rotation)) {
       finalize();
       return EXIT_FAILURE;
     }
 
     /// compute energy
     Do = opening;
     Do -= opening_old;
 
     Dt = traction_old;
     Dt += traction;
 
     theoretical_Ed += .5 * Do.dot(Dt);
 
     opening_old = opening;
     traction_old = traction;
 
     updateDisplacement(model, elements, type, increment);
 
     if (s % 10 == 0) {
       std::cout << "passing step " << s << "/" << max_steps << std::endl;
       model.dump();
       model.dump("cohesive elements");
     }
   }
 
   model.dump();
   model.dump("cohesive elements");
 
   Real Ed = model.getEnergy("dissipated");
   theoretical_Ed *= 4.;
 
   std::cout << Ed << " " << theoretical_Ed << std::endl;
 
   if (!Math::are_float_equal(Ed, theoretical_Ed) || std::isnan(Ed)) {
     std::cout << "The dissipated energy is incorrect" << std::endl;
     finalize();
     return EXIT_FAILURE;
   }
 
   finalize();
 
   std::cout << "OK: test_cohesive_intrinsic_tetrahedron was passed!"
             << std::endl;
   return EXIT_SUCCESS;
 }
 
 /* -------------------------------------------------------------------------- */
 
 void updateDisplacement(SolidMechanicsModelCohesive & model,
                         Array<UInt> & elements, ElementType type,
                         Vector<Real> & increment) {
 
   UInt spatial_dimension = model.getSpatialDimension();
   Mesh & mesh = model.getFEEngine().getMesh();
-  UInt nb_element = elements.getSize();
+  UInt nb_element = elements.size();
   UInt nb_nodes = mesh.getNbNodes();
   UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
   const Array<UInt> & connectivity = mesh.getConnectivity(type);
   Array<Real> & displacement = model.getDisplacement();
   Array<bool> update(nb_nodes);
   update.clear();
 
   for (UInt el = 0; el < nb_element; ++el) {
     for (UInt n = 0; n < nb_nodes_per_element; ++n) {
       UInt node = connectivity(elements(el), n);
       if (!update(node)) {
         Vector<Real> node_disp(displacement.storage() +
                                    node * spatial_dimension,
                                spatial_dimension);
         node_disp += increment;
         update(node) = true;
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 bool checkTractions(SolidMechanicsModelCohesive & model, ElementType type,
                     Vector<Real> & opening, Vector<Real> & theoretical_traction,
                     Matrix<Real> & rotation) {
   UInt spatial_dimension = model.getSpatialDimension();
 
   const MaterialCohesive & mat_cohesive =
       dynamic_cast<const MaterialCohesive &>(model.getMaterial(1));
 
   Real sigma_c = mat_cohesive.getParam("sigma_c");
   const Real beta = mat_cohesive.getParam("beta");
   const Real G_c = mat_cohesive.getParam("G_c");
   const Real delta_0 = mat_cohesive.getParam("delta_0");
   const Real kappa = mat_cohesive.getParam("kappa");
   Real delta_c = 2 * G_c / sigma_c;
   sigma_c *= delta_c / (delta_c - delta_0);
 
   ElementType type_facet = Mesh::getFacetType(type);
   ElementType type_cohesive = FEEngine::getCohesiveElementType(type_facet);
 
   const Array<Real> & traction = mat_cohesive.getTraction(type_cohesive);
   const Array<Real> & damage = mat_cohesive.getDamage(type_cohesive);
 
   UInt nb_quad_per_el = model.getFEEngine("CohesiveFEEngine")
                             .getNbIntegrationPoints(type_cohesive);
   UInt nb_element = model.getMesh().getNbElement(type_cohesive);
   UInt tot_nb_quad = nb_element * nb_quad_per_el;
 
   Vector<Real> normal_opening(spatial_dimension);
   normal_opening.clear();
   normal_opening(0) = opening(0);
   Real normal_opening_norm = normal_opening.norm();
 
   Vector<Real> tangential_opening(spatial_dimension);
   tangential_opening.clear();
   for (UInt dim = 1; dim < spatial_dimension; ++dim)
     tangential_opening(dim) = opening(dim);
 
   Real tangential_opening_norm = tangential_opening.norm();
 
   Real beta2_kappa2 = beta * beta / kappa / kappa;
   Real beta2_kappa = beta * beta / kappa;
 
   Real delta = std::sqrt(tangential_opening_norm * tangential_opening_norm *
                              beta2_kappa2 +
                          normal_opening_norm * normal_opening_norm);
 
   delta = std::max(delta, delta_0);
 
   Real theoretical_damage = std::min(delta / delta_c, 1.);
 
   if (Math::are_float_equal(theoretical_damage, 1.))
     theoretical_traction.clear();
   else {
     theoretical_traction = tangential_opening;
     theoretical_traction *= beta2_kappa;
     theoretical_traction += normal_opening;
     theoretical_traction *= sigma_c / delta * (1. - theoretical_damage);
   }
 
   // adjust damage
   theoretical_damage = std::max((delta - delta_0) / (delta_c - delta_0), 0.);
   theoretical_damage = std::min(theoretical_damage, 1.);
 
   Vector<Real> theoretical_traction_rotated(spatial_dimension);
   theoretical_traction_rotated.mul<false>(rotation, theoretical_traction);
 
   for (UInt q = 0; q < tot_nb_quad; ++q) {
     for (UInt dim = 0; dim < spatial_dimension; ++dim) {
       if (!Math::are_float_equal(theoretical_traction_rotated(dim),
                                  traction(q, dim))) {
         std::cout << "Tractions are incorrect" << std::endl;
         return 1;
       }
     }
 
     if (!Math::are_float_equal(theoretical_damage, damage(q))) {
       std::cout << "Damage is incorrect" << std::endl;
       return 1;
     }
   }
 
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 
 void findNodesToCheck(const Mesh & mesh, const Array<UInt> & elements,
                       ElementType type, Array<UInt> & nodes_to_check) {
 
   const Array<UInt> & connectivity = mesh.getConnectivity(type);
   const Array<Real> & position = mesh.getNodes();
 
-  UInt nb_nodes = position.getSize();
+  UInt nb_nodes = position.size();
   UInt nb_nodes_per_elem = connectivity.getNbComponent();
 
   Array<bool> checked_nodes(nb_nodes);
   checked_nodes.clear();
 
-  for (UInt el = 0; el < elements.getSize(); ++el) {
+  for (UInt el = 0; el < elements.size(); ++el) {
 
     UInt element = elements(el);
     Vector<UInt> conn_el(connectivity.storage() + nb_nodes_per_elem * element,
                          nb_nodes_per_elem);
 
     for (UInt n = 0; n < nb_nodes_per_elem; ++n) {
       UInt node = conn_el(n);
       if (Math::are_float_equal(position(node, 0), 0.) &&
           checked_nodes(node) == false) {
         checked_nodes(node) = true;
         nodes_to_check.push_back(node);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 bool checkEquilibrium(const Array<Real> & residual) {
 
   UInt spatial_dimension = residual.getNbComponent();
 
   Vector<Real> residual_sum(spatial_dimension);
   residual_sum.clear();
 
   Array<Real>::const_iterator<Vector<Real>> res_it =
       residual.begin(spatial_dimension);
   Array<Real>::const_iterator<Vector<Real>> res_end =
       residual.end(spatial_dimension);
 
   for (; res_it != res_end; ++res_it)
     residual_sum += *res_it;
 
   for (UInt s = 0; s < spatial_dimension; ++s) {
     if (!Math::are_float_equal(residual_sum(s), 0.)) {
       std::cout << "System is not in equilibrium!" << std::endl;
       return 1;
     }
   }
 
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 
 bool checkResidual(const Array<Real> & residual, const Vector<Real> & traction,
                    const Array<UInt> & nodes_to_check,
                    const Matrix<Real> & rotation) {
 
   UInt spatial_dimension = residual.getNbComponent();
 
   Vector<Real> total_force(spatial_dimension);
   total_force.clear();
 
-  for (UInt n = 0; n < nodes_to_check.getSize(); ++n) {
+  for (UInt n = 0; n < nodes_to_check.size(); ++n) {
     UInt node = nodes_to_check(n);
 
     Vector<Real> res(residual.storage() + node * spatial_dimension,
                      spatial_dimension);
 
     total_force += res;
   }
 
   Vector<Real> theoretical_total_force(spatial_dimension);
   theoretical_total_force.mul<false>(rotation, traction);
   theoretical_total_force *= -1 * 2 * 2;
 
   for (UInt s = 0; s < spatial_dimension; ++s) {
     if (!Math::are_float_equal(total_force(s), theoretical_total_force(s))) {
       std::cout << "Total force isn't correct!" << std::endl;
       return 1;
     }
   }
 
   return 0;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc
index 9a35455f6..6ef0762e7 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_elasto_plastic_linear_isotropic_hardening/test_material_elasto_plastic_linear_isotropic_hardening.cc
@@ -1,82 +1,82 @@
 /**
  * @file   test_material_elasto_plastic_linear_isotropic_hardening.cc
  *
  * @author Jaehyun Cho <jaehyun.cho@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Thu Dec 03 2015
  *
  * @brief  test for material type elasto plastic linear isotropic hardening using
  *         tension-compression test
  *
  * @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 "non_linear_solver.hh"
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 
 int main(int argc, char *argv[]) {
   initialize("test_material_elasto_plastic_linear_isotropic_hardening.dat", argc, argv);
 
   const UInt spatial_dimension = 2;
   const Real u_increment = 0.1;
   const UInt steps = 20;
 
   Mesh mesh(spatial_dimension);
   mesh.read("test_material_elasto_plastic_linear_isotropic_hardening.msh");
 
   SolidMechanicsModel model(mesh);
   model.initFull(_analysis_method = _static);
 
   model.getNonLinearSolver("static").set("max_iterations", 300);
   model.getNonLinearSolver("static").set("threshold", 1e-6);
 
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _x), "left");
   model.applyBC(BC::Dirichlet::FixedValue(0.0, _y), "bottom");
 
   std::cout.precision(4);
   for (UInt i = 0 ; i < steps ; ++i) {
     model.applyBC(BC::Dirichlet::FixedValue(i * u_increment, _x), "right");
     model.solveStep();
 
     Real strainxx = i * u_increment / 10.;
 
     const Array<UInt> & edge_nodes = mesh.getElementGroup("right").getNodes();
     Array<Real> & residual = model.getInternalForce();
     Real reaction = 0;
 
-    for (UInt n = 0 ; n < edge_nodes.getSize() ; n++) {
+    for (UInt n = 0 ; n < edge_nodes.size() ; n++) {
       reaction -= residual(edge_nodes(n), 0);
     }
 
     std::cout << strainxx << "," << reaction << std::endl;
   }
 
   finalize();
   return EXIT_SUCCESS;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_non_local.cc b/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_non_local.cc
index 90cc88bf2..b1870e9a7 100644
--- a/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_non_local.cc
+++ b/test/test_model/test_solid_mechanics_model/test_materials/test_material_non_local/test_material_non_local.cc
@@ -1,101 +1,101 @@
 /**
  * @file   test_material_non_local.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 31 2011
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  test of the main part of the non local materials
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model.hh"
 #include "custom_non_local_test_material.hh"
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 /* -------------------------------------------------------------------------- */
 int main(int argc, char *argv[]) {
   akantu::initialize("material.dat", argc, argv);
 
   // some configuration variables
   const UInt spatial_dimension = 2;
 
   Mesh mesh(spatial_dimension);
 
   StaticCommunicator & comm = akantu::StaticCommunicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
 
   // mesh creation and read
   if(prank == 0) {
     mesh.read("mesh.msh");
   }
   mesh.distribute();
 
   /// model creation
   SolidMechanicsModel  model(mesh);
 
   /// model initialization changed to use our material
   model.initFull();
 
   CustomNonLocalTestMaterial<spatial_dimension> & mat = dynamic_cast<CustomNonLocalTestMaterial<spatial_dimension> &>(model.getMaterial("test"));
 
   if(prank == 0) std::cout << mat << std::endl;
 
   // Setting up the dumpers + first dump
   model.setBaseName("non_local_material");
   model.addDumpFieldVector("displacement");
   model.addDumpFieldVector("external_force");
   model.addDumpFieldVector("internal_force");
   model.addDumpField("partitions"   );
   model.addDumpField("stress"      );
   model.addDumpField("stress"      );
   model.addDumpField("local_damage");
   model.addDumpField("damage"      );
 
 
   model.assembleInternalForces();
   model.dump();
 
 
   //Array<Real> & damage = mat.getArray("local_damage", _quadrangle_4);
   Array<Real> & damage = mat.getArray<Real>("local_damage", _triangle_3);
 
   RandomGenerator<UInt> gen;
 
   for (UInt i = 0; i < 1; ++i) {
-    UInt g = (gen() / Real(RandomGenerator<UInt>::max() - RandomGenerator<UInt>::min()))  * damage.getSize();
+    UInt g = (gen() / Real(RandomGenerator<UInt>::max() - RandomGenerator<UInt>::min()))  * damage.size();
     std::cout << prank << " -> " << g << std::endl;
     damage(g) = 1.;
   }
 
   model.assembleInternalForces();
   model.dump();
 
   akantu::finalize();
   return EXIT_SUCCESS;
 }
diff --git a/test/test_synchronizer/test_data_accessor.hh b/test/test_synchronizer/test_data_accessor.hh
index 3791f52a6..689817595 100644
--- a/test/test_synchronizer/test_data_accessor.hh
+++ b/test/test_synchronizer/test_data_accessor.hh
@@ -1,132 +1,132 @@
 /**
  * @file   test_data_accessor.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Thu Apr 11 2013
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Data Accessor class for testing
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #include "aka_common.hh"
 #include "data_accessor.hh"
 #include "mesh.hh"
 
 using namespace akantu;
 /* -------------------------------------------------------------------------- */
 
 class TestAccessor : public DataAccessor<Element> {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   inline TestAccessor(const Mesh & mesh,
                       const ElementTypeMapArray<Real> & barycenters);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Barycenter, barycenters, Real);
 
   /* ------------------------------------------------------------------------ */
   /* Ghost Synchronizer inherited members                                     */
   /* ------------------------------------------------------------------------ */
 protected:
   inline UInt getNbData(const Array<Element> & elements,
                         const SynchronizationTag & tag) const;
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const;
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   const ElementTypeMapArray<Real> & barycenters;
   const Mesh & mesh;
 };
 
 /* -------------------------------------------------------------------------- */
 /* TestSynchronizer implementation                                            */
 /* -------------------------------------------------------------------------- */
 inline TestAccessor::TestAccessor(const Mesh & mesh,
                                   const ElementTypeMapArray<Real> & barycenters)
     : barycenters(barycenters), mesh(mesh) {}
 
 inline UInt TestAccessor::getNbData(const Array<Element> & elements,
                                     const SynchronizationTag &) const {
-  if (elements.getSize())
+  if (elements.size())
     // return Mesh::getSpatialDimension(elements(0).type) * sizeof(Real) *
-    // elements.getSize();
-    return mesh.getSpatialDimension() * sizeof(Real) * elements.getSize();
+    // elements.size();
+    return mesh.getSpatialDimension() * sizeof(Real) * elements.size();
   else
     return 0;
 }
 
 inline void TestAccessor::packData(CommunicationBuffer & buffer,
                                    const Array<Element> & elements,
                                    const SynchronizationTag &) const {
   UInt spatial_dimension = mesh.getSpatialDimension();
   Array<Element>::const_iterator<Element> bit = elements.begin();
   Array<Element>::const_iterator<Element> bend = elements.end();
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
 
     Vector<Real> bary(
         this->barycenters(element.type, element.ghost_type).storage() +
             element.element * spatial_dimension,
         spatial_dimension);
     buffer << bary;
   }
 }
 
 inline void TestAccessor::unpackData(CommunicationBuffer & buffer,
                                      const Array<Element> & elements,
                                      const SynchronizationTag & tag) {
   UInt spatial_dimension = mesh.getSpatialDimension();
   Array<Element>::const_iterator<Element> bit = elements.begin();
   Array<Element>::const_iterator<Element> bend = elements.end();
   for (; bit != bend; ++bit) {
     const Element & element = *bit;
 
     Vector<Real> barycenter_loc(
         this->barycenters(element.type, element.ghost_type).storage() +
             element.element * spatial_dimension,
         spatial_dimension);
 
     Vector<Real> bary(spatial_dimension);
     buffer >> bary;
     std::cout << element << barycenter_loc << std::endl;
     Real tolerance = 1e-15;
     for (UInt i = 0; i < spatial_dimension; ++i) {
       if (!(std::abs(bary(i) - barycenter_loc(i)) <= tolerance))
         AKANTU_DEBUG_ERROR("Unpacking an unknown value for the element: "
                            << element << "(barycenter[" << i
                            << "] = " << barycenter_loc(i) << " and buffer[" << i
                            << "] = " << bary(i) << ") - tag: " << tag);
     }
   }
 }
diff --git a/test/test_synchronizer/test_data_distribution.cc b/test/test_synchronizer/test_data_distribution.cc
index cc042b24d..b5f970ae0 100644
--- a/test/test_synchronizer/test_data_distribution.cc
+++ b/test/test_synchronizer/test_data_distribution.cc
@@ -1,173 +1,173 @@
 /**
  * @file   test_data_distribution.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Sep 05 2014
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Test the mesh distribution on creation of a distributed synchonizer
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_iterators.hh"
 #include "aka_random_generator.hh"
 #include "element_group.hh"
 #include "element_synchronizer.hh"
 #include "mesh_iterators.hh"
 #include "mesh_partition_mesh_data.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   const UInt spatial_dimension = 3;
 
   Mesh mesh_group_after(spatial_dimension, "after");
   Mesh mesh_group_before(spatial_dimension, "before");
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   if (prank == 0) {
     mesh_group_before.read("data_split.msh");
     mesh_group_after.read("data_split.msh");
 
     mesh_group_before.registerData<UInt>("global_id");
     mesh_group_after.registerData<UInt>("global_id");
 
     for (const auto & type : mesh_group_after.elementTypes(_all_dimensions)) {
       auto & gidb = mesh_group_before.getDataPointer<UInt>("global_id", type);
       auto & gida = mesh_group_after.getDataPointer<UInt>("global_id", type);
 
-      for (auto && data : zip(arange(gida.getSize()), gida, gidb)) {
+      for (auto && data : zip(arange(gida.size()), gida, gidb)) {
         std::get<1>(data) = std::get<0>(data);
         std::get<2>(data) = std::get<0>(data);
       }
     }
   }
 
   RandomGenerator<UInt>::seed(1);
   mesh_group_before.distribute();
 
   RandomGenerator<UInt>::seed(1);
   mesh_group_after.distribute();
 
   if (prank == 0)
     std::cout << mesh_group_after;
 
   for (const auto & agrp : ElementGroupsIterable(mesh_group_after)) {
     const ElementGroup & bgrp =
         mesh_group_before.getElementGroup(agrp.getName());
 
     for (auto && ghost_type : ghost_types) {
       for (const auto & type : bgrp.elementTypes(_all_dimensions, ghost_type)) {
         Array<UInt> & gidb = mesh_group_before.getDataPointer<UInt>(
             "global_id", type, ghost_type);
         Array<UInt> & gida = mesh_group_after.getDataPointer<UInt>(
             "global_id", type, ghost_type);
 
         Array<UInt> bgelem(bgrp.getElements(type, ghost_type));
         Array<UInt> agelem(agrp.getElements(type, ghost_type));
 
         std::transform(agelem.begin(), agelem.end(), agelem.begin(),
                        [&gida](auto & i) { return gida(i); });
         std::transform(bgelem.begin(), bgelem.end(), bgelem.begin(),
                        [&gidb](auto & i) { return gidb(i); });
 
         std::sort(bgelem.begin(), bgelem.end());
         std::sort(agelem.begin(), agelem.end());
 
         if (not std::equal(bgelem.begin(), bgelem.end(), agelem.begin())) {
           std::cerr << "The filters array for the group " << agrp.getName()
                     << " and for the element type " << type << ", "
                     << ghost_type << " do not match" << std::endl;
 
           debug::setDebugLevel(dblTest);
 
           std::cerr << bgelem << std::endl;
           std::cerr << agelem << std::endl;
           debug::debugger.exit(EXIT_FAILURE);
         }
       }
     }
   }
 
   for (const auto & agrp : NodeGroupsIterable(mesh_group_after)) {
     const NodeGroup & bgrp = mesh_group_before.getNodeGroup(agrp.getName());
 
     const Array<UInt> & gidb = mesh_group_before.getGlobalNodesIds();
     const Array<UInt> & gida = mesh_group_after.getGlobalNodesIds();
 
     Array<UInt> bgnode(0, 1);
     Array<UInt> agnode(0, 1);
 
     for (auto && pair : zip(bgrp, agrp)) {
       UInt a,b;
       std::tie(b, a) = pair;
       if (psize > 1) {
         if (mesh_group_before.isLocalOrMasterNode(b))
           bgnode.push_back(gidb(b));
 
         if (mesh_group_after.isLocalOrMasterNode(a))
           agnode.push_back(gida(a));
       }
     }
 
     std::sort(bgnode.begin(), bgnode.end());
     std::sort(agnode.begin(), agnode.end());
 
     if (!std::equal(bgnode.begin(), bgnode.end(), agnode.begin())) {
       std::cerr << "The filters array for the group " << agrp.getName() << " do not match"
                 << std::endl;
 
       debug::setDebugLevel(dblTest);
 
       std::cerr << bgnode << std::endl;
       std::cerr << agnode << std::endl;
       debug::debugger.exit(EXIT_FAILURE);
     }
   }
 
   mesh_group_after.getElementGroup("inside").setBaseName("after_inside");
   mesh_group_after.getElementGroup("inside").dump();
   mesh_group_after.getElementGroup("outside").setBaseName("after_outside");
   mesh_group_after.getElementGroup("outside").dump();
   mesh_group_after.getElementGroup("volume").setBaseName("after_volume");
   mesh_group_after.getElementGroup("volume").dump();
 
   mesh_group_before.getElementGroup("inside").setBaseName("before_inside");
   mesh_group_before.getElementGroup("inside").dump();
   mesh_group_before.getElementGroup("outside").setBaseName("before_outside");
   mesh_group_before.getElementGroup("outside").dump();
   mesh_group_before.getElementGroup("volume").setBaseName("before_volume");
   mesh_group_before.getElementGroup("volume").dump();
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_synchronizer/test_dof_data_accessor.hh b/test/test_synchronizer/test_dof_data_accessor.hh
index c1c4f6055..debb622e2 100644
--- a/test/test_synchronizer/test_dof_data_accessor.hh
+++ b/test/test_synchronizer/test_dof_data_accessor.hh
@@ -1,117 +1,117 @@
 /**
  * @file   test_dof_data_accessor.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  * @date creation: Tue Dec 09 2014
  *
  * @brief  data accessor class for testing the
  *
  * @section LICENSE
  *
  * Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
  * (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 
 /* -------------------------------------------------------------------------- */
 
 #include "aka_common.hh"
 #include "data_accessor.hh"
 
 
 /* -------------------------------------------------------------------------- */
 
 __BEGIN_AKANTU__
 
 class TestDOFAccessor : public DataAccessor {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   inline TestDOFAccessor(const Array<Int> & global_dof_equation_numbers);
 
 
   /* ------------------------------------------------------------------------ */
   /* Ghost Synchronizer inherited members                                     */
   /* ------------------------------------------------------------------------ */
 protected:
   inline UInt getNbDataForDOFs(const Array<UInt> & dofs,
 			       SynchronizationTag tag) const;
   inline void packDOFData(CommunicationBuffer & buffer,
 			  const Array<UInt> & dofs,
 			  SynchronizationTag tag) const;
   inline void unpackDOFData(CommunicationBuffer & buffer,
 			    const Array<UInt> & dofs,
 			    SynchronizationTag tag);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   const Array<Int> & global_dof_equation_numbers;
 };
 
 
 /* -------------------------------------------------------------------------- */
 /* TestDOFSynchronizer implementation                                            */
 /* -------------------------------------------------------------------------- */
 inline TestDOFAccessor::TestDOFAccessor(const Array<Int> & global_dof_equation_numbers)
   : global_dof_equation_numbers(global_dof_equation_numbers) { }
 
 inline UInt TestDOFAccessor::getNbDataForDOFs(const Array<UInt> & dofs,
 					       __attribute__ ((unused)) SynchronizationTag tag) const {
-  if(dofs.getSize())
-    // return Mesh::getSpatialDimension(elements(0).type) * sizeof(Real) * elements.getSize();
-    return sizeof(Int) * dofs.getSize();
+  if(dofs.size())
+    // return Mesh::getSpatialDimension(elements(0).type) * sizeof(Real) * elements.size();
+    return sizeof(Int) * dofs.size();
   else
     return 0;
 }
 
 inline void TestDOFAccessor::packDOFData(CommunicationBuffer & buffer,
 					  const Array<UInt> & dofs,
 					  __attribute__ ((unused)) SynchronizationTag tag) const {
   Array<UInt>::const_scalar_iterator bit  = dofs.begin();
   Array<UInt>::const_scalar_iterator bend = dofs.end();
   for (; bit != bend; ++bit) {
     buffer << this->global_dof_equation_numbers[*bit];
   }
 }
 
 inline void TestDOFAccessor::unpackDOFData(CommunicationBuffer & buffer,
 					    const Array<UInt> & dofs,
 					    __attribute__ ((unused)) SynchronizationTag tag) {
   Array<UInt>::const_scalar_iterator bit  = dofs.begin();
   Array<UInt>::const_scalar_iterator bend = dofs.end();
   for (; bit != bend; ++bit) {
     Int global_dof_eq_nb_local = global_dof_equation_numbers[*bit];
     Int global_dof_eq_nb = 0;
     buffer >> global_dof_eq_nb;
     std::cout << *bit << global_dof_eq_nb_local << std::endl;
     Real tolerance = Math::getTolerance();
       if(!(std::abs(global_dof_eq_nb - global_dof_eq_nb_local) <= tolerance))
         AKANTU_DEBUG_ERROR("Unpacking an unknown value for the dof: "
                            << *bit
                            << "(global_dof_equation_number = " << global_dof_eq_nb_local
                            << " and buffer = " << global_dof_eq_nb << ") - tag: " << tag);
   }
 }
 
 
 __END_AKANTU__
diff --git a/test/test_synchronizer/test_node_synchronizer.cc b/test/test_synchronizer/test_node_synchronizer.cc
index a3c581d25..94452ce1c 100644
--- a/test/test_synchronizer/test_node_synchronizer.cc
+++ b/test/test_synchronizer/test_node_synchronizer.cc
@@ -1,130 +1,130 @@
 /**
  * @file   test_node_synchronizer.cc
  *
  * @author Nicolas Richart
  *
  * @date creation  Tue Apr 04 2017
  *
  * @brief test the default node synchronizer present 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 "data_accessor.hh"
 #include "mesh.hh"
 #include "node_synchronizer.hh"
 #include "static_communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <limits>
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 class DataAccessorTest : public DataAccessor<UInt> {
 public:
   explicit DataAccessorTest(Array<int> & data) : data(data) {}
 
   UInt getNbData(const Array<UInt> & nodes,
                  const SynchronizationTag &) const {
-    return nodes.getSize() * sizeof(int);
+    return nodes.size() * sizeof(int);
   }
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                 const SynchronizationTag &) const {
     for (auto node : nodes) {
       buffer << data(node);
     }
   }
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & nodes,
                   const SynchronizationTag &) {
     for (auto node : nodes) {
       buffer >> data(node);
     }
   }
 
 protected:
   Array<int> & data;
 };
 
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt spatial_dimension = 3;
 
   Mesh mesh(spatial_dimension);
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
 
   if (prank == 0)
     mesh.read("cube.msh");
 
   mesh.distribute();
 
   UInt nb_nodes = mesh.getNbNodes();
   Array<int> node_data(nb_nodes);
 
   constexpr int max_int = std::numeric_limits<int>::max();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     UInt gn = mesh.getNodeGlobalId(n);
     if (mesh.isMasterNode(n))
       node_data(n) = gn;
     else if (mesh.isLocalNode(n))
       node_data(n) = -gn;
     else if (mesh.isSlaveNode(n))
       node_data(n) = max_int;
     else
       node_data(n) = -max_int;
   }
 
   DataAccessorTest data_accessor(node_data);
 
   auto & node_synchronizer = mesh.getNodeSynchronizer();
   node_synchronizer.synchronize(data_accessor, _gst_test);
 
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     int gn = mesh.getNodeGlobalId(n);
     if(!((mesh.isMasterNode(n) && node_data(n) == gn) ||
          (mesh.isLocalNode(n)  && node_data(n) == -gn) ||
          (mesh.isSlaveNode(n)  && node_data(n) == gn) ||
          (mesh.isPureGhostNode(n) && node_data(n) == -max_int)
          )
       )
       {
         debug::setDebugLevel(dblTest);
         std::cout << "prank : " << prank << " (node " << gn << "[" << n << "]) - "
                   << "( isMaster: " << mesh.isMasterNode(n) << " && " << node_data(n) << " == "  << gn << ") "
                   << "( isLocal: " << mesh.isLocalNode(n) << " && " << node_data(n) << " == "  <<  - gn << ") "
                   << "( isSlave: " << mesh.isSlaveNode(n) << " && " << node_data(n) << " == "  << gn << ") "
                   << "( isPureGhost: " << mesh.isPureGhostNode(n) << " && " << node_data(n) << " == "  << -max_int << ") "
                   << std::endl;
         debug::setDebugLevel(dblDebug);
         return -1;
       }
   }
 
   finalize();
 
   return 0;
 }
diff --git a/test/test_synchronizer/test_synchronizer_communication.cc b/test/test_synchronizer/test_synchronizer_communication.cc
index 390b4616e..18aab7d4d 100644
--- a/test/test_synchronizer/test_synchronizer_communication.cc
+++ b/test/test_synchronizer/test_synchronizer_communication.cc
@@ -1,160 +1,160 @@
 /**
  * @file   test_synchronizer_communication.cc
  *
  * @author Dana Christen <dana.christen@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Sep 01 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  test to synchronize barycenters
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_random_generator.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_partition_scotch.hh"
 #include "synchronizer_registry.hh"
 /* -------------------------------------------------------------------------- */
 
 //#define DUMP
 
 #if defined(AKANTU_USE_IOHELPER) && defined(DUMP)
 #include "dumper_paraview.hh"
 #endif // AKANTU_USE_IOHELPER
 
 #include "test_data_accessor.hh"
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt spatial_dimension = 3;
 
   Mesh mesh(spatial_dimension);
 
   StaticCommunicator & comm = StaticCommunicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
   bool wait = true;
   if (argc > 1) {
     if (prank == 0)
       while (wait)
         ;
   }
 
   if (prank == 0)
     mesh.read("cube.msh");
 
   mesh.distribute();
 
   /// compute barycenter for each facet
   ElementTypeMapArray<Real> barycenters("barycenters", "", 0);
   barycenters.initialize(mesh, _nb_component = spatial_dimension);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     GhostType ghost_type = *gt;
     Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
     Mesh::type_iterator last_type =
         mesh.lastType(spatial_dimension, ghost_type);
 
     for (; it != last_type; ++it) {
       UInt nb_element = mesh.getNbElement(*it, ghost_type);
       Array<Real> & barycenter = barycenters(*it, ghost_type);
       barycenter.resize(nb_element);
 
       Array<Real>::iterator<Vector<Real>> bary_it =
           barycenter.begin(spatial_dimension);
 
       for (UInt elem = 0; elem < nb_element; ++elem, ++bary_it)
         mesh.getBarycenter(elem, *it, bary_it->storage(), ghost_type);
     }
   }
 
   AKANTU_DEBUG_INFO("Creating TestAccessor");
   TestAccessor test_accessor(mesh, barycenters);
   SynchronizerRegistry synch_registry;
   synch_registry.registerDataAccessor(test_accessor);
   synch_registry.registerSynchronizer(mesh.getElementSynchronizer(), _gst_test);
 
   AKANTU_DEBUG_INFO("Synchronizing tag");
   synch_registry.synchronize(_gst_test);
 
   // Checking the tags in MeshData (not a very good test because they're all
   // identical,
   // but still...)
   Mesh::type_iterator it = mesh.firstType(_all_dimensions);
   Mesh::type_iterator last_type = mesh.lastType(_all_dimensions);
 
   for (; it != last_type; ++it) {
     Array<UInt> & tags = mesh.getData<UInt>("tag_0", *it);
     Array<UInt>::const_vector_iterator tags_it = tags.begin(1);
     Array<UInt>::const_vector_iterator tags_end = tags.end(1);
     AKANTU_DEBUG_ASSERT(
-        mesh.getNbElement(*it) == tags.getSize(),
+        mesh.getNbElement(*it) == tags.size(),
         "The number of tags does not match the number of elements on rank "
             << prank << ".");
     std::cout << std::dec << " I am rank " << prank
               << " and here's my MeshData dump for types " << *it
               << " (it should contain " << mesh.getNbElement(*it)
-              << " elements and it has " << tags.getSize()
+              << " elements and it has " << tags.size()
               << "!) :" << std::endl;
     std::cout << std::hex;
 
     debug::setDebugLevel(dblTest);
     for (; tags_it != tags_end; ++tags_it) {
       std::cout << tags_it->operator()(0) << " ";
     }
 
     debug::setDebugLevel(dblInfo);
     std::cout << std::endl;
   }
 
 #if defined(AKANTU_USE_IOHELPER) && defined(DUMP)
   DumperParaview dumper("test-scotch-partition");
   dumper.registerMesh(mesh, spatial_dimension, _not_ghost);
   dumper.registerField("partitions",
    		       new DumperIOHelper::ElementPartitionField<>(mesh,
                                                                    spatial_dimension, _not_ghost));
   dumper.dump();
 
   DumperParaview dumper_ghost("test-scotch-partition-ghost");
   dumper_ghost.registerMesh(mesh, spatial_dimension, _ghost);
   dumper_ghost.registerField("partitions",
    			     new DumperIOHelper::ElementPartitionField<>(mesh,
                                                                          spatial_dimension, _ghost));
   dumper_ghost.dump();
 #endif //AKANTU_USE_IOHELPER
 
   finalize();
 
   return EXIT_SUCCESS;
 }