diff --git a/.clang-tidy b/.clang-tidy
index badab5d0e..be034c548 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,4 +1,4 @@
-Checks:          'modernize-use-override'
+Checks:          'modernize-use-override, modernize-use-nullptr'
 AnalyzeTemporaryDtors: false
 HeaderFilterRegex: '.*'
 FormatStyle:     file
diff --git a/cmake/Modules/CMakePackagesSystem.cmake b/cmake/Modules/CMakePackagesSystem.cmake
index a9f331968..56cdbba58 100644
--- a/cmake/Modules/CMakePackagesSystem.cmake
+++ b/cmake/Modules/CMakePackagesSystem.cmake
@@ -1,1060 +1,1062 @@
 #===============================================================================
 # @file   CMakePackagesSystem.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Wed Nov 05 2014
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  Set of macros used by akantu to handle the package system
 #
 # @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/>.
 #
 #===============================================================================
 
 #[=======================================================================[.rst:
 #CMakePackagesSystem
 #-------------------
 #
 #This package defines multiple function to handle packages. This packages can
 #be of two kinds regular ones and extra_packages (ex: in akantu the LGPL part
 #is regular packages and extra packages are on Propetary license)
 #
 #Package are loaded with the help of the command:
 #
 #.. command:: package_list_packages
 #
 #     package_list_packages(<regular_package_folder>
 #       [ EXTRA_PACKAGE_FOLDER <extra_package_folder> ]
 #       [ SOURCE_FOLDER <source_folder>]
 #       [ TEST_FOLDER <test_folder> ]
 #       [ MANUAL_FOLDER <manual_folder> ]
 #       )
 #
 #     This command will look for packages name like ``<regular_package_folder>/<package>.cmake``
 #     OR ``<extra_package_folder>/<package>/package.cmake``
 #
 #A package is a cmake script that should contain at list the declaration of a
 #package
 #
 #.. command:: package_declare
 #
 #     package_declare(<package real name>
 #       [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #       [DESCRIPTION <description>] [DEFAULT <default_value>]
 #       [DEPENDS <pkg> ...]
 #       [BOOST_COMPONENTS <pkg> ...]
 #       [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #       [COMPILE_FLAGS <lang> <flags>]
 #       [SYSTEM <bool> [ <script_to_compile> ]]
 #       [FEATURES_PUBLIC <feature> ...]
 #       [FEATURES_PRIVATE <feature> ...]
 #       )
 #
 #.. command:: package_declare_sources
 #
 #     It can also declare multiple informations:
 #     source files:
 #
 #     package_declare_sources(<package real name>
 #       <src1> <src2> ... <srcn>)
 #
 #.. command:: package_declare_documentation
 #
 #     a LaTeX documentation
 #     package_declare_documentation(<package real name>
 #       <line1> <line2> ...<linen>)
 #
 #.. command:: package_declare_documentation_files
 #
 #     LaTeX documentation files
 #     package_declare_documentation_files(<package real name>
 #       <file1> <file2> ... <filen>)
 #
 #Different function can also be retrieved from the package system by using the
 #different accessors
 #
 #.. command:: package_get_name
 #     package_get_name(<pkg> <retval>)
 #
 #.. command:: package_get_real_name
-#     package_get_real_name(<pkg> <retval>)
+#    package_get_real_name(<pkg> <retval>)
 #
 #.. command:: package_get_option_name
 #     package_get_option_name(<pkg> <retval>)
 #
 #.. command:: package_use_system
 #     package_use_system(<pkg> <retval>)
 #
 #.. command:: package_get_nature
 #     package_get_nature(<pkg> <retval>)
 #
 #.. command:: package_get_description
 #     package_get_description(<pkg> <retval>)
 #
 #.. command:: package_get_filename
 #     package_get_filename(<pkg> <retval>)
 #
 #.. command:: package_get_sources_folder
 #     package_get_sources_folder(<pkg> <retval>)
 #.. command:: package_get_tests_folder
 #     package_get_tests_folder(<pkg> <retval>)
 #.. command:: package_get_manual_folder
 #     package_get_manual_folder(<pkg> <retval>)
 #
 #.. command:: package_get_find_package_extra_options
 #     package_get_find_package_extra_options(<pkg> <retval>)
 #
 #.. command:: package_get_compile_flags
 #     package_get_compile_flags(<pkg> <lang> <retval>)
 #.. command:: package_set_compile_flags
 #     package_set_compile_flags(<pkg> <lang> <flag1> <flag2> ... <flagn>)
 #
 #.. command:: package_get_include_dir
 #     package_get_include_dir(<pkg> <retval>)
 #.. command:: package_set_include_dir
 #     package_set_include_dir(<pkg> <inc1> <inc2> ... <incn>)
 #.. command:: package_add_include_dir
 #     package_add_include_dir(<pkg> <inc1> <inc2> ... <incn>)
 #
 #.. command:: package_get_libraries
 #     package_get_libraries(<pkg> <retval>)
 #.. command:: package_set_libraries
 #     package_set_libraries(<pkg> <lib1> <lib2> ... <libn>)
 #
 #.. command:: package_add_extra_dependency
 #     package_add_extra_dependency(pkg <dep1> <dep2> ... <depn>)
 #.. command:: package_rm_extra_dependency
 #     package_rm_extra_dependency(<pkg> <dep>)
 #.. command:: package_get_extra_dependencies
 #     package_get_extra_dependencies(<pkg> <retval>)
 #
 #.. command:: package_is_activated
 #     package_is_activated(<pkg> <retval>)
 #.. command:: package_is_deactivated
 #     package_is_deactivated(<pkg> <retval>)
 #
 #.. command:: package_get_dependencies
 #     package_get_dependencies(<pkg> <retval>)
 #.. command:: package_add_dependencies
 #     package_add_dependencies(<pkg> <dep1> <dep2> ... <depn>)
 #     package_remove_dependencies(<pkg> <dep1> <dep2> ... <depn>)
 #     package_remove_dependency(<pkg> <dep>)
 #
 #.. command:: package_on_enabled_script
 #     package_on_enabled_script(<pkg> <script>)
 #
 #.. command:: package_get_all_source_files
 #     package_get_all_source_files(<srcs> <public_headers> <private_headers>)
 #.. command:: package_get_all_include_directories
 #     package_get_all_include_directories(<inc_dirs>)
 #.. command:: package_get_all_external_informations
 #     package_get_all_external_informations(<include_dir> <libraries>)
 #.. command:: package_get_all_definitions
 #     package_get_all_definitions(<definitions>)
 #.. command:: package_get_all_extra_dependencies
 #     package_get_all_extra_dependencies(<dependencies>)
 #.. command:: package_get_all_test_folders
 #     package_get_all_test_folders(<test_dirs>)
 #.. command:: package_get_all_documentation_files
 #     package_get_all_documentation_files(<doc_files>)
 #.. command:: package_get_all_activated_packages
 #     package_get_all_activated_packages(<activated_list>)
 #.. command:: package_get_all_deactivated_packages
 #     package_get_all_deactivated_packages(<deactivated_list>)
 #.. command:: package_get_all_packages
 #     package_get_all_packages(<packages_list>)
 #.. command:: package_get_all_features_public
 #     package_get_all_features_public(<features>)
 #.. command:: package_get_all_features_private
 #     package_get_all_features_private(<features>)
 #
 #
-#.. command:: package_set_package_system_dependency(<pkg> <system> <dep1>
-#                                                   <dep2> ... <depn>)
+#     .. command:: package_set_package_system_dependency
+#
 #     package_set_package_system_dependency(<pkg> <system> <dep1>
 #                                           <dep2> ... <depn>)
-#.. command:: package_get_package_system_dependency(<pkg> <var>)
+#
+#                                       .. command:: package_get_package_system_dependency
+#
 #     package_get_package_system_dependency(<pkg> <var>)
 #
 #
 #]=======================================================================]
 
 
 include(CMakeParseArguments)
 
 #===============================================================================
 # Package Management
 #===============================================================================
 if(__CMAKE_PACKAGES_SYSTEM)
   return()
 endif()
 set(__CMAKE_PACKAGES_SYSTEM TRUE)
 
 if(CMAKE_VERSION VERSION_GREATER 3.1.2)
   cmake_policy(SET CMP0054 NEW)
 endif()
 
 #===============================================================================
 option(AUTO_MOVE_UNKNOWN_FILES
   "Give to cmake the permission to move the unregistered files to the ${PROJECT_SOURCE_DIR}/tmp directory" FALSE)
 mark_as_advanced(AUTO_MOVE_UNKNOWN_FILES)
 
 
 include(CMakePackagesSystemGlobalFunctions)
 include(CMakePackagesSystemPrivateFunctions)
 
 # ==============================================================================
 # "Public" Accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Package name
 # ------------------------------------------------------------------------------
 function(package_get_name pkg pkg_name)
   string(TOUPPER ${PROJECT_NAME} _project)
   string(REPLACE "-" "_" _str_pkg "${pkg}")
   string(TOUPPER ${_str_pkg} _u_package)
   set(${pkg_name} ${_project}_PKG_${_u_package} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Real name
 # ------------------------------------------------------------------------------
 function(package_get_real_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_real_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Option name
 # ------------------------------------------------------------------------------
 function(package_get_option_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_option_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_use_system pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_use_system(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_third_party_script_variable pkg var)
   package_get_name(${pkg} _pkg_name)
   _package_add_third_party_script_variable(${_pkg_name} ${var} ${ARGN})
   set(${var} ${ARGN} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_add_to_export_list pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_export_list(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Nature
 # ------------------------------------------------------------------------------
 function(package_get_nature pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_nature(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Description
 # ------------------------------------------------------------------------------
 function(package_get_description pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_description(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Package file name
 # ------------------------------------------------------------------------------
 function(package_get_filename pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_filename(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source files
 # ------------------------------------------------------------------------------
 function(package_get_source_files pkg ret_srcs ret_pub ret_priv)
   package_get_name(${pkg} _pkg_name)
   _package_get_source_files(${_pkg_name} _tmp_srcs _tmp_pub _tmp_priv)
   set(${ret_srcs} ${_tmp_srcs} PARENT_SCOPE)
   set(${ret_pub}  ${_tmp_pub}  PARENT_SCOPE)
   set(${ret_priv} ${_tmp_pric} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source folder
 # ------------------------------------------------------------------------------
 function(package_get_sources_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_sources_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Test folder
 # ------------------------------------------------------------------------------
 function(package_get_tests_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_tests_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Manual folder
 # ------------------------------------------------------------------------------
 function(package_get_manual_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_manual_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra option for the find_package
 # ------------------------------------------------------------------------------
 function(package_get_find_package_extra_options pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_find_package_extra_options(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_find_package_extra_options pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_find_package_extra_options(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_compile_flags pkg lang ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_compile_flags(${_pkg_name} ${lang} _tmp)
   set(${ret} "${_tmp}" PARENT_SCOPE)
 endfunction()
 
 function(package_set_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_set_compile_flags(${_pkg_name} ${lang} ${ARGN})
 endfunction()
 
 function(package_unset_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_unset_compile_flags(${_pkg_name} ${lang})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Include dir
 # ------------------------------------------------------------------------------
 function(package_get_include_dir pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_include_dir(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Libraries
 # ------------------------------------------------------------------------------
 function(package_get_libraries pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_libraries(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_libraries pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_libraries(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra dependencies like custom commands of ExternalProject
 # ------------------------------------------------------------------------------
 function(package_add_extra_dependency pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_extra_dependency(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_rm_extra_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   _package_rm_extra_dependency(${_pkg_name} ${dep})
 endfunction()
 
 function(package_get_extra_dependencies pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_extra_dependencies(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Activate/deactivate
 # ------------------------------------------------------------------------------
 function(package_is_activated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_activated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_is_deactivated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_deactivated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Direct dependencies
 # ------------------------------------------------------------------------------
 function(package_get_dependencies pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_dependencies(${_pkg_name} _tmp_name)
   _package_get_real_name(${_tmp_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_dependencies pkg)
   package_get_name(${pkg} _pkg_name)
   foreach(_dep ${ARGN})
     package_get_name(${_dep} _dep_pkg_name)
     list(APPEND _tmp_deps ${_dep_pkg_name})
   endforeach()
 
   _package_add_dependencies(${_pkg_name} ${_tmp_deps})
 endfunction()
 
 function(package_remove_dependencies pkg)
   foreach(_dep ${ARGN})
     package_remove_dependency(${pkg} _dep)
   endforeach()
 endfunction()
 
 function(package_remove_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   package_get_name(${dep} _dep_pkg_name)
   _package_remove_dependency(${_pkg_name} ${_dep_pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation related functions
 # ------------------------------------------------------------------------------
 function(package_declare_documentation pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_declare_documentation_files pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation_files(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set any user variables needed
 # ------------------------------------------------------------------------------
 function(package_set_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_to_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_get_variable variable pkg value)
   package_get_name(${pkg} _pkg_name)
   _package_get_variable(${variable} ${_pkg_name} _value_tmp)
   if(_value_tmp)
     set(${value} ${_value_tmp} PARENT_SCOPE)
   else()
     unset(${value} PARENT_SCOPE)
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Exteral package system as apt rpm dependencies
 # ------------------------------------------------------------------------------
 function(package_set_package_system_dependency pkg system)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${system} ${ARGN})
 endfunction()
 
 function(package_get_package_system_dependency pkg system var)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${sytem} _tmp)
   set(${var} ${_tmp} PARENT_SCOPE)
 endfunction()
 # ------------------------------------------------------------------------------
 
 # ==============================================================================
 # Global accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # get the list of source files
 # ------------------------------------------------------------------------------
 function(package_get_all_source_files SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   unset(_tmp_srcs)
   unset(_tmp_public_headers)
   unset(_tmp_private_headers)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_source_files(${_pkg_name}
       _pkg_srcs
       _pkg_public_headers
       _pkg_private_headers
       )
     list(APPEND _tmp_srcs ${_pkg_srcs})
     list(APPEND _tmp_public_headers ${_pkg_public_headers})
     list(APPEND _tmp_private_headers ${_pkg_private_headers})
   endforeach()
 
   set(${SRCS}            ${_tmp_srcs}            PARENT_SCOPE)
   set(${PUBLIC_HEADERS}  ${_tmp_public_headers}  PARENT_SCOPE)
   set(${PRIVATE_HEADERS} ${_tmp_private_headers} PARENT_SCOPE)
 endfunction()
 
 
 # ------------------------------------------------------------------------------
 # Get include directories
 # ------------------------------------------------------------------------------
 function(package_get_all_include_directories inc_dirs)
   set(_tmp)
   package_get_all_activated_packages(_activated_list)
 
   foreach(_pkg_name ${_activated_list})
     foreach(_type SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
       foreach(_file ${${_pkg_name}_${_type}})
         get_filename_component(_path "${_file}" PATH)
         list(APPEND _tmp "${_path}")
       endforeach()
     endforeach()
   endforeach()
 
   if(_tmp)
     list(REMOVE_DUPLICATES _tmp)
   endif()
 
   set(${inc_dirs} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get external libraries informations
 # ------------------------------------------------------------------------------
 function(package_get_all_external_informations INCLUDE_DIR LIBRARIES)
   _package_get_variable_for_activated(INCLUDE_DIR tmp_INCLUDE_DIR)
   _package_get_variable_for_activated(LIBRARIES tmp_LIBRARIES)
 
   set(${INCLUDE_DIR} ${tmp_INCLUDE_DIR} PARENT_SCOPE)
   set(${LIBRARIES}   ${tmp_LIBRARIES}   PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get export list for all activated packages
 # ------------------------------------------------------------------------------
 function(package_get_all_export_list export_list)
   _package_get_variable_for_activated(EXPORT_LIST _tmp)
   set(${export_list} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get definitions like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_definitions definitions)
   _package_get_variable_for_activated(OPTION_NAME _tmp)
   set(${definitions} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra dependencies like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_extra_dependencies deps)
   _package_get_variable_for_activated(EXTRA_DEPENDENCY _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra infos
 # ------------------------------------------------------------------------------
 function(package_get_all_test_folders TEST_DIRS)
   _package_get_variable_for_activated(TEST_FOLDER _tmp)
   set(${TEST_DIRS} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_all_compilation_flags LANG FLAGS)
   _package_get_variable_for_activated(COMPILE_${LANG}_FLAGS _tmp_flags)
   string(REPLACE ";" " " _flags "${_tmp_flags}")
   set(${FLAGS} ${_flags} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation informations
 # ------------------------------------------------------------------------------
 function(package_get_all_documentation_files doc_files)
   set(_tmp_DOC_FILES)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_manual_folder(${_pkg_name} _doc_dir)
     _package_get_documentation_files(${_pkg_name} _doc_files)
 
     foreach(_doc_file ${_doc_files})
       list(APPEND _tmp_DOC_FILES ${_doc_dir}/${_doc_file})
     endforeach()
   endforeach()
 
   if(_tmp_DOC_FILES)
     list(REMOVE_DUPLICATES _tmp_DOC_FILES)
   endif()
 
   set(${doc_files} ${_tmp_DOC_FILES} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get package systems dependencies
 # ------------------------------------------------------------------------------
 function(package_get_all_package_system_dependency system deps)
   string(TOUPPER ${system} _u_system)
   _package_get_variable_for_activated(PACKAGE_SYSTEM_${_u_system} _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List packages
 # ------------------------------------------------------------------------------
 function(package_get_all_activated_packages activated_list)
   package_get_project_variable(ACTIVATED_PACKAGE_LIST _activated_list)
   set(${activated_list} ${_activated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_deactivated_packages deactivated_list)
   package_get_project_variable(DEACTIVATED_PACKAGE_LIST _deactivated_list)
   set(${deactivated_list} ${_deactivated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_packages packages_list)
   package_get_project_variable(ALL_PACKAGES_LIST _packages_list)
   set(${packages_list} ${_packages_list} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List all the needed features
 # ------------------------------------------------------------------------------
 function(package_get_all_features_public features)
   _package_get_variable_for_activated(FEATURES_PUBLIC _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_features_private features)
   _package_get_variable_for_activated(FEATURES_PRIVATE _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Callbacks
 # ------------------------------------------------------------------------------
 function(package_on_enabled_script pkg script)
   package_get_name(${pkg} _pkg_name)
   _package_on_enable_script(${_pkg_name} "${script}")
 endfunction()
 
 # ------------------------------------------------------------------------------
 # list all the packages in the PACKAGE_FOLDER
 # extra packages can be given with an EXTRA_PACKAGE_FOLDER
 # <package_folder>/<package>.cmake
 #
 # Extra packages folder structure
 # <extra_package_folder>/<package>/package.cmake
 #                                 /src
 #                                 /test
 #                                 /manual
 #
 # ------------------------------------------------------------------------------
 function(package_list_packages PACKAGE_FOLDER)
   cmake_parse_arguments(_opt_pkg
     "NO_AUTO_COMPILE_FLAGS"
     "SOURCE_FOLDER;EXTRA_PACKAGES_FOLDER;TEST_FOLDER;MANUAL_FOLDER"
     ""
     ${ARGN})
 
   string(TOUPPER ${PROJECT_NAME} _project)
 
   # Cleaning some states to start correctly
   package_get_all_packages(_already_loaded_pkg)
   foreach(_pkg_name ${_already_loaded_pkg})
     _package_unset_extra_dependencies(${_pkg_name})
     _package_unset_dependencies(${_pkg_name})
     _package_unset_activated(${_pkg_name})
   endforeach()
 
 
   if(_opt_pkg_SOURCE_FOLDER)
     set(_src_folder "${_opt_pkg_SOURCE_FOLDER}")
   else()
     set(_src_folder "src/")
   endif()
 
   get_filename_component(_abs_src_folder ${_src_folder} ABSOLUTE)
 
   if(_opt_pkg_TEST_FOLDER)
     set(_test_folder "${_opt_pkg_TEST_FOLDER}")
   else()
     set(_test_folder "test/")
   endif()
 
   if(_opt_pkg_MANUAL_FOLDER)
     set(_manual_folder "${_opt_pkg_MANUAL_FOLDER}")
   else()
     set(_manual_folder "doc/manual")
   endif()
 
   if(_opt_pkg_NO_AUTO_COMPILE_FLAGS)
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS TRUE)
   else()
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS FALSE)
   endif()
 
 
   get_filename_component(_abs_test_folder ${_test_folder} ABSOLUTE)
   get_filename_component(_abs_manual_folder ${_manual_folder} ABSOLUTE)
 
   # check all the packages in the <package_folder>
   file(GLOB _package_list "${PACKAGE_FOLDER}/*.cmake")
 
   set(_package_files)
   foreach(_pkg ${_package_list})
     get_filename_component(_basename ${_pkg} NAME)
     if(NOT _basename MATCHES "^\\.#.*")
       list(APPEND _package_files ${_basename})
     endif()
   endforeach()
 
   if(_package_files)
     list(SORT _package_files)
   endif()
 
   # check all packages
   set(_packages_list_all)
   foreach(_pkg_file ${_package_files})
     string(REGEX REPLACE "[0-9]+_" "" _pkg_file_stripped ${_pkg_file})
     string(REGEX REPLACE "\\.cmake" "" _pkg ${_pkg_file_stripped})
 
     set(_current_src_folder "${_abs_src_folder}" CACHE INTERNAL "" FORCE)
     set(_current_test_folder "${_abs_test_folder}" CACHE INTERNAL "" FORCE)
     set(_current_manual_folder "${_abs_manual_folder}" CACHE INTERNAL "" FORCE)
 
     include("${PACKAGE_FOLDER}/${_pkg_file}")
 
     unset(_current_src_folder CACHE)
     unset(_current_test_folder CACHE)
     unset(_current_manual_folder CACHE)
   endforeach()
 
   # check the extra_packages if they exists
   if(_opt_pkg_EXTRA_PACKAGES_FOLDER)
     file(GLOB _extra_package_list RELATIVE
       "${_opt_pkg_EXTRA_PACKAGES_FOLDER}" "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/*")
     foreach(_pkg ${_extra_package_list})
       if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         package_get_name(${_pkg} _pkg_name)
 
         _package_set_filename(${_pkg_name}
           "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         set(_current_src_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src" CACHE INTERNAL "" FORCE)
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test")
           set(_current_test_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test" CACHE INTERNAL "" FORCE)
         endif()
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual")
           set(_current_manual_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual" CACHE INTERNAL "" FORCE)
         endif()
 
         list(APPEND _extra_pkg_src_folders "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src")
 
         include("${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         unset(_current_src_folder CACHE)
         unset(_current_test_folder CACHE)
         unset(_current_manual_folder CACHE)
       endif()
     endforeach()
   endif()
 
   _package_build_rdependencies()
   _package_load_packages()
   _package_check_files_exists()
   _package_check_files_registered(${_abs_src_folder} ${_extra_pkg_src_folders})
 
   # Load boost components if boost was loaded
   package_is_activated(Boost _ret)
   if(_ret)
     _package_load_boost_components()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # macro to include internal/external packages packages
 # package_declare(<package real name>
 #                 [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #                 [DESCRIPTION <description>] [DEFAULT <default_value>]
 #                 [DEPENDS <pkg> ...]
 #                 [BOOST_COMPONENTS <pkg> ...]
 #                 [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #                 [COMPILE_FLAGS <lang> <flags>]
 #                 [SYSTEM <bool> [ <script_to_compile> ]]
 #                 [FEATURES_PUBLIC <feature> ...]
 #                 [FEATURES_PRIVATE <feature> ...])
 # ------------------------------------------------------------------------------
 function(package_declare pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_real_name(${_pkg_name} ${pkg})
   _package_set_filename(${_pkg_name} "${CMAKE_CURRENT_LIST_FILE}")
 
   _package_set_sources_folder(${_pkg_name} "${_current_src_folder}")
 
   _package_variable_unset(SRCS ${_pkg_name})
   _package_variable_unset(PUBLIC_HEADERS ${_pkg_name})
   _package_variable_unset(PRIVATE_HEADERS ${_pkg_name})
 
   if(_current_test_folder)
     _package_set_tests_folder(${_pkg_name} "${_current_test_folder}")
   endif()
 
   if(_current_manual_folder)
     _package_set_manual_folder(${_pkg_name} "${_current_manual_folder}")
   endif()
 
   package_get_project_variable(ALL_PACKAGES_LIST _tmp_pkg_list)
   list(APPEND _tmp_pkg_list ${_pkg_name})
   list(REMOVE_DUPLICATES _tmp_pkg_list)
   package_set_project_variable(ALL_PACKAGES_LIST ${_tmp_pkg_list})
 
   set(_options
     EXTERNAL
     NOT_OPTIONAL
     META
     ADVANCED)
   set(_one_valued_options
     DEFAULT
     DESCRIPTION)
   set(_multi_valued_options
     DEPENDS
     EXTRA_PACKAGE_OPTIONS
     COMPILE_FLAGS BOOST_COMPONENTS
     SYSTEM
     FEATURES_PUBLIC
     FEATURES_PRIVATE)
 
   cmake_parse_arguments(_opt_pkg
     "${_options}"
     "${_one_valued_options}"
     "${_multi_valued_options}"
     ${ARGN})
 
   if(_opt_pkg_UNPARSED_ARGUMENTS)
     message("You gave to many arguments while registering the package ${pkg} \"${_opt_pkg_UNPARSED_ARGUMENTS}\"")
   endif()
 
   # set the nature
   if(_opt_pkg_EXTERNAL)
     _package_set_nature(${_pkg_name} "external")
   elseif(_opt_pkg_META)
     _package_set_nature(${_pkg_name} "meta")
   else()
     _package_set_nature(${_pkg_name} "internal")
   endif()
 
   _package_declare_option(${_pkg_name})
 
   # set description
   if(_opt_pkg_DESCRIPTION)
     _package_set_description(${_pkg_name} ${_opt_pkg_DESCRIPTION})
   else()
     _package_set_description(${_pkg_name} "")
   endif()
 
   _package_get_option_name(${_pkg_name} _option_name)
   _package_get_description(${_pkg_name} _description)
 
   # get the default value
   if(DEFINED _opt_pkg_DEFAULT)
     set(_default ${_opt_pkg_DEFAULT})
   else()
     if(_opt_pkg_NOT_OPTIONAL)
       set(_default ON)
     else()
       set(_default OFF)
     endif()
   endif()
 
   # set the option if needed
   if(_opt_pkg_NOT_OPTIONAL)
     _package_get_nature(${_pkg_name} _nature)
     _package_set_nature(${_pkg_name} "${_nature}_not_optional")
     set(${_option_name} ${_default} CACHE INTERNAL "${_description}" FORCE)
   else()
     option(${_option_name} "${_description}" ${_default})
     if(_opt_pkg_ADVANCED OR _opt_pkg_EXTERNAL)
       mark_as_advanced(${_option_name})
     endif()
   endif()
 
   # Set the option for third-partie that can be compiled as an ExternalProject
   if(DEFINED _opt_pkg_SYSTEM)
     list(LENGTH _opt_pkg_SYSTEM _length)
     list(GET _opt_pkg_SYSTEM 0 _bool)
     _package_set_system_option(${_pkg_name} ${_bool})
     if(_length GREATER 1)
       list(GET _opt_pkg_SYSTEM 1 _script)
       _package_set_system_script(${_pkg_name} ${_script})
     endif()
   endif()
 
   # set the dependecies
   if(_opt_pkg_DEPENDS)
     set(_depends)
     foreach(_dep ${_opt_pkg_DEPENDS})
       package_get_name(${_dep} _dep_pkg_name)
       list(APPEND _depends ${_dep_pkg_name})
     endforeach()
     _package_add_dependencies(${_pkg_name} ${_depends})
   endif()
 
   # keep the extra option for the future find package
   if(_opt_pkg_EXTRA_PACKAGE_OPTIONS)
     _package_set_find_package_extra_options(${_pkg_name} "${_opt_pkg_EXTRA_PACKAGE_OPTIONS}")
   endif()
 
   # register the compilation flags
   if(_opt_pkg_COMPILE_FLAGS)
     set(_languages C CXX Fortran)
     cmake_parse_arguments(_compile_flags
       "" "" "${_languages}"
       ${_opt_pkg_COMPILE_FLAGS}
       )
 
 
     # this is done to maintain backward compatibility
     if(_compile_flags_UNPARSED_ARGUMENTS)
       set(_compile_flags_CXX ${_compile_flags_UNPARSED_ARGUMENTS})
     endif()
 
     foreach(_lang ${_languages})
       if(_compile_flags_${_lang})
         _package_set_compile_flags(${_pkg_name} ${_lang} ${_compile_flags_${_lang}})
       else()
         _package_unset_compile_flags(${_pkg_name} ${_lang})
       endif()
     endforeach()
   endif()
 
   # set the boost dependencies
   if(_opt_pkg_BOOST_COMPONENTS)
     _package_set_boost_component_needed(${_pkg_name} "${_opt_pkg_BOOST_COMPONENTS}")
   endif()
 
   if(_opt_pkg_FEATURES_PUBLIC)
     _package_set_variable(FEATURES_PUBLIC ${_pkg_name} "${_opt_pkg_FEATURES_PUBLIC}")
   endif()
 
   if(_opt_pkg_FEATURES_PRIVATE)
     _package_set_variable(FEATURES_PRIVATE ${_pkg_name} "${_opt_pkg_FEATURES_PRIVATE}")
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # declare the source files of a given package
 #
 # package_declare_sources(<package> <list of sources>
 #                         SOURCES <source file> ...
 #                         PUBLIC_HEADER <header file> ...
 #                         PRIVATE_HEADER <header file> ...)
 # ------------------------------------------------------------------------------
 function(package_declare_sources pkg)
   package_get_name(${pkg} _pkg_name)
 
   # get 3 lists, if none of the options given try to distinguish the different lists
   cmake_parse_arguments(_opt_pkg
     ""
     ""
     "SOURCES;PUBLIC_HEADERS;PRIVATE_HEADERS"
     ${ARGN})
 
   set(_tmp_srcs     ${_opt_pkg_SOURCES})
   set(_tmp_pub_hdrs ${_opt_pkg_PUBLIC_HEADER})
   set(_tmp_pri_hdrs ${_opt_pkg_PRIVATE_HEADERS})
 
   foreach(_file ${_opt_pkg_UNPARSED_ARGUMENTS})
     if(${_file} MATCHES ".*inline.*\\.cc")
       list(APPEND _tmp_pub_hdrs ${_file})
     elseif(${_file} MATCHES ".*\\.h+")
       list(APPEND _tmp_pub_hdrs ${_file})
     else()
       list(APPEND _tmp_srcs ${_file})
     endif()
   endforeach()
 
   _package_get_sources_folder(${_pkg_name} _src_folder)
 
   foreach(_type _srcs _pub_hdrs _pri_hdrs)
     set(${_type})
     foreach(_file ${_tmp${_type}})
       # get the full name
       list(APPEND ${_type} "${_src_folder}/${_file}")
     endforeach()
   endforeach()
 
   set(${_pkg_name}_SRCS "${_srcs}"
     CACHE INTERNAL "List of sources files" FORCE)
   set(${_pkg_name}_PUBLIC_HEADERS  "${_pub_hdrs}"
     CACHE INTERNAL "List of public header files" FORCE)
   set(${_pkg_name}_PRIVATE_HEADERS "${_pri_hdrs}"
     CACHE INTERNAL "List of private header files" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
diff --git a/src/common/aka_array_tmpl.hh b/src/common/aka_array_tmpl.hh
index 5c3a508ea..ed5c40a47 100644
--- a/src/common/aka_array_tmpl.hh
+++ b/src/common/aka_array_tmpl.hh
@@ -1,1250 +1,1251 @@
 /**
  * @file   aka_array_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jul 15 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  Inline functions of the classes Array<T> and ArrayBase
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions Array<T>                                                 */
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <memory>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_ARRAY_TMPL_HH__
 #define __AKANTU_AKA_ARRAY_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator()(UInt i, UInt j) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator()(UInt i, UInt j) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_) && (j < nb_component),
                       "The value at position ["
                           << i << "," << j << "] is out of range in array \""
                           << id << "\"");
   return values[i * nb_component + j];
 }
 
 template <class T, bool is_scal>
 inline T & Array<T, is_scal>::operator[](UInt i) {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 inline const T & Array<T, is_scal>::operator[](UInt i) const {
   AKANTU_DEBUG_ASSERT(size_ > 0, "The array \"" << id << "\" is empty");
   AKANTU_DEBUG_ASSERT((i < size_ * nb_component),
                       "The value at position ["
                           << i << "] is out of range in array \"" << id
                           << "\"");
   return values[i];
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array with the value value for all components
  * @param value the new last tuple or the array will contain nb_component copies
  * of value
  */
 template <class T, bool is_scal>
 inline void Array<T, is_scal>::push_back(const T & value) {
   resizeUnitialized(size_ + 1, true, value);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param new_elem a C-array containing the values to be copied to the end of
  * the array */
 // template <class T, bool is_scal>
 // inline void Array<T, is_scal>::push_back(const T new_elem[]) {
 //   UInt pos = size_;
 
 //   resizeUnitialized(size_ + 1, false);
 
 //   T * tmp = values + nb_component * pos;
 //   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 // }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a matrix or a vector to the array
  * @param new_elem a reference to a Matrix<T> or Vector<T> */
 template <class T, bool is_scal>
 template <template <typename> class C>
 inline void Array<T, is_scal>::push_back(const C<T> & new_elem) {
   AKANTU_DEBUG_ASSERT(
       nb_component == new_elem.size(),
       "The vector("
           << new_elem.size()
           << ") as not a size compatible with the Array (nb_component="
           << nb_component << ").");
   UInt pos = size_;
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   std::uninitialized_copy(new_elem.storage(), new_elem.storage() + nb_component,
                           tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * append a tuple to the array
  * @param it an iterator to the tuple to be copied to the end of the array */
 template <class T, bool is_scal>
 template <class Ret>
 inline void
 Array<T, is_scal>::push_back(const Array<T, is_scal>::iterator<Ret> & it) {
   UInt pos = size_;
 
   resizeUnitialized(size_ + 1, false);
 
   T * tmp = values + nb_component * pos;
   T * new_elem = it.data();
   std::uninitialized_copy(new_elem, new_elem + nb_component, tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * erase an element. If the erased element is not the last of the array, the
  * last element is moved into the hole in order to maintain contiguity. This
  * may invalidate existing iterators (For instance an iterator obtained by
  * Array::end() is no longer correct) and will change the order of the
  * elements.
  * @param i index of element to erase
  */
 template <class T, bool is_scal> inline void Array<T, is_scal>::erase(UInt i) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT((size_ > 0), "The array is empty");
   AKANTU_DEBUG_ASSERT((i < size_), "The element at position ["
                                        << i << "] is out of range (" << i
                                        << ">=" << size_ << ")");
 
   if (i != (size_ - 1)) {
     for (UInt j = 0; j < nb_component; ++j) {
       values[i * nb_component + j] = values[(size_ - 1) * nb_component + j];
     }
   }
 
   resize(size_ - 1);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Subtract another array entry by entry from this array in place. Both arrays
  * must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to subtract from this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator-=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size_) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a -= *b;
     ++a;
     ++b;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Add another array entry by entry to this array in place. Both arrays must
  * have the same size and nb_component. If the arrays have different shapes,
  * code compiled in debug mode will throw an expeption and optimised code
  * will behave in an unpredicted manner
  * @param other array to add to this
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::
 operator+=(const Array<T, is_scal> & vect) {
   AKANTU_DEBUG_ASSERT((size_ == vect.size) &&
                           (nb_component == vect.nb_component),
                       "The too array don't have the same sizes");
 
   T * a = values;
   T * b = vect.storage();
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ += *b++;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Multiply all entries of this array by a scalar in place
  * @param alpha scalar multiplicant
  * @return reference to modified this
  */
 template <class T, bool is_scal>
 Array<T, is_scal> & Array<T, is_scal>::operator*=(const T & alpha) {
   T * a = values;
   for (UInt i = 0; i < size_ * nb_component; ++i) {
     *a++ *= alpha;
   }
 
   return *this;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Compare this array element by element to another.
  * @param other array to compare to
  * @return true it all element are equal and arrays have the same shape, else
  * false
  */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator==(const Array<T, is_scal> & array) const {
   bool equal = nb_component == array.nb_component && size_ == array.size_ &&
                id == array.id;
   if (!equal)
     return false;
 
   if (values == array.storage())
     return true;
   else
     return std::equal(values, values + size_ * nb_component, array.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 bool Array<T, is_scal>::operator!=(const Array<T, is_scal> & array) const {
   return !operator==(array);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * set all tuples of the array to a given vector or matrix
  * @param vm Matrix or Vector to fill the array with
  */
 template <class T, bool is_scal>
 template <template <typename> class C>
 inline void Array<T, is_scal>::set(const C<T> & vm) {
   AKANTU_DEBUG_ASSERT(
       nb_component == vm.size(),
       "The size of the object does not match the number of components");
   for (T * it = values; it < values + nb_component * size_;
        it += nb_component) {
     std::copy(vm.storage(), vm.storage() + nb_component, it);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::append(const Array<T> & other) {
   AKANTU_DEBUG_ASSERT(
       nb_component == other.nb_component,
       "Cannot append an array with a different number of component");
   UInt old_size = this->size_;
   this->resizeUnitialized(this->size_ + other.size(), false);
 
   T * tmp = values + nb_component * old_size;
   std::uninitialized_copy(other.storage(),
                           other.storage() + other.size() * nb_component, tmp);
 }
 
 /* -------------------------------------------------------------------------- */
 /* Functions Array<T, is_scal>                                                */
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   if (!is_scal) {
     T val = T();
     std::uninitialized_fill(values, values + size * nb_component, val);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T def_values[],
                          const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   T * tmp = values;
 
   for (UInt i = 0; i < size; ++i) {
     tmp = values + nb_component * i;
     std::uninitialized_copy(def_values, def_values + nb_component, tmp);
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(UInt size, UInt nb_component, const T & value,
                          const ID & id)
     : ArrayBase(id), values(NULL) {
   AKANTU_DEBUG_IN();
   allocate(size, nb_component);
 
   std::uninitialized_fill_n(values, size * nb_component, value);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const Array<T, is_scal> & vect, bool deep,
                          const ID & id)
     : ArrayBase(vect) {
   AKANTU_DEBUG_IN();
   this->id = (id == "") ? vect.id : id;
 
   if (deep) {
     allocate(vect.size_, vect.nb_component);
     T * tmp = values;
     std::uninitialized_copy(vect.storage(),
                             vect.storage() + size_ * nb_component, tmp);
   } else {
     this->values = vect.storage();
     this->size_ = vect.size_;
     this->nb_component = vect.nb_component;
     this->allocated_size = vect.allocated_size;
     this->size_of_type = vect.size_of_type;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 #ifndef SWIG
 template <class T, bool is_scal>
 Array<T, is_scal>::Array(const std::vector<T> & vect) {
   AKANTU_DEBUG_IN();
   this->id = "";
 
   allocate(vect.size(), 1);
   T * tmp = values;
   std::uninitialized_copy(&(vect[0]), &(vect[size_ - 1]), tmp);
 
   AKANTU_DEBUG_OUT();
 }
 #endif
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> Array<T, is_scal>::~Array() {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG(dblAccessory,
                "Freeing " << printMemorySize<T>(allocated_size * nb_component)
                           << " (" << id << ")");
 
   if (values) {
     if (!is_scal)
       for (UInt i = 0; i < size_ * nb_component; ++i) {
         T * obj = values + i;
         obj->~T();
       }
     free(values);
   }
   size_ = allocated_size = 0;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * perform the allocation for the constructors
  * @param size is the size of the array
  * @param nb_component is the number of component of the array
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::allocate(UInt size, UInt nb_component) {
   AKANTU_DEBUG_IN();
   if (size == 0) {
     values = nullptr;
   } else {
     values = static_cast<T *>(malloc(nb_component * size * sizeof(T)));
     AKANTU_DEBUG_ASSERT(values != nullptr,
                         "Cannot allocate "
                             << printMemorySize<T>(size * nb_component) << " ("
                             << id << ")");
   }
 
   if (values == NULL) {
     this->size_ = this->allocated_size = 0;
   } else {
     AKANTU_DEBUG(dblAccessory, "Allocated "
                                    << printMemorySize<T>(size * nb_component)
                                    << " (" << id << ")");
     this->size_ = this->allocated_size = size;
   }
 
   this->size_of_type = sizeof(T);
   this->nb_component = nb_component;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::reserve(UInt new_size) {
   UInt tmp_size = this->size_;
   resizeUnitialized(new_size, false);
   this->size_ = tmp_size;
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal> void Array<T, is_scal>::resize(UInt new_size) {
   resizeUnitialized(new_size, !is_scal);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed. If the
  * size increases, the new tuples are filled with zeros
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resize(UInt new_size, const T & val) {
   this->resizeUnitialized(new_size, true, val);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the size of the array and allocate or free memory if needed.
  * @param new_size new number of tuples contained in the array */
 template <class T, bool is_scal>
 void Array<T, is_scal>::resizeUnitialized(UInt new_size, bool fill,
                                           const T & val) {
   //  AKANTU_DEBUG_IN();
   // free some memory
   if (new_size <= allocated_size) {
     if (!is_scal) {
       T * old_values = values;
       if (new_size < size_) {
         for (UInt i = new_size * nb_component; i < size_ * nb_component; ++i) {
           T * obj = old_values + i;
           obj->~T();
         }
       }
     }
 
     if (allocated_size - new_size > AKANTU_MIN_ALLOCATION) {
       AKANTU_DEBUG(dblAccessory,
                    "Freeing " << printMemorySize<T>((allocated_size - size_) *
                                                     nb_component)
                               << " (" << id << ")");
 
       // Normally there are no allocation problem when reducing an array
       if (new_size == 0) {
         free(values);
         values = NULL;
       } else {
         auto * tmp_ptr = static_cast<T *>(
             realloc(values, new_size * nb_component * sizeof(T)));
 
         if (tmp_ptr == NULL) {
           AKANTU_EXCEPTION("Cannot free data ("
                            << id << ")"
                            << " [current allocated size : " << allocated_size
                            << " | "
                            << "requested size : " << new_size << "]");
         }
         values = tmp_ptr;
       }
       allocated_size = new_size;
     }
   } else {
     // allocate more memory
     UInt size_to_alloc = (new_size - allocated_size < AKANTU_MIN_ALLOCATION)
                              ? allocated_size + AKANTU_MIN_ALLOCATION
                              : new_size;
 
     auto * tmp_ptr = static_cast<T *>(
         realloc(values, size_to_alloc * nb_component * sizeof(T)));
     AKANTU_DEBUG_ASSERT(
         tmp_ptr != NULL,
         "Cannot allocate " << printMemorySize<T>(size_to_alloc * nb_component));
     if (tmp_ptr == NULL) {
       AKANTU_DEBUG_ERROR("Cannot allocate more data ("
                          << id << ")"
                          << " [current allocated size : " << allocated_size
                          << " | "
                          << "requested size : " << new_size << "]");
     }
 
     AKANTU_DEBUG(dblAccessory,
                  "Allocating " << printMemorySize<T>(
                      (size_to_alloc - allocated_size) * nb_component));
 
     allocated_size = size_to_alloc;
     values = tmp_ptr;
   }
 
   if (fill && this->size_ < new_size) {
     std::uninitialized_fill(values + size_ * nb_component,
                             values + new_size * nb_component, val);
   }
 
   size_ = new_size;
   //  AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * change the number of components by interlacing data
  * @param multiplicator number of interlaced components add
  * @param block_size blocks of data in the array
  * Examaple for block_size = 2, multiplicator = 2
  * array = oo oo oo -> new array = oo nn nn oo nn nn oo nn nn */
 template <class T, bool is_scal>
 void Array<T, is_scal>::extendComponentsInterlaced(UInt multiplicator,
                                                    UInt block_size) {
   AKANTU_DEBUG_IN();
 
   if (multiplicator == 1)
     return;
 
   AKANTU_DEBUG_ASSERT(multiplicator > 1, "invalid multiplicator");
   AKANTU_DEBUG_ASSERT(nb_component % block_size == 0,
                       "stride must divide actual number of components");
 
   values = static_cast<T *>(
       realloc(values, nb_component * multiplicator * size_ * sizeof(T)));
 
   UInt new_component = nb_component / block_size * multiplicator;
 
   for (UInt i = 0, k = size_ - 1; i < size_; ++i, --k) {
     for (UInt j = 0; j < new_component; ++j) {
       UInt m = new_component - j - 1;
       UInt n = m / multiplicator;
       for (UInt l = 0, p = block_size - 1; l < block_size; ++l, --p) {
         values[k * nb_component * multiplicator + m * block_size + p] =
             values[k * nb_component + n * block_size + p];
       }
     }
   }
 
   nb_component = nb_component * multiplicator;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * search elem in the array, return  the position of the first occurrence or
  * -1 if not found
  *  @param elem the element to look for
  *  @return index of the first occurrence of elem or -1 if elem is not present
  */
 template <class T, bool is_scal>
 UInt Array<T, is_scal>::find(const T & elem) const {
   AKANTU_DEBUG_IN();
 
   auto begin = this->begin();
   auto end = this->end();
   auto it = std::find(begin, end, elem);
 
   AKANTU_DEBUG_OUT();
   return (it != end) ? it - begin : UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal> UInt Array<T, is_scal>::find(T elem[]) const {
   AKANTU_DEBUG_IN();
   T * it = values;
   UInt i = 0;
   for (; i < size_; ++i) {
     if (*it == elem[0]) {
       T * cit = it;
       UInt c = 0;
       for (; (c < nb_component) && (*cit == elem[c]); ++c, ++cit)
         ;
       if (c == nb_component) {
         AKANTU_DEBUG_OUT();
         return i;
       }
     }
     it += nb_component;
   }
   return UInt(-1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <template <typename> class C>
 inline UInt Array<T, is_scal>::find(const C<T> & elem) {
   AKANTU_DEBUG_ASSERT(elem.size() == nb_component,
                       "Cannot find an element with a wrong size ("
                           << elem.size() << ") != " << nb_component);
   return this->find(elem.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * copy the content of another array. This overwrites the current content.
  * @param other Array to copy into this array. It has to have the same
  * nb_component as this. If compiled in debug mode, an incorrect other will
  * result in an exception being thrown. Optimised code may result in
  * unpredicted behaviour.
  */
 template <class T, bool is_scal>
 void Array<T, is_scal>::copy(const Array<T, is_scal> & vect,
                              bool no_sanity_check) {
   AKANTU_DEBUG_IN();
 
   if (!no_sanity_check)
     if (vect.nb_component != nb_component)
       AKANTU_DEBUG_ERROR(
           "The two arrays do not have the same number of components");
 
   resize((vect.size_ * vect.nb_component) / nb_component);
 
   T * tmp = values;
   std::uninitialized_copy(vect.storage(), vect.storage() + size_ * nb_component,
                           tmp);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <bool is_scal> class ArrayPrintHelper {
 public:
   template <typename T>
   static void print_content(const Array<T> & vect, std::ostream & stream,
                             int indent) {
     if (AKANTU_DEBUG_TEST(dblDump) || AKANTU_DEBUG_LEVEL_IS_TEST()) {
       std::string space;
       for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
         ;
 
       stream << space << " + values         : {";
       for (UInt i = 0; i < vect.size(); ++i) {
         stream << "{";
         for (UInt j = 0; j < vect.getNbComponent(); ++j) {
           stream << vect(i, j);
           if (j != vect.getNbComponent() - 1)
             stream << ", ";
         }
         stream << "}";
         if (i != vect.size() - 1)
           stream << ", ";
       }
       stream << "}" << std::endl;
     }
   }
 };
 
 template <> class ArrayPrintHelper<false> {
 public:
   template <typename T>
   static void print_content(__attribute__((unused)) const Array<T> & vect,
                             __attribute__((unused)) std::ostream & stream,
                             __attribute__((unused)) int indent) {}
 };
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 void Array<T, is_scal>::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   std::streamsize prec = stream.precision();
   std::ios_base::fmtflags ff = stream.flags();
 
   stream.setf(std::ios_base::showbase);
   stream.precision(2);
 
   stream << space << "Array<" << debug::demangle(typeid(T).name()) << "> ["
          << std::endl;
   stream << space << " + id             : " << this->id << std::endl;
   stream << space << " + size           : " << this->size_ << std::endl;
   stream << space << " + nb_component   : " << this->nb_component << std::endl;
   stream << space << " + allocated size : " << this->allocated_size
          << std::endl;
   stream << space << " + memory size    : "
          << printMemorySize<T>(allocated_size * nb_component) << std::endl;
   if (!AKANTU_DEBUG_LEVEL_IS_TEST())
     stream << space << " + address        : " << std::hex << this->values
            << std::dec << std::endl;
 
   stream.precision(prec);
   stream.flags(ff);
 
   ArrayPrintHelper<is_scal>::print_content(*this, stream, indent);
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Inline Functions ArrayBase                                                */
 /* -------------------------------------------------------------------------- */
 
 inline UInt ArrayBase::getMemorySize() const {
   return allocated_size * nb_component * size_of_type;
 }
 
 inline void ArrayBase::empty() { size_ = 0; }
 
 /* -------------------------------------------------------------------------- */
 /* 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                                         */
 /* -------------------------------------------------------------------------- */
 namespace {
   template <std::size_t N> struct extract_last {
     template <typename F, typename... T, typename... Arg>
     static decltype(auto) extract(F && func, std::tuple<T...> && t,
                                   Arg... args) {
       return extract_last<N - 1>::extract(
           std::forward<F>(func), std::forward<decltype(t)>(t),
           std::get<sizeof...(T) - N>(std::forward<decltype(t)>(t)), args...);
     }
   };
 
   template <> struct extract_last<1> {
     template <typename F, typename... T, typename... Arg>
     static decltype(auto) extract(F && func, std::tuple<T...> && /*unused*/,
                                   Arg... args) {
       return std::forward<F>(func)(args...);
     }
   };
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wnarrowing"
   template <std::size_t N> struct InstantiationHelper {
     template <typename... Ns> static constexpr std::size_t product(Ns... ns) {
       std::size_t p = 1;
       for (auto n : std::array<std::size_t, sizeof...(Ns)>{ns...})
         p *= n;
       return p;
     }
 
     template <typename... Ns> static std::string to_string(Ns... ns) {
       std::stringstream sstr;
       bool first = true;
       sstr << "(";
       for (auto n : std::array<std::size_t, sizeof...(Ns)>{ns...}) {
         if (!first) {
           sstr << ", ";
         }
         sstr << n;
         first = false;
       }
       sstr << ")";
       return sstr.str();
     }
 #pragma GCC diagnostic pop
     template <typename type, typename T, typename... Ns>
     static auto instantiate(T && data, Ns... ns) {
       return new type(data, ns...);
     }
   };
 
   template <> struct InstantiationHelper<0> {
     template <typename type, typename T> static auto instantiate(T && data) {
       return data;
     }
 
     static constexpr std::size_t product() { return 1; }
     static std::string to_string() { return ""; }
   };
 
   template <typename Arr, typename T, typename... Ns>
   decltype(auto) get_iterator(Arr && array, T * data, Ns... ns) {
     using type = IteratorHelper_t<sizeof...(Ns) -1, T>;
     using array_type = std::decay_t<Arr>;
     using iterator =
         std::conditional_t<std::is_const<Arr>::value,
                            typename array_type::template const_iterator<type>,
                            typename array_type::template iterator<type>>;
     AKANTU_DEBUG_ASSERT(
         array.getNbComponent() * array.size() ==
             InstantiationHelper<sizeof...(Ns)>::product(ns...),
         "The iterator is not compatible with the type "
             << debug::demangle(typeid(type).name())
             << InstantiationHelper<sizeof...(Ns)>::to_string(ns...));
+
     auto && wrapped = extract_last<sizeof...(Ns)>::extract(
         [&](auto... n) {
           return InstantiationHelper<sizeof...(n)>::template instantiate<type>(
               data, n...);
         },
         std::make_tuple(ns...));
 
     return iterator{wrapped};
   }
 } // namespace
 
 /* -------------------------------------------------------------------------- */
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns... ns) {
   return get_iterator(*this, values, ns..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns... ns) {
   return get_iterator(*this, values + nb_component * size_, ns..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin(Ns... ns) const {
   return get_iterator(*this, values, ns..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end(Ns... ns) const {
   return get_iterator(*this, values + nb_component * size_, ns..., size_);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns... ns) {
   return get_iterator(*this, values, ns...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns... ns) {
   return get_iterator(
       *this, values + InstantiationHelper<sizeof...(Ns)>::product(ns...),
       ns...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::begin_reinterpret(Ns... ns) const {
   return get_iterator(*this, values, ns...);
 }
 
 template <class T, bool is_scal>
 template <typename... Ns>
 inline decltype(auto) Array<T, is_scal>::end_reinterpret(Ns... ns) const {
   return get_iterator(
       *this, values + InstantiationHelper<sizeof...(Ns)>::product(ns...),
       ns...);
 }
 
 /* -------------------------------------------------------------------------- */
 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;
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_AKA_ARRAY_TMPL_HH__ */
diff --git a/src/common/aka_common.hh b/src/common/aka_common.hh
index ec8bcb9be..d53741946 100644
--- a/src/common/aka_common.hh
+++ b/src/common/aka_common.hh
@@ -1,457 +1,458 @@
 /**
  * @file   aka_common.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jun 14 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  common type descriptions for akantu
  *
  * @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
  *
  * All common things to be included in the projects files
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COMMON_HH__
 #define __AKANTU_COMMON_HH__
 
 /* -------------------------------------------------------------------------- */
 #include <list>
 #include <limits>
 #include <type_traits>
 
 #if __cplusplus < 201402L
 namespace std {
 template< bool B, class T = void >
 using enable_if_t = typename enable_if<B,T>::type;
 }
 #endif
 /* -------------------------------------------------------------------------- */
 #define __BEGIN_AKANTU_DUMPER__ namespace dumper {
 #define __END_AKANTU_DUMPER__ }
 /* -------------------------------------------------------------------------- */
 #if defined(WIN32)
 #define __attribute__(x)
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include "aka_config.hh"
 #include "aka_error.hh"
 #include "aka_safe_enum.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Common types                                                               */
 /* -------------------------------------------------------------------------- */
 using ID = std::string;
 
 #ifdef AKANTU_NDEBUG
 static const Real REAL_INIT_VALUE = Real(0.);
 #else
 static const Real REAL_INIT_VALUE = std::numeric_limits<Real>::quiet_NaN();
 #endif
 
 /* -------------------------------------------------------------------------- */
 /* Memory types                                                               */
 /* -------------------------------------------------------------------------- */
 
 using MemoryID = UInt;
 
 using Surface = std::string;
 typedef std::pair<Surface, Surface> SurfacePair;
 using SurfacePairList = std::list<SurfacePair>;
 
 /* -------------------------------------------------------------------------- */
 extern const UInt _all_dimensions;
 
 /* -------------------------------------------------------------------------- */
 /* Mesh/FEM/Model types                                                       */
 /* -------------------------------------------------------------------------- */
 } // akantu
 
 #include "aka_element_classes_info.hh"
 
 namespace akantu {
 
 /// small help to use names for directions
 enum SpacialDirection { _x = 0, _y = 1, _z = 2 };
 
 /// enum MeshIOType type of mesh reader/writer
 enum MeshIOType {
   _miot_auto,        ///< Auto guess of the reader to use based on the extension
   _miot_gmsh,        ///< Gmsh files
   _miot_gmsh_struct, ///< Gsmh reader with reintpretation of elements has
                      /// structures elements
   _miot_diana,       ///< TNO Diana mesh format
   _miot_abaqus       ///< Abaqus mesh format
 };
 
 /// enum MeshEventHandlerPriority defines relative order of execution of events
 enum EventHandlerPriority {
   _ehp_highest = 0,
   _ehp_mesh = 5,
   _ehp_fe_engine = 9,
   _ehp_synchronizer = 10,
   _ehp_dof_manager = 20,
   _ehp_model = 94,
   _ehp_non_local_manager = 100,
   _ehp_lowest = 100
 };
 
 
 /// enum AnalysisMethod type of solving method used to solve the equation of
 /// motion
 enum AnalysisMethod {
   _static = 0,
   _implicit_dynamic = 1,
   _explicit_lumped_mass = 2,
   _explicit_lumped_capacity = 2,
   _explicit_consistent_mass = 3
 };
 
 /// enum DOFSupportType defines which kind of dof that can exists
 enum DOFSupportType { _dst_nodal, _dst_generic };
 
 /// Type of non linear resolution available in akantu
 enum NonLinearSolverType {
   _nls_linear,                  ///< No non linear convergence loop
   _nls_newton_raphson,          ///< Regular Newton-Raphson
   _nls_newton_raphson_modified, ///< Newton-Raphson with initial tangent
   _nls_lumped,                  ///< Case of lumped mass or equivalent matrix
   _nls_auto                     ///< This will take a default value that make sense in case of
                                 ///  model::getNewSolver
 };
 
 /// Define the node/dof type
 enum NodeType : Int {
   _nt_pure_gost = -3,
   _nt_master = -2,
   _nt_normal = -1
 };
 
 /// Type of time stepping solver
 enum TimeStepSolverType {
   _tsst_static,         ///< Static solution
   _tsst_dynamic,        ///< Dynamic solver
   _tsst_dynamic_lumped, ///< Dynamic solver with lumped mass
+  _tsst_not_defined,    ///< For not defined cases
 };
 
 /// Type of integration scheme
 enum IntegrationSchemeType {
   _ist_pseudo_time,             ///< Pseudo Time
   _ist_forward_euler,           ///< GeneralizedTrapezoidal(0)
   _ist_trapezoidal_rule_1,      ///< GeneralizedTrapezoidal(1/2)
   _ist_backward_euler,          ///< GeneralizedTrapezoidal(1)
   _ist_central_difference,      ///< NewmarkBeta(0, 1/2)
   _ist_fox_goodwin,             ///< NewmarkBeta(1/6, 1/2)
   _ist_trapezoidal_rule_2,      ///< NewmarkBeta(1/2, 1/2)
   _ist_linear_acceleration,     ///< NewmarkBeta(1/3, 1/2)
   _ist_newmark_beta,            ///< generic NewmarkBeta with user defined
                                 /// alpha and beta
   _ist_generalized_trapezoidal  ///< generic GeneralizedTrapezoidal with user
                                 ///  defined alpha
 };
 
 /// enum SolveConvergenceCriteria different convergence criteria
 enum SolveConvergenceCriteria {
   _scc_residual,         ///< Use residual to test the convergence
   _scc_solution,         ///< Use solution to test the convergence
   _scc_residual_mass_wgh ///< Use residual weighted by inv. nodal mass to testb
 };
 
 /// enum CohesiveMethod type of insertion of cohesive elements
 enum CohesiveMethod { _intrinsic, _extrinsic };
 
 /// @enum SparseMatrixType type of sparse matrix used
 enum MatrixType { _unsymmetric, _symmetric, _mt_not_defined };
 
 /* -------------------------------------------------------------------------- */
 /* Ghosts handling                                                            */
 /* -------------------------------------------------------------------------- */
 
 using SynchronizerID = ID;
 
 /// @enum CommunicatorType type of communication method to use
 enum CommunicatorType { _communicator_mpi, _communicator_dummy };
 
 /// @enum SynchronizationTag type of synchronizations
 enum SynchronizationTag {
   //--- Generic tags ---
   _gst_whatever,
   _gst_update,
   _gst_size,
 
   //--- SolidMechanicsModel tags ---
   _gst_smm_mass,      ///< synchronization of the SolidMechanicsModel.mass
   _gst_smm_for_gradu, ///< synchronization of the
                       /// SolidMechanicsModel.displacement
   _gst_smm_boundary,  ///< synchronization of the boundary, forces, velocities
                       /// and displacement
   _gst_smm_uv,  ///< synchronization of the nodal velocities and displacement
   _gst_smm_res, ///< synchronization of the nodal residual
   _gst_smm_init_mat, ///< synchronization of the data to initialize materials
   _gst_smm_stress,  ///< synchronization of the stresses to compute the internal
                     /// forces
   _gst_smmc_facets, ///< synchronization of facet data to setup facet synch
   _gst_smmc_facets_conn,   ///< synchronization of facet global connectivity
   _gst_smmc_facets_stress, ///< synchronization of facets' stress to setup facet
                            /// synch
   _gst_smmc_damage,        ///< synchronization of damage
 
   // --- GlobalIdsUpdater tags ---
   _gst_giu_global_conn, ///< synchronization of global connectivities
 
   // --- CohesiveElementInserter tags ---
   _gst_ce_groups, ///< synchronization of cohesive element insertion depending
                   /// on facet groups
 
   // --- GroupManager tags ---
   _gst_gm_clusters, ///< synchronization of clusters
 
   // --- HeatTransfer tags ---
   _gst_htm_capacity,             ///< synchronization of the nodal heat capacity
   _gst_htm_temperature,          ///< synchronization of the nodal temperature
   _gst_htm_gradient_temperature, ///< synchronization of the element gradient
                                  /// temperature
   // --- LevelSet tags ---
   _gst_htm_phi,          ///< synchronization of the nodal level set value phi
   _gst_htm_gradient_phi, ///< synchronization of the element gradient phi
 
   //--- Material non local ---
   _gst_mnl_for_average, ///< synchronization of data to average in non local
                         /// material
   _gst_mnl_weight,      ///< synchronization of data for the weight computations
 
   // --- NeighborhoodSynchronization tags ---
   _gst_nh_criterion,
 
   // --- General tags ---
   _gst_test,        ///< Test tag
   _gst_user_1,      ///< tag for user simulations
   _gst_user_2,      ///< tag for user simulations
   _gst_material_id, ///< synchronization of the material ids
   _gst_for_dump,    ///< everything that needs to be synch before dump
 
   // --- Contact & Friction ---
   _gst_cf_nodal, ///< synchronization of disp, velo, and current position
   _gst_cf_incr,  ///< synchronization of increment
 
   // --- Solver tags ---
   _gst_solver_solution ///< synchronization of the solution obained with the
                        /// PETSc solver
 };
 
 /// standard output stream operator for SynchronizationTag
 inline std::ostream & operator<<(std::ostream & stream,
                                  SynchronizationTag type);
 
 /// @enum GhostType type of ghost
 enum GhostType {
   _not_ghost,
   _ghost,
   _casper // not used but a real cute ghost
 };
 
 /* -------------------------------------------------------------------------- */
 struct GhostType_def {
   using type = GhostType;
   static const type _begin_ = _not_ghost;
   static const type _end_ = _casper;
 };
 
 using ghost_type_t = safe_enum<GhostType_def>;
 extern ghost_type_t ghost_types;
 
 /// standard output stream operator for GhostType
 inline std::ostream & operator<<(std::ostream & stream, GhostType type);
 
 /// @enum SynchronizerOperation reduce operation that the synchronizer can
 /// perform
 enum SynchronizerOperation {
   _so_sum,
   _so_min,
   _so_max,
   _so_prod,
   _so_land,
   _so_band,
   _so_lor,
   _so_bor,
   _so_lxor,
   _so_bxor,
   _so_min_loc,
   _so_max_loc,
   _so_null
 };
 
 /* -------------------------------------------------------------------------- */
 /* Global defines                                                             */
 /* -------------------------------------------------------------------------- */
 #define AKANTU_MIN_ALLOCATION 2000
 
 #define AKANTU_INDENT " "
 #define AKANTU_INCLUDE_INLINE_IMPL
 
 /* -------------------------------------------------------------------------- */
 template <class T> struct is_scalar {
   enum { value = false };
 };
 
 #define AKANTU_SPECIFY_IS_SCALAR(type)                                         \
   template <> struct is_scalar<type> {                                         \
     enum { value = true };                                                     \
   }
 
 AKANTU_SPECIFY_IS_SCALAR(Real);
 AKANTU_SPECIFY_IS_SCALAR(UInt);
 AKANTU_SPECIFY_IS_SCALAR(Int);
 AKANTU_SPECIFY_IS_SCALAR(bool);
 
 template <typename T1, typename T2> struct is_same {
   enum { value = false }; // is_same represents a bool.
 };
 
 template <typename T> struct is_same<T, T> {
   enum { value = true };
 };
 
 /* -------------------------------------------------------------------------- */
 #define AKANTU_SET_MACRO(name, variable, type)                                 \
   inline void set##name(type variable) { this->variable = variable; }
 
 #define AKANTU_GET_MACRO(name, variable, type)                                 \
   inline type get##name() const { return variable; }
 
 #define AKANTU_GET_MACRO_NOT_CONST(name, variable, type)                       \
   inline type get##name() { return variable; }
 
 #define AKANTU_GET_MACRO_BY_SUPPORT_TYPE(name, variable, type, support, con)   \
   inline con Array<type> & get##name(                                          \
       const support & el_type, const GhostType & ghost_type = _not_ghost)      \
       con {                                                                    \
     return variable(el_type, ghost_type);                                      \
   }
 
 #define AKANTU_GET_MACRO_BY_ELEMENT_TYPE(name, variable, type)                 \
   AKANTU_GET_MACRO_BY_SUPPORT_TYPE(name, variable, type, ElementType, )
 #define AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(name, variable, type)           \
   AKANTU_GET_MACRO_BY_SUPPORT_TYPE(name, variable, type, ElementType, const)
 
 #define AKANTU_GET_MACRO_BY_GEOMETRIE_TYPE(name, variable, type)               \
   AKANTU_GET_MACRO_BY_SUPPORT_TYPE(name, variable, type, GeometricalType, )
 #define AKANTU_GET_MACRO_BY_GEOMETRIE_TYPE_CONST(name, variable, type)         \
   AKANTU_GET_MACRO_BY_SUPPORT_TYPE(name, variable, type, GeometricalType, const)
 
 /* -------------------------------------------------------------------------- */
 /// initialize the static part of akantu
 void initialize(int & argc, char **& argv);
 /// initialize the static part of akantu and read the global input_file
 void initialize(const std::string & input_file, int & argc, char **& argv);
 /* -------------------------------------------------------------------------- */
 /// finilize correctly akantu and clean the memory
 void finalize();
 /* -------------------------------------------------------------------------- */
 /// Read an new input file
 void readInputFile(const std::string & input_file);
 /* -------------------------------------------------------------------------- */
 
 /*
  * For intel compiler annoying remark
  */
 // #if defined(__INTEL_COMPILER)
 // /// remark #981: operands are evaluated in unspecified order
 // #pragma warning(disable : 981)
 // /// remark #383: value copied to temporary, reference to temporary used
 // #pragma warning(disable : 383)
 // #endif // defined(__INTEL_COMPILER)
 
 /* -------------------------------------------------------------------------- */
 /* string manipulation                                                        */
 /* -------------------------------------------------------------------------- */
 inline std::string to_lower(const std::string & str);
 /* -------------------------------------------------------------------------- */
 inline std::string trim(const std::string & to_trim);
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 /// give a string representation of the a human readable size in bit
 template <typename T> std::string printMemorySize(UInt size);
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #include "aka_fwd.hh"
 
 namespace akantu {
 
 /// get access to the internal argument parser
 cppargparse::ArgumentParser & getStaticArgumentParser();
 
 /// get access to the internal input file parser
 Parser & getStaticParser();
 
 /// get access to the user part of the internal input file parser
 const ParserSection & getUserParser();
 
 } // akantu
 
 #include "aka_common_inline_impl.cc"
 
 /* -------------------------------------------------------------------------- */
 
 #if AKANTU_INTEGER_SIZE == 4
 #define AKANTU_HASH_COMBINE_MAGIC_NUMBER 0x9e3779b9
 #elif AKANTU_INTEGER_SIZE == 8
 #define AKANTU_HASH_COMBINE_MAGIC_NUMBER 0x9e3779b97f4a7c13LL
 #endif
 
 namespace std {
 /**
  * Hashing function for pairs based on hash_combine from boost The magic number
  * is coming from the golden number @f[\phi = \frac{1 + \sqrt5}{2}@f]
  * @f[\frac{2^32}{\phi} = 0x9e3779b9@f]
  * http://stackoverflow.com/questions/4948780/magic-number-in-boosthash-combine
  * http://burtleburtle.net/bob/hash/doobs.html
  */
 template <typename a, typename b> struct hash<std::pair<a, b> > {
 public:
   hash() : ah(), bh() {}
   size_t operator()(const std::pair<a, b> & p) const {
     size_t seed = ah(p.first);
     return bh(p.second) + AKANTU_HASH_COMBINE_MAGIC_NUMBER + (seed << 6) +
            (seed >> 2);
   }
 
 private:
   const hash<a> ah;
   const hash<b> bh;
 };
 
 } //std
 
 
 #endif /* __AKANTU_COMMON_HH__ */
diff --git a/src/common/aka_common_inline_impl.cc b/src/common/aka_common_inline_impl.cc
index 820bb02c1..9672a2036 100644
--- a/src/common/aka_common_inline_impl.cc
+++ b/src/common/aka_common_inline_impl.cc
@@ -1,456 +1,459 @@
 /**
  * @file   aka_common_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  inline implementations of common akantu type descriptions
  *
  * @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
  *
  * All common things to be included in the projects files
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <cctype>
 #include <iomanip>
 #include <iostream>
 #include "aka_common.hh"
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_AKA_COMMON_INLINE_IMPL_CC__
 #define __AKANTU_AKA_COMMON_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for GhostType
 inline std::ostream & operator<<(std::ostream & stream, GhostType type) {
   switch (type) {
   case _not_ghost:
     stream << "not_ghost";
     break;
   case _ghost:
     stream << "ghost";
     break;
   case _casper:
     stream << "Casper the friendly ghost";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for TimeStepSolverType
 inline std::ostream & operator<<(std::ostream & stream,
                                  const TimeStepSolverType & type) {
   switch (type) {
   case _tsst_static:
     stream << "static";
     break;
   case _tsst_dynamic:
     stream << "dynamic";
     break;
   case _tsst_dynamic_lumped:
     stream << "dynamic_lumped";
     break;
+  case _tsst_not_defined:
+    stream << "not defined time step solver";
+    break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard input stream operator for TimeStepSolverType
 inline std::istream & operator>>(std::istream & stream,
                                  TimeStepSolverType & type) {
   std::string str;
   stream >> str;
   if (str == "static")
     type = _tsst_static;
   else if (str == "dynamic")
     type = _tsst_dynamic;
   else if (str == "dynamic_lumped")
     type = _tsst_dynamic_lumped;
   else {
     AKANTU_DEBUG_ERROR("The type "
                        << str << " is not a recognized TimeStepSolverType");
 
     stream.setstate(std::ios::failbit);
   }
 
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for NonLinearSolverType
 inline std::ostream & operator<<(std::ostream & stream,
                                  const NonLinearSolverType & type) {
   switch (type) {
   case _nls_linear:
     stream << "linear";
     break;
   case _nls_newton_raphson:
     stream << "newton_raphson";
     break;
   case _nls_newton_raphson_modified:
     stream << "newton_raphson_modified";
     break;
   case _nls_lumped:
     stream << "lumped";
     break;
   case _nls_auto:
     stream << "auto";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard input stream operator for NonLinearSolverType
 inline std::istream & operator>>(std::istream & stream,
                                  NonLinearSolverType & type) {
   std::string str;
   stream >> str;
   if (str == "linear")
     type = _nls_linear;
   else if (str == "newton_raphson")
     type = _nls_newton_raphson;
   else if (str == "newton_raphson_modified")
     type = _nls_newton_raphson_modified;
   else if (str == "lumped")
     type = _nls_lumped;
   else if (str == "auto")
     type = _nls_auto;
   else
     type = _nls_auto;
 
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for IntegrationSchemeType
 inline std::ostream & operator<<(std::ostream & stream,
                                  const IntegrationSchemeType & type) {
   switch (type) {
   case _ist_pseudo_time:
     stream << "pseudo_time";
     break;
   case _ist_forward_euler:
     stream << "forward_euler";
     break;
   case _ist_trapezoidal_rule_1:
     stream << "trapezoidal_rule_1";
     break;
   case _ist_backward_euler:
     stream << "backward_euler";
     break;
   case _ist_central_difference:
     stream << "central_difference";
     break;
   case _ist_fox_goodwin:
     stream << "fox_goodwin";
     break;
   case _ist_trapezoidal_rule_2:
     stream << "trapezoidal_rule_2";
     break;
   case _ist_linear_acceleration:
     stream << "linear_acceleration";
     break;
   case _ist_newmark_beta:
     stream << "newmark_beta";
     break;
   case _ist_generalized_trapezoidal:
     stream << "generalized_trapezoidal";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard input stream operator for IntegrationSchemeType
 inline std::istream & operator>>(std::istream & stream,
                                  IntegrationSchemeType & type) {
   std::string str;
   stream >> str;
 
   if (str == "pseudo_time")
     type = _ist_pseudo_time;
   else if (str == "forward_euler")
     type = _ist_forward_euler;
   else if (str == "trapezoidal_rule_1")
     type = _ist_trapezoidal_rule_1;
   else if (str == "backward_euler")
     type = _ist_backward_euler;
   else if (str == "central_difference")
     type = _ist_central_difference;
   else if (str == "fox_goodwin")
     type = _ist_fox_goodwin;
   else if (str == "trapezoidal_rule_2")
     type = _ist_trapezoidal_rule_2;
   else if (str == "linear_acceleration")
     type = _ist_linear_acceleration;
   else if (str == "newmark_beta")
     type = _ist_newmark_beta;
   else if (str == "generalized_trapezoidal")
     type = _ist_generalized_trapezoidal;
   else {
     AKANTU_DEBUG_ERROR("The type "
                        << str << " is not a recognized IntegrationSchemeType");
     stream.setstate(std::ios::failbit);
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for SynchronizationTag
 inline std::ostream & operator<<(std::ostream & stream,
                                  SynchronizationTag type) {
   switch (type) {
   case _gst_whatever:
     stream << "_gst_whatever";
     break;
   case _gst_update:
     stream << "_gst_update";
     break;
   case _gst_size:
     stream << "_gst_size";
     break;
   case _gst_smm_mass:
     stream << "_gst_smm_mass";
     break;
   case _gst_smm_for_gradu:
     stream << "_gst_smm_for_gradu";
     break;
   case _gst_smm_boundary:
     stream << "_gst_smm_boundary";
     break;
   case _gst_smm_uv:
     stream << "_gst_smm_uv";
     break;
   case _gst_smm_res:
     stream << "_gst_smm_res";
     break;
   case _gst_smm_init_mat:
     stream << "_gst_smm_init_mat";
     break;
   case _gst_smm_stress:
     stream << "_gst_smm_stress";
     break;
   case _gst_smmc_facets:
     stream << "_gst_smmc_facets";
     break;
   case _gst_smmc_facets_conn:
     stream << "_gst_smmc_facets_conn";
     break;
   case _gst_smmc_facets_stress:
     stream << "_gst_smmc_facets_stress";
     break;
   case _gst_smmc_damage:
     stream << "_gst_smmc_damage";
     break;
   case _gst_giu_global_conn:
     stream << "_gst_giu_global_conn";
     break;
   case _gst_ce_groups:
     stream << "_gst_ce_groups";
     break;
   case _gst_gm_clusters:
     stream << "_gst_gm_clusters";
     break;
   case _gst_htm_capacity:
     stream << "_gst_htm_capacity";
     break;
   case _gst_htm_temperature:
     stream << "_gst_htm_temperature";
     break;
   case _gst_htm_gradient_temperature:
     stream << "_gst_htm_gradient_temperature";
     break;
   case _gst_htm_phi:
     stream << "_gst_htm_phi";
     break;
   case _gst_htm_gradient_phi:
     stream << "_gst_htm_gradient_phi";
     break;
   case _gst_mnl_for_average:
     stream << "_gst_mnl_for_average";
     break;
   case _gst_mnl_weight:
     stream << "_gst_mnl_weight";
     break;
   case _gst_nh_criterion:
     stream << "_gst_nh_criterion";
     break;
   case _gst_test:
     stream << "_gst_test";
     break;
   case _gst_user_1:
     stream << "_gst_user_1";
     break;
   case _gst_user_2:
     stream << "_gst_user_2";
     break;
   case _gst_material_id:
     stream << "_gst_material_id";
     break;
   case _gst_for_dump:
     stream << "_gst_for_dump";
     break;
   case _gst_cf_nodal:
     stream << "_gst_cf_nodal";
     break;
   case _gst_cf_incr:
     stream << "_gst_cf_incr";
     break;
   case _gst_solver_solution:
     stream << "_gst_solver_solution";
     break;
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 /// standard output stream operator for SolveConvergenceCriteria
 inline std::ostream & operator<<(std::ostream & stream,
                                  const SolveConvergenceCriteria & criteria) {
   switch (criteria) {
   case _scc_residual:
     stream << "_scc_residual";
     break;
   case _scc_solution:
     stream << "_scc_solution";
     break;
   case _scc_residual_mass_wgh:
     stream << "_scc_residual_mass_wgh";
     break;
   }
   return stream;
 }
 
 inline std::istream & operator>>(std::istream & stream,
                                  SolveConvergenceCriteria & criteria) {
   std::string str;
   stream >> str;
   if (str == "residual")
     criteria = _scc_residual;
   else if (str == "solution")
     criteria = _scc_solution;
   else if (str == "residual_mass_wgh")
     criteria = _scc_residual_mass_wgh;
   else {
     stream.setstate(std::ios::failbit);
   }
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 inline std::string to_lower(const std::string & str) {
   std::string lstr = str;
   std::transform(lstr.begin(), lstr.end(), lstr.begin(), (int (*)(int))tolower);
   return lstr;
 }
 
 /* -------------------------------------------------------------------------- */
 inline std::string trim(const std::string & to_trim) {
   std::string trimed = to_trim;
   // left trim
   trimed.erase(trimed.begin(),
                std::find_if(trimed.begin(), trimed.end(),
                             std::not1(std::ptr_fun<int, int>(isspace))));
   // right trim
   trimed.erase(std::find_if(trimed.rbegin(), trimed.rend(),
                             std::not1(std::ptr_fun<int, int>(isspace)))
                    .base(),
                trimed.end());
   return trimed;
 }
 
 } // akantu
 
 #include <cmath>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T> std::string printMemorySize(UInt size) {
   Real real_size = size * sizeof(T);
 
   UInt mult = 0;
   if (real_size != 0)
     mult = (std::log(real_size) / std::log(2)) / 10;
 
   std::stringstream sstr;
 
   real_size /= Real(1 << (10 * mult));
   sstr << std::setprecision(2) << std::fixed << real_size;
 
   std::string size_prefix;
   switch (mult) {
   case 0:
     sstr << "";
     break;
   case 1:
     sstr << "Ki";
     break;
   case 2:
     sstr << "Mi";
     break;
   case 3:
     sstr << "Gi";
     break; // I started on this type of machines
            // (32bit computers) (Nicolas)
   case 4:
     sstr << "Ti";
     break;
   case 5:
     sstr << "Pi";
     break;
   case 6:
     sstr << "Ei";
     break; // theoritical limit of RAM of the current
            // computers in 2014 (64bit computers) (Nicolas)
   case 7:
     sstr << "Zi";
     break;
   case 8:
     sstr << "Yi";
     break;
   default:
     AKANTU_DEBUG_ERROR(
         "The programmer in 2014 didn't thought so far (even wikipedia does not "
         "go further)."
         << " You have at least 1024 times more than a yobibit of RAM!!!"
         << " Just add the prefix corresponding in this switch case.");
   }
 
   sstr << "Byte";
 
   return sstr.str();
 }
 
 } // akantu
 
 #endif /* __AKANTU_AKA_COMMON_INLINE_IMPL_CC__ */
diff --git a/src/fe_engine/cohesive_element.cc b/src/fe_engine/cohesive_element.cc
index 580aad513..97c4df49c 100644
--- a/src/fe_engine/cohesive_element.cc
+++ b/src/fe_engine/cohesive_element.cc
@@ -1,150 +1,151 @@
 /**
  * @file   cohesive_element.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Sun Sep 26 2010
  * @date last modification: Mon Sep 14 2015
  *
  * @brief  CohesiveElement implementation
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
-#include "cohesive_element.hh"
+#include "element_class.hh"
+/* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template<> UInt GeometricalElement<_gt_cohesive_2d_4>::spatial_dimension    = 2;
 template<> UInt GeometricalElement<_gt_cohesive_2d_4>::nb_nodes_per_element = 4;
 template<> UInt GeometricalElement<_gt_cohesive_2d_4>::nb_facet_types       = 1;
 template<> UInt GeometricalElement<_gt_cohesive_2d_4>::nb_facets[]          = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_2d_4>::nb_nodes_per_facet[] = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_2d_4>::facet_connectivity_vect[] = {0, 2,
                                                                                     1, 3};
 template<> UInt * GeometricalElement<_gt_cohesive_2d_4>::facet_connectivity[] = { &facet_connectivity_vect[0] };
 
 template<> ElementType ElementClass<_cohesive_2d_4>::facet_type[] = { _segment_2 };
 template<> ElementType ElementClass<_cohesive_2d_4>::p1_type      = _cohesive_2d_4;
 
 /* -------------------------------------------------------------------------- */
 template<> UInt GeometricalElement<_gt_cohesive_2d_6>::spatial_dimension    = 2;
 template<> UInt GeometricalElement<_gt_cohesive_2d_6>::nb_nodes_per_element = 6;
 template<> UInt GeometricalElement<_gt_cohesive_2d_6>::nb_facet_types       = 1;
 template<> UInt GeometricalElement<_gt_cohesive_2d_6>::nb_facets[]          = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_2d_6>::nb_nodes_per_facet[] = { 3 };
 template<> UInt GeometricalElement<_gt_cohesive_2d_6>::facet_connectivity_vect[] = {0, 3,
                                                                                     1, 4,
                                                                                     2, 5};
 template<> UInt * GeometricalElement<_gt_cohesive_2d_6>::facet_connectivity[] = { &facet_connectivity_vect[0] };
 
 template<> ElementType ElementClass<_cohesive_2d_6>::facet_type[] = { _segment_3 };
 template<> ElementType ElementClass<_cohesive_2d_6>::p1_type      = _cohesive_2d_4;
 
 /* -------------------------------------------------------------------------- */
 template<> UInt GeometricalElement<_gt_cohesive_1d_2>::spatial_dimension    = 1;
 template<> UInt GeometricalElement<_gt_cohesive_1d_2>::nb_nodes_per_element = 2;
 template<> UInt GeometricalElement<_gt_cohesive_1d_2>::nb_facet_types       = 1;
 template<> UInt GeometricalElement<_gt_cohesive_1d_2>::nb_facets[]          = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_1d_2>::nb_nodes_per_facet[] = { 1 };
 template<> UInt GeometricalElement<_gt_cohesive_1d_2>::facet_connectivity_vect[] = {0,
                                                                                     1};
 template<> UInt * GeometricalElement<_gt_cohesive_1d_2>::facet_connectivity[] = { &facet_connectivity_vect[0] };
 
 template<> ElementType ElementClass<_cohesive_1d_2>::facet_type[] = { _point_1 };
 template<> ElementType ElementClass<_cohesive_1d_2>::p1_type      = _cohesive_1d_2;
 /* -------------------------------------------------------------------------- */
 
 template<> UInt GeometricalElement<_gt_cohesive_3d_6>::spatial_dimension    = 3;
 template<> UInt GeometricalElement<_gt_cohesive_3d_6>::nb_nodes_per_element = 6;
 template<> UInt GeometricalElement<_gt_cohesive_3d_6>::nb_facet_types       = 1;
 template<> UInt GeometricalElement<_gt_cohesive_3d_6>::nb_facets[]          = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_6>::nb_nodes_per_facet[] = { 3 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_6>::facet_connectivity_vect[] = {0, 3,
                                                                                     1, 4,
                                                                                     2, 5};
 template<> UInt * GeometricalElement<_gt_cohesive_3d_6>::facet_connectivity[] = { &facet_connectivity_vect[0] };
 
 template<> ElementType ElementClass<_cohesive_3d_6>::facet_type[] = { _triangle_3 };
 template<> ElementType ElementClass<_cohesive_3d_6>::p1_type      = _cohesive_3d_6;
 
 /* -------------------------------------------------------------------------- */
 
 template<> UInt GeometricalElement<_gt_cohesive_3d_12>::spatial_dimension    = 3;
 template<> UInt GeometricalElement<_gt_cohesive_3d_12>::nb_nodes_per_element = 12;
 template<> UInt GeometricalElement<_gt_cohesive_3d_12>::nb_facet_types       = 1;
 template<> UInt GeometricalElement<_gt_cohesive_3d_12>::nb_facets[]          = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_12>::nb_nodes_per_facet[] = { 6 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_12>::facet_connectivity_vect[] = {0, 6,
                                                                                      1, 7,
                                                                                      2, 8,
                                                                                      3, 9,
                                                                                      4, 10,
                                                                                      5, 11};
 template<> UInt * GeometricalElement<_gt_cohesive_3d_12>::facet_connectivity[] = { &facet_connectivity_vect[0] };
 
 template<> ElementType ElementClass<_cohesive_3d_12>::facet_type[] = { _triangle_6 };
 template<> ElementType ElementClass<_cohesive_3d_12>::p1_type      = _cohesive_3d_6;
 
 /* -------------------------------------------------------------------------- */
 
 template<> UInt GeometricalElement<_gt_cohesive_3d_8>::spatial_dimension    = 3;
 template<> UInt GeometricalElement<_gt_cohesive_3d_8>::nb_nodes_per_element = 8;
 template<> UInt GeometricalElement<_gt_cohesive_3d_8>::nb_facet_types       = 1;
 template<> UInt GeometricalElement<_gt_cohesive_3d_8>::nb_facets[]          = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_8>::nb_nodes_per_facet[] = { 4 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_8>::facet_connectivity_vect[] = {0, 4,
                                                                                     1, 5,
                                                                                     2, 6,
                                                                                     3, 7};
 template<> UInt * GeometricalElement<_gt_cohesive_3d_8>::facet_connectivity[] = { &facet_connectivity_vect[0] };
 
 template<> ElementType ElementClass<_cohesive_3d_8>::facet_type[] = { _quadrangle_4 };
 template<> ElementType ElementClass<_cohesive_3d_8>::p1_type      = _cohesive_3d_8;
 
 /* -------------------------------------------------------------------------- */
 
 template<> UInt GeometricalElement<_gt_cohesive_3d_16>::spatial_dimension    = 3;
 template<> UInt GeometricalElement<_gt_cohesive_3d_16>::nb_nodes_per_element = 16;
 template<> UInt GeometricalElement<_gt_cohesive_3d_16>::nb_facet_types       = 1;
 template<> UInt GeometricalElement<_gt_cohesive_3d_16>::nb_facets[]          = { 2 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_16>::nb_nodes_per_facet[] = { 8 };
 template<> UInt GeometricalElement<_gt_cohesive_3d_16>::facet_connectivity_vect[] = {0, 8,
                                                                                      1, 9,
                                                                                      2, 10,
                                                                                      3, 11,
                                                                                      4, 12,
                                                                                      5, 13,
                                                                                      6, 14,
                                                                                      7, 15};
 template<> UInt * GeometricalElement<_gt_cohesive_3d_16>::facet_connectivity[] = { &facet_connectivity_vect[0] };
 
 template<> ElementType ElementClass<_cohesive_3d_16>::facet_type[] = { _quadrangle_8 };
 template<> ElementType ElementClass<_cohesive_3d_16>::p1_type      = _cohesive_3d_8;
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/fe_engine/cohesive_element.hh b/src/fe_engine/cohesive_element.hh
index 968604ffd..e6ab33817 100644
--- a/src/fe_engine/cohesive_element.hh
+++ b/src/fe_engine/cohesive_element.hh
@@ -1,91 +1,91 @@
 /**
  * @file   cohesive_element.hh
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  Generates the cohesive element structres (defined in
  * element_class.hh)
  *
  * @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_class.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COHESIVE_ELEMENT_HH__
 #define __AKANTU_COHESIVE_ELEMENT_HH__
 
 namespace akantu {
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_cohesive_2d_4, _gt_cohesive_2d_4,
                                      _itp_lagrange_segment_2, _ek_cohesive, 2,
                                      _git_segment, 2);
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_cohesive_2d_6, _gt_cohesive_2d_6,
                                      _itp_lagrange_segment_3, _ek_cohesive, 2,
                                      _git_segment, 3);
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_cohesive_1d_2, _gt_cohesive_1d_2,
                                      _itp_lagrange_point_1, _ek_cohesive, 1,
                                      _git_point, 1);
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_cohesive_3d_6, _gt_cohesive_3d_6,
                                      _itp_lagrange_triangle_3, _ek_cohesive, 3,
                                      _git_triangle, 2);
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_cohesive_3d_12, _gt_cohesive_3d_12,
                                      _itp_lagrange_triangle_6, _ek_cohesive, 3,
                                      _git_triangle, 3);
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_cohesive_3d_8, _gt_cohesive_3d_8,
                                      _itp_lagrange_quadrangle_4, _ek_cohesive,
                                      3, _git_segment, 2);
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_cohesive_3d_16, _gt_cohesive_3d_16,
                                      _itp_serendip_quadrangle_8, _ek_cohesive,
                                      3, _git_segment, 3);
 
 template <ElementType> struct CohesiveFacetProperty {
   static const ElementType cohesive_type = _not_defined;
 };
 
 #define AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(ftype, ctype)                    \
   template <> struct CohesiveFacetProperty<ftype> {                            \
     static const ElementType cohesive_type = ctype;                            \
   }
 
 AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(_point_1, _cohesive_1d_2);
 AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(_segment_2, _cohesive_2d_4);
 AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(_segment_3, _cohesive_2d_6);
 AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(_triangle_3, _cohesive_3d_6);
 AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(_triangle_6, _cohesive_3d_12);
 AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(_quadrangle_4, _cohesive_3d_8);
 AKANTU_DEFINE_COHESIVE_FACET_PROPERTY(_quadrangle_8, _cohesive_3d_16);
 
-} // akantu
+} // namespace akantu
 
 #endif /* __AKANTU_COHESIVE_ELEMENT_HH__ */
diff --git a/src/fe_engine/element_class.hh b/src/fe_engine/element_class.hh
index 5eda6c5ca..188115a3d 100644
--- a/src/fe_engine/element_class.hh
+++ b/src/fe_engine/element_class.hh
@@ -1,399 +1,410 @@
 /**
  * @file   element_class.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jan 21 2016
  *
  * @brief  Declaration of the ElementClass main class and the
  * Integration and Interpolation elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_types.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_CLASS_HH__
 #define __AKANTU_ELEMENT_CLASS_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /// default element class structure
 template <ElementType element_type> struct ElementClassProperty {
-  static const GeometricalType geometrical_type = _gt_not_defined;
-  static const InterpolationType interpolation_type = _itp_not_defined;
-  static const ElementKind element_kind = _ek_regular;
-  static const UInt spatial_dimension = 0;
-  static const GaussIntegrationType gauss_integration_type = _git_not_defined;
-  static const UInt polynomial_degree = 0;
+  static const GeometricalType geometrical_type{_gt_not_defined};
+  static const InterpolationType interpolation_type{_itp_not_defined};
+  static const ElementKind element_kind{_ek_regular};
+  static const UInt spatial_dimension{0};
+  static const GaussIntegrationType gauss_integration_type{_git_not_defined};
+  static const UInt polynomial_degree{0};
 };
 
 /// Macro to generate the element class structures for different element types
 #define AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(elem_type, geom_type,             \
                                              interp_type, elem_kind, sp,       \
                                              gauss_int_type, min_int_order)    \
   template <> struct ElementClassProperty<elem_type> {                         \
-    static const GeometricalType geometrical_type = geom_type;                 \
-    static const InterpolationType interpolation_type = interp_type;           \
-    static const ElementKind element_kind = elem_kind;                         \
-    static const UInt spatial_dimension = sp;                                  \
-    static const GaussIntegrationType gauss_integration_type =                \
-        gauss_int_type;                                                        \
-    static const UInt polynomial_degree = min_int_order;                       \
+    static const GeometricalType geometrical_type{geom_type};                  \
+    static const InterpolationType interpolation_type{interp_type};            \
+    static const ElementKind element_kind{elem_kind};                          \
+    static const UInt spatial_dimension{sp};                                   \
+    static const GaussIntegrationType gauss_integration_type{gauss_int_type};  \
+    static const UInt polynomial_degree{min_int_order};                        \
   }
 
 /* -------------------------------------------------------------------------- */
 /* Geometry                                                                   */
 /* -------------------------------------------------------------------------- */
 /// Default GeometricalShape structure
 template <GeometricalType geometrical_type> struct GeometricalShape {
-  static const GeometricalShapeType shape = _gst_point;
+  static const GeometricalShapeType shape{_gst_point};
 };
 
 /// Templated GeometricalShape with function contains
 template <GeometricalShapeType shape> struct GeometricalShapeContains {
   /// Check if the point (vector in 2 and 3D) at natural coordinate coor
   template <class vector_type>
   static inline bool contains(const vector_type & coord);
 };
 
 /// Macro to generate the GeometricalShape structures for different geometrical
 /// types
 #define AKANTU_DEFINE_SHAPE(geom_type, geom_shape)                             \
   template <> struct GeometricalShape<geom_type> {                             \
-    static const GeometricalShapeType shape = geom_shape;                      \
+    static const GeometricalShapeType shape{geom_shape};                      \
   }
 
+AKANTU_DEFINE_SHAPE(_gt_hexahedron_20, _gst_square);
+AKANTU_DEFINE_SHAPE(_gt_hexahedron_8, _gst_square);
+AKANTU_DEFINE_SHAPE(_gt_pentahedron_15, _gst_prism);
+AKANTU_DEFINE_SHAPE(_gt_pentahedron_6, _gst_prism);
+AKANTU_DEFINE_SHAPE(_gt_point, _gst_point);
+AKANTU_DEFINE_SHAPE(_gt_quadrangle_4, _gst_square);
+AKANTU_DEFINE_SHAPE(_gt_quadrangle_8, _gst_square);
+AKANTU_DEFINE_SHAPE(_gt_segment_2, _gst_square);
+AKANTU_DEFINE_SHAPE(_gt_segment_3, _gst_square);
+AKANTU_DEFINE_SHAPE(_gt_tetrahedron_10, _gst_triangle);
+AKANTU_DEFINE_SHAPE(_gt_tetrahedron_4, _gst_triangle);
+AKANTU_DEFINE_SHAPE(_gt_triangle_3, _gst_triangle);
+AKANTU_DEFINE_SHAPE(_gt_triangle_6, _gst_triangle);
+
 /* -------------------------------------------------------------------------- */
 /// Templated GeometricalElement with function getInradius
 template <GeometricalType geometrical_type,
           GeometricalShapeType shape =
               GeometricalShape<geometrical_type>::shape>
 class GeometricalElement {
 public:
   /// compute the in-radius
   static inline Real getInradius(__attribute__((unused))
                                  const Matrix<Real> & coord) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// true if the natural coordinates are in the element
   template <class vector_type>
   static inline bool contains(const vector_type & coord);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(SpatialDimension, spatial_dimension, UInt);
-  static AKANTU_GET_MACRO_NOT_CONST(NbNodesPerElement, nb_nodes_per_element, UInt);
+  static AKANTU_GET_MACRO_NOT_CONST(NbNodesPerElement, nb_nodes_per_element,
+                                    UInt);
   static AKANTU_GET_MACRO_NOT_CONST(NbFacetTypes, nb_facet_types, UInt);
   static inline UInt getNbFacetsPerElement(UInt t);
   static inline UInt getNbFacetsPerElement();
   static inline const MatrixProxy<UInt>
   getFacetLocalConnectivityPerElement(UInt t = 0);
 
 protected:
   /// Number of nodes per element
   static UInt nb_nodes_per_element;
   /// spatial dimension of the element
   static UInt spatial_dimension;
   /// number of different facet types
   static UInt nb_facet_types;
   /// number of facets for element
   static UInt nb_facets[];
   /// storage of the facet local connectivity
   static UInt facet_connectivity_vect[];
   /// local connectivity of facets
   static UInt * facet_connectivity[];
 
 private:
   /// Type of the facet elements
   static UInt nb_nodes_per_facet[];
 };
 
 /* -------------------------------------------------------------------------- */
 /* Interpolation                                                              */
 /* -------------------------------------------------------------------------- */
-/// default InterpolationPorperty structure
-template <InterpolationType interpolation_type> struct InterpolationPorperty {
-  static const InterpolationKind kind = _itk_not_defined;
-  static const UInt nb_nodes_per_element = 0;
-  static const UInt natural_space_dimension = 0;
+/// default InterpolationProperty structure
+template <InterpolationType interpolation_type> struct InterpolationProperty {
+  static const InterpolationKind kind{_itk_not_defined};
+  static const UInt nb_nodes_per_element{0};
+  static const UInt natural_space_dimension{0};
 };
 
-/// Macro to generate the InterpolationPorperty structures for different
+/// Macro to generate the InterpolationProperty structures for different
 /// interpolation types
 #define AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(itp_type, itp_kind,          \
                                                   nb_nodes, ndim)              \
-  template <> struct InterpolationPorperty<itp_type> {                         \
-    static const InterpolationKind kind = itp_kind;                            \
-    static const UInt nb_nodes_per_element = nb_nodes;                         \
-    static const UInt natural_space_dimension = ndim;                          \
+  template <> struct InterpolationProperty<itp_type> {                         \
+    static const InterpolationKind kind{itp_kind};                             \
+    static const UInt nb_nodes_per_element{nb_nodes};                          \
+    static const UInt natural_space_dimension{ndim};                           \
   }
 
-#include "interpolation_element_tmpl.hh"
-
 /* -------------------------------------------------------------------------- */
 /// Generic (templated by the enum InterpolationType which specifies the order
 /// and the dimension of the interpolation) class handling the elemental
 /// interpolation
 template <InterpolationType interpolation_type,
           InterpolationKind kind =
-              InterpolationPorperty<interpolation_type>::kind>
+              InterpolationProperty<interpolation_type>::kind>
 class InterpolationElement {
 public:
-  typedef InterpolationPorperty<interpolation_type> interpolation_property;
+  typedef InterpolationProperty<interpolation_type> interpolation_property;
 
   /// compute the shape values for a given set of points in natural coordinates
   static inline void computeShapes(const Matrix<Real> & natural_coord,
                                    Matrix<Real> & N);
 
   /// compute the shape values for a given point in natural coordinates
   template <class vector_type>
-  static inline void computeShapes(__attribute__((unused))
-                                   const vector_type & natural_coord,
-                                   __attribute__((unused)) vector_type & N) {
+  static inline void computeShapes(const vector_type &, vector_type &) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with variation of natural coordinates on a given set
    * of points in natural coordinates
    */
   static inline void computeDNDS(const Matrix<Real> & natural_coord,
                                  Tensor3<Real> & dnds);
   /**
    * compute @f$ B_{ij} = \frac{\partial N_j}{\partial S_i} @f$ the variation of
    * shape functions along with
    * variation of natural coordinates on a given point in natural
    * coordinates
    */
   template <class vector_type, class matrix_type>
-  static inline void computeDNDS(__attribute__((unused))
-                                 const vector_type & natural_coord,
-                                 __attribute__((unused)) matrix_type & dnds) {
+  static inline void computeDNDS(const vector_type &, matrix_type &) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// compute jacobian (or integration variable change factor) for a given point
   /// in the case of spatial_dimension != natural_space_dimension
-  static inline void computeSpecialJacobian(__attribute__((unused))
-                                            const Matrix<Real> & J,
-                                            __attribute__((unused))
-                                            Real & jacobians) {
+  static inline void computeSpecialJacobian(const Matrix<Real> &, Real &) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// interpolate a field given (arbitrary) natural coordinates
   static inline void
   interpolateOnNaturalCoordinates(const Vector<Real> & natural_coords,
                                   const Matrix<Real> & nodal_values,
                                   Vector<Real> & interpolated);
 
   /// interpolate a field given the shape functions on the interpolation point
   static inline void interpolate(const Matrix<Real> & nodal_values,
                                  const Vector<Real> & shapes,
                                  Vector<Real> & interpolated);
 
   /// interpolate a field given the shape functions on the interpolations points
   static inline void interpolate(const Matrix<Real> & nodal_values,
                                  const Matrix<Real> & shapes,
                                  Matrix<Real> & interpolated);
 
   /// compute the gradient of a given field on the given natural coordinates
   static inline void
   gradientOnNaturalCoordinates(const Vector<Real> & natural_coords,
                                const Matrix<Real> & f, Matrix<Real> & gradient);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeSize,
-      InterpolationPorperty<interpolation_type>::nb_nodes_per_element, UInt);
+      InterpolationProperty<interpolation_type>::nb_nodes_per_element, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       ShapeDerivativesSize,
-      (InterpolationPorperty<interpolation_type>::nb_nodes_per_element *
-       InterpolationPorperty<interpolation_type>::natural_space_dimension),
+      (InterpolationProperty<interpolation_type>::nb_nodes_per_element *
+       InterpolationProperty<interpolation_type>::natural_space_dimension),
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NaturalSpaceDimension,
-      InterpolationPorperty<interpolation_type>::natural_space_dimension, UInt);
+      InterpolationProperty<interpolation_type>::natural_space_dimension, UInt);
   static AKANTU_GET_MACRO_NOT_CONST(
       NbNodesPerInterpolationElement,
-      InterpolationPorperty<interpolation_type>::nb_nodes_per_element, UInt);
+      InterpolationProperty<interpolation_type>::nb_nodes_per_element, UInt);
 };
 
 /* -------------------------------------------------------------------------- */
 /* Integration                                                                */
 /* -------------------------------------------------------------------------- */
 template <GaussIntegrationType git_class, UInt nb_points>
 struct GaussIntegrationTypeData {
   /// quadrature points in natural coordinates
   static Real quad_positions[];
   /// weights for the Gauss integration
   static Real quad_weights[];
 };
 
 template <ElementType type,
           UInt n = ElementClassProperty<type>::polynomial_degree>
 class GaussIntegrationElement {
 public:
   static UInt getNbQuadraturePoints();
   static const Matrix<Real> getQuadraturePoints();
   static const Vector<Real> getWeights();
 };
 
 /* -------------------------------------------------------------------------- */
 /* ElementClass                                                               */
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type,
           ElementKind element_kind =
               ElementClassProperty<element_type>::element_kind>
 class ElementClass
     : public GeometricalElement<
           ElementClassProperty<element_type>::geometrical_type>,
       public InterpolationElement<
           ElementClassProperty<element_type>::interpolation_type> {
 protected:
   typedef GeometricalElement<
-      ElementClassProperty<element_type>::geometrical_type> geometrical_element;
-  typedef InterpolationElement<ElementClassProperty<
-      element_type>::interpolation_type> interpolation_element;
+      ElementClassProperty<element_type>::geometrical_type>
+      geometrical_element;
+  typedef InterpolationElement<
+      ElementClassProperty<element_type>::interpolation_type>
+      interpolation_element;
 
   typedef ElementClassProperty<element_type> element_property;
   typedef typename interpolation_element::interpolation_property
       interpolation_property;
 
 public:
   /**
    * compute @f$ J = \frac{\partial x_j}{\partial s_i} @f$ the variation of real
    * coordinates along with variation of natural coordinates on a given point in
    * natural coordinates
    */
   static inline void computeJMat(const Matrix<Real> & dnds,
                                  const Matrix<Real> & node_coords,
                                  Matrix<Real> & J);
 
   /**
    * compute the Jacobian matrix by computing the variation of real coordinates
    * along with variation of natural coordinates on a given set of points in
    * natural coordinates
    */
   static inline void computeJMat(const Tensor3<Real> & dnds,
                                  const Matrix<Real> & node_coords,
                                  Tensor3<Real> & J);
 
   /// compute the jacobians of a serie of natural coordinates
   static inline void computeJacobian(const Matrix<Real> & natural_coords,
                                      const Matrix<Real> & node_coords,
                                      Vector<Real> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a set of
   /// points
   static inline void computeJacobian(const Tensor3<Real> & J,
                                      Vector<Real> & jacobians);
 
   /// compute jacobian (or integration variable change factor) for a given point
   static inline void computeJacobian(const Matrix<Real> & J, Real & jacobians);
 
   /// compute shape derivatives (input is dxds) for a set of points
   static inline void computeShapeDerivatives(const Tensor3<Real> & J,
                                              const Tensor3<Real> & dnds,
                                              Tensor3<Real> & shape_deriv);
 
   /// compute shape derivatives (input is dxds) for a given point
   static inline void computeShapeDerivatives(const Matrix<Real> & J,
                                              const Matrix<Real> & dnds,
                                              Matrix<Real> & shape_deriv);
 
   /// compute the normal of a surface defined by the function f
   static inline void
   computeNormalsOnNaturalCoordinates(const Matrix<Real> & coord,
                                      Matrix<Real> & f, Matrix<Real> & normals);
 
   /// get natural coordinates from real coordinates
   static inline void inverseMap(const Vector<Real> & real_coords,
                                 const Matrix<Real> & node_coords,
                                 Vector<Real> & natural_coords,
                                 Real tolerance = 1e-10);
 
   /// get natural coordinates from real coordinates
   static inline void inverseMap(const Matrix<Real> & real_coords,
                                 const Matrix<Real> & node_coords,
                                 Matrix<Real> & natural_coords,
                                 Real tolerance = 1e-10);
 
 public:
   static AKANTU_GET_MACRO_NOT_CONST(Kind, element_kind, ElementKind);
   static AKANTU_GET_MACRO_NOT_CONST(
       SpatialDimension, ElementClassProperty<element_type>::spatial_dimension,
       UInt);
   static AKANTU_GET_MACRO_NOT_CONST(P1ElementType, p1_type,
                                     const ElementType &);
   static const ElementType & getFacetType(UInt t = 0) { return facet_type[t]; }
   static ElementType * getFacetTypeInternal() { return facet_type; }
 
 protected:
   /// Type of the facet elements
   static ElementType facet_type[];
   /// type of element P1 associated
   static ElementType p1_type;
 };
 
 /* -------------------------------------------------------------------------- */
-} // akantu
+} // namespace akantu
 
+/* -------------------------------------------------------------------------- */
+#include "interpolation_element_tmpl.hh"
+/* -------------------------------------------------------------------------- */
 #include "element_class_tmpl.hh"
 /* -------------------------------------------------------------------------- */
 namespace akantu {
+#include "element_class_pentahedron_6_inline_impl.cc"
+/* keep order */
+#include "element_class_hexahedron_20_inline_impl.cc"
+#include "element_class_hexahedron_8_inline_impl.cc"
+#include "element_class_pentahedron_15_inline_impl.cc"
 #include "element_class_point_1_inline_impl.cc"
+#include "element_class_quadrangle_4_inline_impl.cc"
+#include "element_class_quadrangle_8_inline_impl.cc"
 #include "element_class_segment_2_inline_impl.cc"
 #include "element_class_segment_3_inline_impl.cc"
+#include "element_class_tetrahedron_10_inline_impl.cc"
+#include "element_class_tetrahedron_4_inline_impl.cc"
 #include "element_class_triangle_3_inline_impl.cc"
 #include "element_class_triangle_6_inline_impl.cc"
-#include "element_class_tetrahedron_4_inline_impl.cc"
-#include "element_class_tetrahedron_10_inline_impl.cc"
-#include "element_class_quadrangle_4_inline_impl.cc"
-#include "element_class_quadrangle_8_inline_impl.cc"
-#include "element_class_hexahedron_8_inline_impl.cc"
-#include "element_class_hexahedron_20_inline_impl.cc"
-#include "element_class_pentahedron_6_inline_impl.cc"
-#include "element_class_pentahedron_15_inline_impl.cc"
-} // akantu
+} // namespace akantu
 
 /* -------------------------------------------------------------------------- */
-#if defined(AKANTU_COHESIVE_ELEMENT)
-#include "cohesive_element.hh"
-#endif
-
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 #include "element_class_structural.hh"
 #endif
 
+#if defined(AKANTU_COHESIVE_ELEMENT)
+#include "cohesive_element.hh"
+#endif
+
 #if defined(AKANTU_IGFEM)
 #include "element_class_igfem.hh"
 #endif
 
 #endif /* __AKANTU_ELEMENT_CLASS_HH__ */
diff --git a/src/fe_engine/element_class_tmpl.hh b/src/fe_engine/element_class_tmpl.hh
index 51e25a110..5758b5f82 100644
--- a/src/fe_engine/element_class_tmpl.hh
+++ b/src/fe_engine/element_class_tmpl.hh
@@ -1,513 +1,514 @@
 /**
  * @file   element_class_tmpl.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Thomas Menouillard <tmenouillard@stucky.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Thu Oct 22 2015
  *
  * @brief  Implementation of the inline templated function of the element class
  * descriptions
  *
  * @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 "gauss_integration_tmpl.hh"
 #include "element_class.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
+
 #ifndef __AKANTU_ELEMENT_CLASS_TMPL_HH__
 #define __AKANTU_ELEMENT_CLASS_TMPL_HH__
 
 namespace akantu {
 /* -------------------------------------------------------------------------- */
 /* GeometricalElement                                                         */
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline const MatrixProxy<UInt>
 GeometricalElement<geometrical_type,
                    shape>::getFacetLocalConnectivityPerElement(UInt t) {
   return MatrixProxy<UInt>(facet_connectivity[t], nb_facets[t],
                            nb_nodes_per_facet[t]);
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline UInt
 GeometricalElement<geometrical_type, shape>::getNbFacetsPerElement() {
   UInt total_nb_facets = 0;
   for (UInt n = 0; n < nb_facet_types; ++n) {
     total_nb_facets += nb_facets[n];
   }
 
   return total_nb_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 inline UInt
 GeometricalElement<geometrical_type, shape>::getNbFacetsPerElement(UInt t) {
   return nb_facets[t];
 }
 
 /* -------------------------------------------------------------------------- */
 template <GeometricalType geometrical_type, GeometricalShapeType shape>
 template <class vector_type>
 inline bool GeometricalElement<geometrical_type, shape>::contains(
     const vector_type & coords) {
   return GeometricalShapeContains<shape>::contains(coords);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_point>::contains(const vector_type & coords) {
   return (coords(0) < std::numeric_limits<Real>::epsilon());
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_square>::contains(const vector_type & coords) {
   bool in = true;
   for (UInt i = 0; i < coords.size() && in; ++i)
     in &= ((coords(i) >= -(1. + std::numeric_limits<Real>::epsilon())) &&
            (coords(i) <= (1. + std::numeric_limits<Real>::epsilon())));
   return in;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_triangle>::contains(const vector_type & coords) {
   bool in = true;
   Real sum = 0;
   for (UInt i = 0; (i < coords.size()) && in; ++i) {
     in &= ((coords(i) >= -(Math::getTolerance())) &&
            (coords(i) <= (1. + Math::getTolerance())));
     sum += coords(i);
   }
   if (in)
     return (in && (sum <= (1. + Math::getTolerance())));
   return in;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline bool
 GeometricalShapeContains<_gst_prism>::contains(const vector_type & coords) {
   bool in = ((coords(0) >= -1.) && (coords(0) <= 1.)); // x in segment [-1, 1]
 
   // y and z in triangle
   in &= ((coords(1) >= 0) && (coords(1) <= 1.));
   in &= ((coords(2) >= 0) && (coords(2) <= 1.));
   Real sum = coords(1) + coords(2);
 
   return (in && (sum <= 1));
 }
 
 /* -------------------------------------------------------------------------- */
 /* InterpolationElement                                                       */
 /* -------------------------------------------------------------------------- */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::computeShapes(
     const Matrix<Real> & natural_coord, Matrix<Real> & N) {
   UInt nb_points = natural_coord.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> Np(N(p));
     Vector<Real> ncoord_p(natural_coord(p));
     computeShapes(ncoord_p, Np);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::computeDNDS(
     const Matrix<Real> & natural_coord, Tensor3<Real> & dnds) {
   UInt nb_points = natural_coord.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Matrix<Real> dnds_p(dnds(p));
     Vector<Real> ncoord_p(natural_coord(p));
     computeDNDS(ncoord_p, dnds_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate on a point a field for which values are given on the
  * node of the element using the shape functions at this interpolation point
  *
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param shapes value of shape functions at the interpolation point
  * @param interpolated interpolated value of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::interpolate(
     const Matrix<Real> & nodal_values, const Vector<Real> & shapes,
     Vector<Real> & interpolated) {
   Matrix<Real> interpm(interpolated.storage(), nodal_values.rows(), 1);
   Matrix<Real> shapesm(
       shapes.storage(),
-      InterpolationPorperty<interpolation_type>::nb_nodes_per_element, 1);
+      InterpolationProperty<interpolation_type>::nb_nodes_per_element, 1);
   interpm.mul<false, false>(nodal_values, shapesm);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate on several points a field  for which values are given on the
  * node of the element using the shape functions at the interpolation point
  *
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param shapes value of shape functions at the interpolation point
  * @param interpolated interpolated values of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void InterpolationElement<interpolation_type, kind>::interpolate(
     const Matrix<Real> & nodal_values, const Matrix<Real> & shapes,
     Matrix<Real> & interpolated) {
   UInt nb_points = shapes.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> Np(shapes(p));
     Vector<Real> interpolated_p(interpolated(p));
     interpolate(nodal_values, Np, interpolated_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * interpolate the field on a point given in natural coordinates the field which
  * values are given on the node of the element
  *
  * @param natural_coords natural coordinates of point where to interpolate \xi
  * @param nodal_values values of the function per node @f$ f_{ij} = f_{n_i j}
  *@f$ so it should be a matrix of size nb_nodes_per_element @f$\times@f$
  *nb_degree_of_freedom
  * @param interpolated interpolated value of f @f$ f_j(\xi) = \sum_i f_{n_i j}
  *N_i @f$
  */
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void
 InterpolationElement<interpolation_type, kind>::interpolateOnNaturalCoordinates(
     const Vector<Real> & natural_coords, const Matrix<Real> & nodal_values,
     Vector<Real> & interpolated) {
   Vector<Real> shapes(
-      InterpolationPorperty<interpolation_type>::nb_nodes_per_element);
+      InterpolationProperty<interpolation_type>::nb_nodes_per_element);
   computeShapes(natural_coords, shapes);
 
   interpolate(nodal_values, shapes, interpolated);
 }
 
 /* -------------------------------------------------------------------------- */
 /// @f$ gradient_{ij} = \frac{\partial f_j}{\partial s_i} = \sum_k
 /// \frac{\partial N_k}{\partial s_i}f_{j n_k} @f$
 template <InterpolationType interpolation_type, InterpolationKind kind>
 inline void
 InterpolationElement<interpolation_type, kind>::gradientOnNaturalCoordinates(
     const Vector<Real> & natural_coords, const Matrix<Real> & f,
     Matrix<Real> & gradient) {
   Matrix<Real> dnds(
-      InterpolationPorperty<interpolation_type>::natural_space_dimension,
-      InterpolationPorperty<interpolation_type>::nb_nodes_per_element);
+      InterpolationProperty<interpolation_type>::natural_space_dimension,
+      InterpolationProperty<interpolation_type>::nb_nodes_per_element);
   computeDNDS(natural_coords, dnds);
   gradient.mul<false, true>(f, dnds);
 }
 
 /* -------------------------------------------------------------------------- */
 /* ElementClass                                                               */
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJMat(const Tensor3<Real> & dnds,
                                       const Matrix<Real> & node_coords,
                                       Tensor3<Real> & J) {
   UInt nb_points = dnds.size(2);
   for (UInt p = 0; p < nb_points; ++p) {
     Matrix<Real> J_p(J(p));
     Matrix<Real> dnds_p(dnds(p));
     computeJMat(dnds_p, node_coords, J_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJMat(const Matrix<Real> & dnds,
                                       const Matrix<Real> & node_coords,
                                       Matrix<Real> & J) {
   /// @f$ J = dxds = dnds * x @f$
   J.mul<false, true>(dnds, node_coords);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJacobian(const Matrix<Real> & natural_coords,
                                           const Matrix<Real> & node_coords,
                                           Vector<Real> & jacobians) {
   UInt nb_points = natural_coords.cols();
   Matrix<Real> dnds(interpolation_property::natural_space_dimension,
                     interpolation_property::nb_nodes_per_element);
   Matrix<Real> J(natural_coords.rows(), node_coords.rows());
 
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> ncoord_p(natural_coords(p));
     interpolation_element::computeDNDS(ncoord_p, dnds);
     computeJMat(dnds, node_coords, J);
     computeJacobian(J, jacobians(p));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeJacobian(const Tensor3<Real> & J,
                                           Vector<Real> & jacobians) {
   UInt nb_points = J.size(2);
   for (UInt p = 0; p < nb_points; ++p) {
     computeJacobian(J(p), jacobians(p));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::computeJacobian(const Matrix<Real> & J,
                                                       Real & jacobians) {
   if (J.rows() == J.cols()) {
     jacobians = Math::det<element_property::spatial_dimension>(J.storage());
   } else {
     interpolation_element::computeSpecialJacobian(J, jacobians);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeShapeDerivatives(const Tensor3<Real> & J,
                                                   const Tensor3<Real> & dnds,
                                                   Tensor3<Real> & shape_deriv) {
   UInt nb_points = J.size(2);
   for (UInt p = 0; p < nb_points; ++p) {
     Matrix<Real> shape_deriv_p(shape_deriv(p));
     computeShapeDerivatives(J(p), dnds(p), shape_deriv_p);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void
 ElementClass<type, kind>::computeShapeDerivatives(const Matrix<Real> & J,
                                                   const Matrix<Real> & dnds,
                                                   Matrix<Real> & shape_deriv) {
   Matrix<Real> inv_J(J.rows(), J.cols());
   Math::inv<element_property::spatial_dimension>(J.storage(), inv_J.storage());
 
   shape_deriv.mul<false, false>(inv_J, dnds);
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::computeNormalsOnNaturalCoordinates(
     const Matrix<Real> & coord, Matrix<Real> & f, Matrix<Real> & normals) {
   UInt dimension = normals.rows();
   UInt nb_points = coord.cols();
 
   AKANTU_DEBUG_ASSERT((dimension - 1) ==
                           interpolation_property::natural_space_dimension,
                       "cannot extract a normal because of dimension mismatch "
                           << dimension - 1 << " "
                           << interpolation_property::natural_space_dimension);
 
   Matrix<Real> J(dimension, interpolation_property::natural_space_dimension);
   for (UInt p = 0; p < nb_points; ++p) {
     interpolation_element::gradientOnNaturalCoordinates(coord(p), f, J);
     if (dimension == 2) {
       Math::normal2(J.storage(), normals(p).storage());
     }
     if (dimension == 3) {
       Math::normal3(J(0).storage(), J(1).storage(), normals(p).storage());
     }
   }
 }
 
 /* ------------------------------------------------------------------------- */
 /**
  * In the non linear cases we need to iterate to find the natural coordinates
  *@f$\xi@f$
  * provided real coordinates @f$x@f$.
  *
  * We want to solve: @f$ x- \phi(\xi) = 0@f$ with @f$\phi(\xi) = \sum_I N_I(\xi)
  *x_I@f$
  * the mapping function which uses the nodal coordinates @f$x_I@f$.
  *
  * To that end we use the Newton method and the following series:
  *
  * @f$ \frac{\partial \phi(x_k)}{\partial \xi} \left( \xi_{k+1} - \xi_k \right)
  *= x - \phi(x_k)@f$
  *
  * When we consider elements embedded in a dimension higher than them (2D
  *triangle in a 3D space for example)
  * @f$ J = \frac{\partial \phi(\xi_k)}{\partial \xi}@f$ is of dimension
  *@f$dim_{space} \times dim_{elem}@f$ which
  * is not invertible in most cases. Rather we can solve the problem:
  *
  * @f$ J^T J \left( \xi_{k+1} - \xi_k \right) = J^T \left( x - \phi(\xi_k)
  *\right) @f$
  *
  * So that
  *
  * @f$ d\xi = \xi_{k+1} - \xi_k = (J^T J)^{-1} J^T \left( x - \phi(\xi_k)
  *\right) @f$
  *
  * So that if the series converges we have:
  *
  * @f$ 0 = J^T \left( \phi(\xi_\infty) - x \right) @f$
  *
  * And we see that this is ill-posed only if @f$ J^T x = 0@f$ which means that
  *the vector provided
  * is normal to any tangent which means it is outside of the element itself.
  *
  * @param real_coords: the real coordinates the natural coordinates are sought
  *for
  * @param node_coords: the coordinates of the nodes forming the element
  * @param natural_coords: output->the sought natural coordinates
  * @param spatial_dimension: spatial dimension of the problem
  *
  **/
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::inverseMap(
     const Vector<Real> & real_coords, const Matrix<Real> & node_coords,
     Vector<Real> & natural_coords, Real tolerance) {
   UInt spatial_dimension = real_coords.size();
   UInt dimension = natural_coords.size();
 
   // matrix copy of the real_coords
   Matrix<Real> mreal_coords(real_coords.storage(), spatial_dimension, 1);
 
   // initial guess
   //  Matrix<Real> natural_guess(natural_coords.storage(), dimension, 1);
   natural_coords.clear();
 
   // real space coordinates provided by initial guess
   Matrix<Real> physical_guess(dimension, 1);
 
   // objective function f = real_coords - physical_guess
   Matrix<Real> f(dimension, 1);
 
   // dnds computed on the natural_guess
   //  Matrix<Real> dnds(interpolation_element::nb_nodes_per_element,
   //  spatial_dimension);
 
   // J Jacobian matrix computed on the natural_guess
   Matrix<Real> J(spatial_dimension, dimension);
 
   // G = J^t * J
   Matrix<Real> G(spatial_dimension, spatial_dimension);
 
   // Ginv = G^{-1}
   Matrix<Real> Ginv(spatial_dimension, spatial_dimension);
 
   // J = Ginv * J^t
   Matrix<Real> F(spatial_dimension, dimension);
 
   // dxi = \xi_{k+1} - \xi in the iterative process
   Matrix<Real> dxi(spatial_dimension, 1);
 
   /* --------------------------- */
   /* init before iteration loop  */
   /* --------------------------- */
   // do interpolation
   auto update_f = [&f, &physical_guess, &natural_coords, &node_coords, &mreal_coords,
                    dimension]() {
     Vector<Real> physical_guess_v(physical_guess.storage(), dimension);
     interpolation_element::interpolateOnNaturalCoordinates(
         natural_coords, node_coords, physical_guess_v);
 
     // compute initial objective function value f = real_coords - physical_guess
     f = mreal_coords;
     f -= physical_guess;
 
     // compute initial error
     auto error = f.norm<L_2>();
     return error;
   };
 
   auto inverse_map_error = update_f();
 
   /* --------------------------- */
   /* iteration loop              */
   /* --------------------------- */
   while (tolerance < inverse_map_error) {
     // compute J^t
     interpolation_element::gradientOnNaturalCoordinates(natural_coords,
                                                         node_coords, J);
 
     // compute G
     G.mul<true, false>(J, J);
 
     // inverse G
     Ginv.inverse(G);
 
     // compute F
     F.mul<false, true>(Ginv, J);
 
     // compute increment
     dxi.mul<false, false>(F, f);
 
     // update our guess
     natural_coords += Vector<Real>(dxi(0));
 
     inverse_map_error = update_f();
   }
   //  memcpy(natural_coords.storage(), natural_guess.storage(), sizeof(Real) *
   //  natural_coords.size());
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType type, ElementKind kind>
 inline void ElementClass<type, kind>::inverseMap(
     const Matrix<Real> & real_coords, const Matrix<Real> & node_coords,
     Matrix<Real> & natural_coords, Real tolerance) {
   UInt nb_points = real_coords.cols();
   for (UInt p = 0; p < nb_points; ++p) {
     Vector<Real> X(real_coords(p));
     Vector<Real> ncoord_p(natural_coords(p));
     inverseMap(X, node_coords, ncoord_p, tolerance);
   }
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_CLASS_TMPL_HH__ */
diff --git a/src/fe_engine/element_classes/element_class_hexahedron_20_inline_impl.cc b/src/fe_engine/element_classes/element_class_hexahedron_20_inline_impl.cc
index 971f815fd..da0c877fc 100644
--- a/src/fe_engine/element_classes/element_class_hexahedron_20_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_hexahedron_20_inline_impl.cc
@@ -1,236 +1,259 @@
 /**
  * @file   element_class_hexahedron_20_inline_impl.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Sacha Laffely <sacha.laffely@epfl.ch>
  * @author Damien Scantamburlo <damien.scantamburlo@epfl.ch>
  *
  * @date creation: Tue Mar 31 2015
  * @date last modification: Thu Jul 16 2015
  *
  * @brief  Specialization of the element_class class for the type _hexahedron_20
  *
  * @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/>.
  *
  * @section DESCRIPTION
  *
  * @verbatim
                                    \y
                          \z       /
                          |       /
                    7-----|18--------6
                   /|     |     /   /|
                  / |     |    /   / |
                19  |     |   /  17  |
                /  15     |  /   /   14
               /    |     | /   /    |
              4-------16---/---5     |
              |     |     +----|------------\x
              |     3-------10-|-----2
              |    /           |    /
             12   /           13   /
              |  11            |  9
              | /              | /
              |/               |/
              0--------8-------1
        x   y    z
 * N0  -1  -1   -1
 * N1   1  -1   -1
 * N2   1   1   -1
 * N3  -1   1   -1
 * N4  -1  -1    1
 * N5   1  -1    1
 * N6   1   1    1
 * N7  -1   1    1
 * N8   0  -1   -1
 * N9   1   0   -1
 * N10  0   1   -1
 * N11 -1   0   -1
 * N12 -1  -1    0
 * N13  1  -1    0
 * N14  1   1    0
 * N15 -1   1    0
 * N16  0  -1    1
 * N17  1   0    1
 * N18  0   1    1
 * N19 -1   0    1
  */
 
 /* -------------------------------------------------------------------------- */
-AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_hexahedron_20,
-                                     _gt_hexahedron_20,
-                                     _itp_serendip_hexahedron_20,
-                                     _ek_regular,
-                                     3,
-                                     _git_segment,
-				     3);
-
-AKANTU_DEFINE_SHAPE(_gt_hexahedron_20, _gst_square);
+AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_hexahedron_20, _gt_hexahedron_20,
+                                     _itp_serendip_hexahedron_20, _ek_regular,
+                                     3, _git_segment, 3);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
-inline void
-InterpolationElement<_itp_serendip_hexahedron_20>::computeShapes(const vector_type & c,
-                                                                vector_type & N) {
+inline void InterpolationElement<_itp_serendip_hexahedron_20>::computeShapes(
+    const vector_type & c, vector_type & N) {
 
   // Shape function , Natural coordinates
-  N( 0) = 0.125 * (1 - c(0)) * (1 - c(1)) * (1 - c(2)) * (-2 - c(0) - c(1) - c(2));
-  N( 1) = 0.125 * (1 + c(0)) * (1 - c(1)) * (1 - c(2)) * (-2 + c(0) - c(1) - c(2));
-  N( 2) = 0.125 * (1 + c(0)) * (1 + c(1)) * (1 - c(2)) * (-2 + c(0) + c(1) - c(2));
-  N( 3) = 0.125 * (1 - c(0)) * (1 + c(1)) * (1 - c(2)) * (-2 - c(0) + c(1) - c(2));
-  N( 4) = 0.125 * (1 - c(0)) * (1 - c(1)) * (1 + c(2)) * (-2 - c(0) - c(1) + c(2));
-  N( 5) = 0.125 * (1 + c(0)) * (1 - c(1)) * (1 + c(2)) * (-2 + c(0) - c(1) + c(2));
-  N( 6) = 0.125 * (1 + c(0)) * (1 + c(1)) * (1 + c(2)) * (-2 + c(0) + c(1) + c(2));
-  N( 7) = 0.125 * (1 - c(0)) * (1 + c(1)) * (1 + c(2)) * (-2 - c(0) + c(1) + c(2));
-  N( 8) = 0.25  * (1 - c(0)*c(0)) * (1 - c(1)) * (1 - c(2));
-  N( 9) = 0.25  * (1 - c(1)*c(1)) * (1 + c(0)) * (1 - c(2));
-  N(10) = 0.25  * (1 - c(0)*c(0)) * (1 + c(1)) * (1 - c(2));
-  N(11) = 0.25  * (1 - c(1)*c(1)) * (1 - c(0)) * (1 - c(2));
-  N(12) = 0.25  * (1 - c(2)*c(2)) * (1 - c(0)) * (1 - c(1));
-  N(13) = 0.25  * (1 - c(2)*c(2)) * (1 + c(0)) * (1 - c(1));
-  N(14) = 0.25  * (1 - c(2)*c(2)) * (1 + c(0)) * (1 + c(1));
-  N(15) = 0.25  * (1 - c(2)*c(2)) * (1 - c(0)) * (1 + c(1));
-  N(16) = 0.25  * (1 - c(0)*c(0)) * (1 - c(1)) * (1 + c(2));
-  N(17) = 0.25  * (1 - c(1)*c(1)) * (1 + c(0)) * (1 + c(2));
-  N(18) = 0.25  * (1 - c(0)*c(0)) * (1 + c(1)) * (1 + c(2));
-  N(19) = 0.25  * (1 - c(1)*c(1)) * (1 - c(0)) * (1 + c(2));
+  N(0) =
+      0.125 * (1 - c(0)) * (1 - c(1)) * (1 - c(2)) * (-2 - c(0) - c(1) - c(2));
+  N(1) =
+      0.125 * (1 + c(0)) * (1 - c(1)) * (1 - c(2)) * (-2 + c(0) - c(1) - c(2));
+  N(2) =
+      0.125 * (1 + c(0)) * (1 + c(1)) * (1 - c(2)) * (-2 + c(0) + c(1) - c(2));
+  N(3) =
+      0.125 * (1 - c(0)) * (1 + c(1)) * (1 - c(2)) * (-2 - c(0) + c(1) - c(2));
+  N(4) =
+      0.125 * (1 - c(0)) * (1 - c(1)) * (1 + c(2)) * (-2 - c(0) - c(1) + c(2));
+  N(5) =
+      0.125 * (1 + c(0)) * (1 - c(1)) * (1 + c(2)) * (-2 + c(0) - c(1) + c(2));
+  N(6) =
+      0.125 * (1 + c(0)) * (1 + c(1)) * (1 + c(2)) * (-2 + c(0) + c(1) + c(2));
+  N(7) =
+      0.125 * (1 - c(0)) * (1 + c(1)) * (1 + c(2)) * (-2 - c(0) + c(1) + c(2));
+  N(8) = 0.25 * (1 - c(0) * c(0)) * (1 - c(1)) * (1 - c(2));
+  N(9) = 0.25 * (1 - c(1) * c(1)) * (1 + c(0)) * (1 - c(2));
+  N(10) = 0.25 * (1 - c(0) * c(0)) * (1 + c(1)) * (1 - c(2));
+  N(11) = 0.25 * (1 - c(1) * c(1)) * (1 - c(0)) * (1 - c(2));
+  N(12) = 0.25 * (1 - c(2) * c(2)) * (1 - c(0)) * (1 - c(1));
+  N(13) = 0.25 * (1 - c(2) * c(2)) * (1 + c(0)) * (1 - c(1));
+  N(14) = 0.25 * (1 - c(2) * c(2)) * (1 + c(0)) * (1 + c(1));
+  N(15) = 0.25 * (1 - c(2) * c(2)) * (1 - c(0)) * (1 + c(1));
+  N(16) = 0.25 * (1 - c(0) * c(0)) * (1 - c(1)) * (1 + c(2));
+  N(17) = 0.25 * (1 - c(1) * c(1)) * (1 + c(0)) * (1 + c(2));
+  N(18) = 0.25 * (1 - c(0) * c(0)) * (1 + c(1)) * (1 + c(2));
+  N(19) = 0.25 * (1 - c(1) * c(1)) * (1 - c(0)) * (1 + c(2));
 }
 /* -------------------------------------------------------------------------- */
 
 template <>
 template <class vector_type, class matrix_type>
-inline void
-InterpolationElement<_itp_serendip_hexahedron_20>::computeDNDS(const vector_type & c,
-                                                              matrix_type & dnds) {
-  //derivatives
-  //ddx
-  dnds(0,  0) =  0.25 * (c(0) + 0.5 * (c(1) + c(2) + 1)) * (c(1) - 1) * (c(2) - 1);
-  dnds(0,  1) =  0.25 * (c(0) - 0.5 * (c(1) + c(2) + 1)) * (c(1) - 1) * (c(2) - 1);
-  dnds(0,  2) = -0.25 * (c(0) + 0.5 * (c(1) - c(2) - 1)) * (c(1) + 1) * (c(2) - 1);
-  dnds(0,  3) = -0.25 * (c(0) - 0.5 * (c(1) - c(2) - 1)) * (c(1) + 1) * (c(2) - 1);
-  dnds(0,  4) = -0.25 * (c(0) + 0.5 * (c(1) - c(2) + 1)) * (c(1) - 1) * (c(2) + 1);
-  dnds(0,  5) = -0.25 * (c(0) - 0.5 * (c(1) - c(2) + 1)) * (c(1) - 1) * (c(2) + 1);
-  dnds(0,  6) =  0.25 * (c(0) + 0.5 * (c(1) + c(2) - 1)) * (c(1) + 1) * (c(2) + 1);
-  dnds(0,  7) =  0.25 * (c(0) - 0.5 * (c(1) + c(2) - 1)) * (c(1) + 1) * (c(2) + 1);
-  dnds(0,  8) = -0.5  * c(0) * (c(1) - 1) * (c(2) - 1);
-  dnds(0,  9) =  0.25 * (c(1)*c(1) - 1) * (c(2) - 1);
-  dnds(0, 10) =  0.5  * c(0) * (c(1) + 1) * (c(2) - 1);
-  dnds(0, 11) = -0.25 * (c(1)*c(1) - 1) * (c(2) - 1);
-  dnds(0, 12) = -0.25 * (c(2)*c(2) - 1) * (c(1) - 1);
-  dnds(0, 13) =  0.25 * (c(1) - 1) * (c(2)*c(2) - 1);
-  dnds(0, 14) = -0.25 * (c(1) + 1) * (c(2)*c(2) - 1);
-  dnds(0, 15) =  0.25 * (c(1) + 1) * (c(2)*c(2) - 1);
-  dnds(0, 16) =  0.5  * c(0) * (c(1) - 1) * (c(2) + 1);
-  dnds(0, 17) = -0.25 * (c(2) + 1) * (c(1)*c(1) - 1);
-  dnds(0, 18) = -0.5  * c(0) * (c(1) + 1) * (c(2) + 1);
-  dnds(0, 19) =  0.25 * (c(2) + 1) * (c(1)*c(1) - 1);
-
+inline void InterpolationElement<_itp_serendip_hexahedron_20>::computeDNDS(
+    const vector_type & c, matrix_type & dnds) {
+  // derivatives
+  // ddx
+  dnds(0, 0) =
+      0.25 * (c(0) + 0.5 * (c(1) + c(2) + 1)) * (c(1) - 1) * (c(2) - 1);
+  dnds(0, 1) =
+      0.25 * (c(0) - 0.5 * (c(1) + c(2) + 1)) * (c(1) - 1) * (c(2) - 1);
+  dnds(0, 2) =
+      -0.25 * (c(0) + 0.5 * (c(1) - c(2) - 1)) * (c(1) + 1) * (c(2) - 1);
+  dnds(0, 3) =
+      -0.25 * (c(0) - 0.5 * (c(1) - c(2) - 1)) * (c(1) + 1) * (c(2) - 1);
+  dnds(0, 4) =
+      -0.25 * (c(0) + 0.5 * (c(1) - c(2) + 1)) * (c(1) - 1) * (c(2) + 1);
+  dnds(0, 5) =
+      -0.25 * (c(0) - 0.5 * (c(1) - c(2) + 1)) * (c(1) - 1) * (c(2) + 1);
+  dnds(0, 6) =
+      0.25 * (c(0) + 0.5 * (c(1) + c(2) - 1)) * (c(1) + 1) * (c(2) + 1);
+  dnds(0, 7) =
+      0.25 * (c(0) - 0.5 * (c(1) + c(2) - 1)) * (c(1) + 1) * (c(2) + 1);
+  dnds(0, 8) = -0.5 * c(0) * (c(1) - 1) * (c(2) - 1);
+  dnds(0, 9) = 0.25 * (c(1) * c(1) - 1) * (c(2) - 1);
+  dnds(0, 10) = 0.5 * c(0) * (c(1) + 1) * (c(2) - 1);
+  dnds(0, 11) = -0.25 * (c(1) * c(1) - 1) * (c(2) - 1);
+  dnds(0, 12) = -0.25 * (c(2) * c(2) - 1) * (c(1) - 1);
+  dnds(0, 13) = 0.25 * (c(1) - 1) * (c(2) * c(2) - 1);
+  dnds(0, 14) = -0.25 * (c(1) + 1) * (c(2) * c(2) - 1);
+  dnds(0, 15) = 0.25 * (c(1) + 1) * (c(2) * c(2) - 1);
+  dnds(0, 16) = 0.5 * c(0) * (c(1) - 1) * (c(2) + 1);
+  dnds(0, 17) = -0.25 * (c(2) + 1) * (c(1) * c(1) - 1);
+  dnds(0, 18) = -0.5 * c(0) * (c(1) + 1) * (c(2) + 1);
+  dnds(0, 19) = 0.25 * (c(2) + 1) * (c(1) * c(1) - 1);
 
-  //ddy
-  dnds(1,  0) =  0.25 * (c(1) + 0.5 * (c(0) + c(2) + 1)) * (c(0) - 1) * (c(2) - 1);
-  dnds(1,  1) = -0.25 * (c(1) - 0.5 * (c(0) - c(2) - 1)) * (c(0) + 1) * (c(2) - 1);
-  dnds(1,  2) = -0.25 * (c(1) + 0.5 * (c(0) - c(2) - 1)) * (c(0) + 1) * (c(2) - 1);
-  dnds(1,  3) =  0.25 * (c(1) - 0.5 * (c(0) + c(2) + 1)) * (c(0) - 1) * (c(2) - 1);
-  dnds(1,  4) = -0.25 * (c(1) + 0.5 * (c(0) - c(2) + 1)) * (c(0) - 1) * (c(2) + 1);
-  dnds(1,  5) =  0.25 * (c(1) - 0.5 * (c(0) + c(2) - 1)) * (c(0) + 1) * (c(2) + 1);
-  dnds(1,  6) =  0.25 * (c(1) + 0.5 * (c(0) + c(2) - 1)) * (c(0) + 1) * (c(2) + 1);
-  dnds(1,  7) = -0.25 * (c(1) - 0.5 * (c(0) - c(2) + 1)) * (c(0) - 1) * (c(2) + 1);
-  dnds(1,  8) = -0.25 * (c(0)*c(0) - 1) * (c(2) - 1);
-  dnds(1,  9) =  0.5  * c(1) * (c(0) + 1) * (c(2) - 1);
-  dnds(1, 10) =  0.25 * (c(0)*c(0) - 1) * (c(2) - 1);
-  dnds(1, 11) = -0.5  * c(1) * (c(0) - 1) * (c(2) - 1);
-  dnds(1, 12) = -0.25 * (c(2)*c(2) - 1) * (c(0) - 1);
-  dnds(1, 13) =  0.25 * (c(0) + 1) * (c(2)*c(2) - 1);
-  dnds(1, 14) = -0.25 * (c(0) + 1) * (c(2)*c(2) - 1);
-  dnds(1, 15) =  0.25 * (c(0) - 1) * (c(2)*c(2) - 1);
-  dnds(1, 16) =  0.25 * (c(2) + 1) * (c(0)*c(0) - 1);
-  dnds(1, 17) = -0.5  * c(1) * (c(0) + 1) * (c(2) + 1);
-  dnds(1, 18) = -0.25 * (c(2) + 1) * (c(0)*c(0) - 1);
-  dnds(1, 19) =  0.5  * c(1) * (c(0) - 1) * (c(2) + 1);
+  // ddy
+  dnds(1, 0) =
+      0.25 * (c(1) + 0.5 * (c(0) + c(2) + 1)) * (c(0) - 1) * (c(2) - 1);
+  dnds(1, 1) =
+      -0.25 * (c(1) - 0.5 * (c(0) - c(2) - 1)) * (c(0) + 1) * (c(2) - 1);
+  dnds(1, 2) =
+      -0.25 * (c(1) + 0.5 * (c(0) - c(2) - 1)) * (c(0) + 1) * (c(2) - 1);
+  dnds(1, 3) =
+      0.25 * (c(1) - 0.5 * (c(0) + c(2) + 1)) * (c(0) - 1) * (c(2) - 1);
+  dnds(1, 4) =
+      -0.25 * (c(1) + 0.5 * (c(0) - c(2) + 1)) * (c(0) - 1) * (c(2) + 1);
+  dnds(1, 5) =
+      0.25 * (c(1) - 0.5 * (c(0) + c(2) - 1)) * (c(0) + 1) * (c(2) + 1);
+  dnds(1, 6) =
+      0.25 * (c(1) + 0.5 * (c(0) + c(2) - 1)) * (c(0) + 1) * (c(2) + 1);
+  dnds(1, 7) =
+      -0.25 * (c(1) - 0.5 * (c(0) - c(2) + 1)) * (c(0) - 1) * (c(2) + 1);
+  dnds(1, 8) = -0.25 * (c(0) * c(0) - 1) * (c(2) - 1);
+  dnds(1, 9) = 0.5 * c(1) * (c(0) + 1) * (c(2) - 1);
+  dnds(1, 10) = 0.25 * (c(0) * c(0) - 1) * (c(2) - 1);
+  dnds(1, 11) = -0.5 * c(1) * (c(0) - 1) * (c(2) - 1);
+  dnds(1, 12) = -0.25 * (c(2) * c(2) - 1) * (c(0) - 1);
+  dnds(1, 13) = 0.25 * (c(0) + 1) * (c(2) * c(2) - 1);
+  dnds(1, 14) = -0.25 * (c(0) + 1) * (c(2) * c(2) - 1);
+  dnds(1, 15) = 0.25 * (c(0) - 1) * (c(2) * c(2) - 1);
+  dnds(1, 16) = 0.25 * (c(2) + 1) * (c(0) * c(0) - 1);
+  dnds(1, 17) = -0.5 * c(1) * (c(0) + 1) * (c(2) + 1);
+  dnds(1, 18) = -0.25 * (c(2) + 1) * (c(0) * c(0) - 1);
+  dnds(1, 19) = 0.5 * c(1) * (c(0) - 1) * (c(2) + 1);
 
-  //ddz
-  dnds(2,  0) =  0.25 * (c(2) + 0.5 * (c(0) + c(1) + 1)) * (c(0) - 1) * (c(1) - 1);
-  dnds(2,  1) = -0.25 * (c(2) - 0.5 * (c(0) - c(1) - 1)) * (c(0) + 1) * (c(1) - 1);
-  dnds(2,  2) =  0.25 * (c(2) - 0.5 * (c(0) + c(1) - 1)) * (c(0) + 1) * (c(1) + 1);
-  dnds(2,  3) = -0.25 * (c(2) + 0.5 * (c(0) - c(1) + 1)) * (c(0) - 1) * (c(1) + 1);
-  dnds(2,  4) =  0.25 * (c(2) - 0.5 * (c(0) + c(1) + 1)) * (c(0) - 1) * (c(1) - 1);
-  dnds(2,  5) = -0.25 * (c(2) + 0.5 * (c(0) - c(1) - 1)) * (c(0) + 1) * (c(1) - 1);
-  dnds(2,  6) =  0.25 * (c(2) + 0.5 * (c(0) + c(1) - 1)) * (c(0) + 1) * (c(1) + 1);
-  dnds(2,  7) = -0.25 * (c(2) - 0.5 * (c(0) - c(1) + 1)) * (c(0) - 1) * (c(1) + 1);
-  dnds(2,  8) = -0.25 * (c(0)*c(0) - 1) * (c(1) - 1);
-  dnds(2,  9) =  0.25 * (c(1)*c(1) - 1) * (c(0) + 1);
-  dnds(2, 10) =  0.25 * (c(0)*c(0) - 1) * (c(1) + 1);
-  dnds(2, 11) = -0.25 * (c(1)*c(1) - 1) * (c(0) - 1);
-  dnds(2, 12) = -0.5  * c(2) * (c(1) - 1) * (c(0) - 1);
-  dnds(2, 13) =  0.5  * c(2) * (c(0) + 1) * (c(1) - 1);
-  dnds(2, 14) = -0.5  * c(2) * (c(0) + 1) * (c(1) + 1);
-  dnds(2, 15) =  0.5  * c(2) * (c(0) - 1) * (c(1) + 1);
-  dnds(2, 16) =  0.25 * (c(1) - 1) * (c(0)*c(0) - 1);
-  dnds(2, 17) = -0.25 * (c(0) + 1) * (c(1)*c(1) - 1);
-  dnds(2, 18) = -0.25 * (c(1) + 1) * (c(0)*c(0) - 1);
-  dnds(2, 19) =  0.25 * (c(0) - 1) * (c(1)*c(1) - 1);
+  // ddz
+  dnds(2, 0) =
+      0.25 * (c(2) + 0.5 * (c(0) + c(1) + 1)) * (c(0) - 1) * (c(1) - 1);
+  dnds(2, 1) =
+      -0.25 * (c(2) - 0.5 * (c(0) - c(1) - 1)) * (c(0) + 1) * (c(1) - 1);
+  dnds(2, 2) =
+      0.25 * (c(2) - 0.5 * (c(0) + c(1) - 1)) * (c(0) + 1) * (c(1) + 1);
+  dnds(2, 3) =
+      -0.25 * (c(2) + 0.5 * (c(0) - c(1) + 1)) * (c(0) - 1) * (c(1) + 1);
+  dnds(2, 4) =
+      0.25 * (c(2) - 0.5 * (c(0) + c(1) + 1)) * (c(0) - 1) * (c(1) - 1);
+  dnds(2, 5) =
+      -0.25 * (c(2) + 0.5 * (c(0) - c(1) - 1)) * (c(0) + 1) * (c(1) - 1);
+  dnds(2, 6) =
+      0.25 * (c(2) + 0.5 * (c(0) + c(1) - 1)) * (c(0) + 1) * (c(1) + 1);
+  dnds(2, 7) =
+      -0.25 * (c(2) - 0.5 * (c(0) - c(1) + 1)) * (c(0) - 1) * (c(1) + 1);
+  dnds(2, 8) = -0.25 * (c(0) * c(0) - 1) * (c(1) - 1);
+  dnds(2, 9) = 0.25 * (c(1) * c(1) - 1) * (c(0) + 1);
+  dnds(2, 10) = 0.25 * (c(0) * c(0) - 1) * (c(1) + 1);
+  dnds(2, 11) = -0.25 * (c(1) * c(1) - 1) * (c(0) - 1);
+  dnds(2, 12) = -0.5 * c(2) * (c(1) - 1) * (c(0) - 1);
+  dnds(2, 13) = 0.5 * c(2) * (c(0) + 1) * (c(1) - 1);
+  dnds(2, 14) = -0.5 * c(2) * (c(0) + 1) * (c(1) + 1);
+  dnds(2, 15) = 0.5 * c(2) * (c(0) - 1) * (c(1) + 1);
+  dnds(2, 16) = 0.25 * (c(1) - 1) * (c(0) * c(0) - 1);
+  dnds(2, 17) = -0.25 * (c(0) + 1) * (c(1) * c(1) - 1);
+  dnds(2, 18) = -0.25 * (c(1) + 1) * (c(0) * c(0) - 1);
+  dnds(2, 19) = 0.25 * (c(0) - 1) * (c(1) * c(1) - 1);
 }
 
 /* -------------------------------------------------------------------------- */
 
-template<>
+template <>
 inline Real
 GeometricalElement<_gt_hexahedron_20>::getInradius(const Matrix<Real> & coord) {
   Vector<Real> u0 = coord(0);
   Vector<Real> u1 = coord(1);
   Vector<Real> u2 = coord(2);
   Vector<Real> u3 = coord(3);
   Vector<Real> u4 = coord(4);
   Vector<Real> u5 = coord(5);
   Vector<Real> u6 = coord(6);
   Vector<Real> u7 = coord(7);
   Vector<Real> u8 = coord(8);
   Vector<Real> u9 = coord(9);
   Vector<Real> u10 = coord(10);
-  Vector<Real> u11= coord(11);
+  Vector<Real> u11 = coord(11);
   Vector<Real> u12 = coord(12);
   Vector<Real> u13 = coord(13);
   Vector<Real> u14 = coord(14);
   Vector<Real> u15 = coord(15);
   Vector<Real> u16 = coord(16);
   Vector<Real> u17 = coord(17);
   Vector<Real> u18 = coord(18);
   Vector<Real> u19 = coord(19);
 
   Real a = u0.distance(u1);
   Real b = u1.distance(u2);
   Real c = u2.distance(u3);
   Real d = u3.distance(u0);
   Real e = u0.distance(u4);
   Real f = u1.distance(u5);
   Real g = u2.distance(u6);
   Real h = u3.distance(u7);
   Real i = u4.distance(u5);
   Real j = u5.distance(u6);
   Real k = u6.distance(u7);
   Real l = u7.distance(u4);
 
   Real x = std::min(a, std::min(b, std::min(c, d)));
   Real y = std::min(e, std::min(f, std::min(g, h)));
   Real z = std::min(i, std::min(j, std::min(k, l)));
   Real p = std::min(x, std::min(y, z));
 
   return p;
 }
diff --git a/src/fe_engine/element_classes/element_class_hexahedron_8_inline_impl.cc b/src/fe_engine/element_classes/element_class_hexahedron_8_inline_impl.cc
index d84a2ad30..dfee018d7 100644
--- a/src/fe_engine/element_classes/element_class_hexahedron_8_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_hexahedron_8_inline_impl.cc
@@ -1,216 +1,215 @@
 /**
  * @file   element_class_hexahedron_8_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Peter Spijker <peter.spijker@epfl.ch>
  *
  * @date creation: Mon Mar 14 2011
  * @date last modification: Sat Sep 12 2015
  *
  * @brief  Specialization of the element_class class for the type _hexahedron_8
  *
  * @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
  *
  * @verbatim
                    \zeta
                     ^
          (-1,1,1)   |     (1,1,1)
                 7---|------6
                /|   |     /|
               / |   |    / |
    (-1,-1,1) 4----------5  | (1,-1,1)
              |  |   |   |  |
              |  |   |   |  |
              |  |   +---|-------> \xi
              |  |  /    |  |
    (-1,1,-1) |  3-/-----|--2 (1,1,-1)
              | / /      | /
              |/ /       |/
              0-/--------1
    (-1,-1,-1) /        (1,-1,-1)
              /
             \eta
  @endverbatim
  *
  * @subsection shapes Shape functions
  * @f[
  * \begin{array}{llll}
  * N1 = (1 - \xi) (1 - \eta) (1 - \zeta) / 8
  *       & \frac{\partial N1}{\partial \xi}  = - (1 - \eta) (1 - \zeta) / 8
  *       & \frac{\partial N1}{\partial \eta} = - (1 - \xi) (1 - \zeta) / 8
  *       & \frac{\partial N1}{\partial \zeta} = - (1 - \xi) (1 - \eta) / 8 \\
  * N2 = (1 + \xi) (1 - \eta) (1 - \zeta) / 8
  *       & \frac{\partial N2}{\partial \xi}  = (1 - \eta) (1 - \zeta) / 8
  *       & \frac{\partial N2}{\partial \eta} = - (1 + \xi) (1 - \zeta) / 8
  *       & \frac{\partial N2}{\partial \zeta} = - (1 + \xi) (1 - \eta) / 8 \\
  * N3 = (1 + \xi) (1 + \eta) (1 - \zeta) / 8
  *       & \frac{\partial N3}{\partial \xi}  = (1 + \eta) (1 - \zeta) / 8
  *       & \frac{\partial N3}{\partial \eta} = (1 + \xi) (1 - \zeta) / 8
  *       & \frac{\partial N3}{\partial \zeta} = - (1 + \xi) (1 + \eta) / 8 \\
  * N4 = (1 - \xi) (1 + \eta) (1 - \zeta) / 8
  *       & \frac{\partial N4}{\partial \xi}  = - (1 + \eta) (1 - \zeta) / 8
  *       & \frac{\partial N4}{\partial \eta} = (1 - \xi) (1 - \zeta) / 8
  *       & \frac{\partial N4}{\partial \zeta} = - (1 - \xi) (1 + \eta) / 8 \\
  * N5 = (1 - \xi) (1 - \eta) (1 + \zeta) / 8
  *       & \frac{\partial N5}{\partial \xi}  = - (1 - \eta) (1 + \zeta) / 8
  *       & \frac{\partial N5}{\partial \eta} = - (1 - \xi) (1 + \zeta) / 8
  *       & \frac{\partial N5}{\partial \zeta} = (1 - \xi) (1 - \eta) / 8 \\
  * N6 = (1 + \xi) (1 - \eta) (1 + \zeta) / 8
  *       & \frac{\partial N6}{\partial \xi}  = (1 - \eta) (1 + \zeta) / 8
  *       & \frac{\partial N6}{\partial \eta} = - (1 + \xi) (1 + \zeta) / 8
  *       & \frac{\partial N6}{\partial \zeta} = (1 + \xi) (1 - \eta) / 8 \\
  * N7 = (1 + \xi) (1 + \eta) (1 + \zeta) / 8
  *       & \frac{\partial N7}{\partial \xi}  = (1 + \eta) (1 + \zeta) / 8
  *       & \frac{\partial N7}{\partial \eta} = (1 + \xi) (1 + \zeta) / 8
  *       & \frac{\partial N7}{\partial \zeta} = (1 + \xi) (1 + \eta) / 8 \\
  * N8 = (1 - \xi) (1 + \eta) (1 + \zeta) / 8
  *       & \frac{\partial N8}{\partial \xi}  = - (1 + \eta) (1 + \zeta) / 8
  *       & \frac{\partial N8}{\partial \eta} = (1 - \xi) (1 + \zeta) / 8
  *       & \frac{\partial N8}{\partial \zeta} = (1 - \xi) (1 + \eta) / 8 \\
  * \end{array}
  * @f]
  *
  * @subsection quad_points Position of quadrature points
  * @f{eqnarray*}{
  * \xi_{q0}  &=& -1/\sqrt{3} \qquad  \eta_{q0} = -1/\sqrt{3} \qquad \zeta_{q0} = -1/\sqrt{3} \\
  * \xi_{q1}  &=&  1/\sqrt{3} \qquad  \eta_{q1} = -1/\sqrt{3} \qquad \zeta_{q1} = -1/\sqrt{3} \\
  * \xi_{q2}  &=&  1/\sqrt{3} \qquad  \eta_{q2} =  1/\sqrt{3} \qquad \zeta_{q2} = -1/\sqrt{3} \\
  * \xi_{q3}  &=& -1/\sqrt{3} \qquad  \eta_{q3} =  1/\sqrt{3} \qquad \zeta_{q3} = -1/\sqrt{3} \\
  * \xi_{q4}  &=& -1/\sqrt{3} \qquad  \eta_{q4} = -1/\sqrt{3} \qquad \zeta_{q4} =  1/\sqrt{3} \\
  * \xi_{q5}  &=&  1/\sqrt{3} \qquad  \eta_{q5} = -1/\sqrt{3} \qquad \zeta_{q5} =  1/\sqrt{3} \\
  * \xi_{q6}  &=&  1/\sqrt{3} \qquad  \eta_{q6} =  1/\sqrt{3} \qquad \zeta_{q6} =  1/\sqrt{3} \\
  * \xi_{q7}  &=& -1/\sqrt{3} \qquad  \eta_{q7} =  1/\sqrt{3} \qquad \zeta_{q7} =  1/\sqrt{3} \\
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_hexahedron_8,
 				     _gt_hexahedron_8,
 				     _itp_lagrange_hexahedron_8,
 				     _ek_regular,
 				     3,
 				     _git_segment, 2);
-AKANTU_DEFINE_SHAPE(_gt_hexahedron_8, _gst_square);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_hexahedron_8>::computeShapes(const vector_type & c,
                                                                 vector_type & N) {
   /// Natural coordinates
   N(0) = .125 * (1 - c(0)) * (1 - c(1)) * (1 - c(2)); /// N1(q_0)
   N(1) = .125 * (1 + c(0)) * (1 - c(1)) * (1 - c(2)); /// N2(q_0)
   N(2) = .125 * (1 + c(0)) * (1 + c(1)) * (1 - c(2)); /// N3(q_0)
   N(3) = .125 * (1 - c(0)) * (1 + c(1)) * (1 - c(2)); /// N4(q_0)
   N(4) = .125 * (1 - c(0)) * (1 - c(1)) * (1 + c(2)); /// N5(q_0)
   N(5) = .125 * (1 + c(0)) * (1 - c(1)) * (1 + c(2)); /// N6(q_0)
   N(6) = .125 * (1 + c(0)) * (1 + c(1)) * (1 + c(2)); /// N7(q_0)
   N(7) = .125 * (1 - c(0)) * (1 + c(1)) * (1 + c(2)); /// N8(q_0)
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_hexahedron_8>::computeDNDS(const vector_type & c,
                                                               matrix_type & dnds) {
   /**
    * @f[
    * dnds = \left(
    *          \begin{array}{cccccccc}
    *            \frac{\partial N1}{\partial \xi}  & \frac{\partial N2}{\partial \xi}
    *               & \frac{\partial N3}{\partial \xi}  & \frac{\partial N4}{\partial \xi}
    *               & \frac{\partial N5}{\partial \xi}  & \frac{\partial N6}{\partial \xi}
    *               & \frac{\partial N7}{\partial \xi}  & \frac{\partial N8}{\partial \xi}\\
    *            \frac{\partial N1}{\partial \eta} & \frac{\partial N2}{\partial \eta}
    *               & \frac{\partial N3}{\partial \eta} & \frac{\partial N4}{\partial \eta}
    *               & \frac{\partial N5}{\partial \eta} & \frac{\partial N6}{\partial \eta}
    *               & \frac{\partial N7}{\partial \eta} & \frac{\partial N8}{\partial \eta}\\
    *            \frac{\partial N1}{\partial \zeta} & \frac{\partial N2}{\partial \zeta}
    *               & \frac{\partial N3}{\partial \zeta} & \frac{\partial N4}{\partial \zeta}
    *               & \frac{\partial N5}{\partial \zeta} & \frac{\partial N6}{\partial \zeta}
    *               & \frac{\partial N7}{\partial \zeta} & \frac{\partial N8}{\partial \zeta}
    *          \end{array}
    *        \right)
    * @f]
    */
   dnds(0, 0) = - .125 * (1 - c(1)) * (1 - c(2));;
   dnds(0, 1) =   .125 * (1 - c(1)) * (1 - c(2));;
   dnds(0, 2) =   .125 * (1 + c(1)) * (1 - c(2));;
   dnds(0, 3) = - .125 * (1 + c(1)) * (1 - c(2));;
   dnds(0, 4) = - .125 * (1 - c(1)) * (1 + c(2));;
   dnds(0, 5) =   .125 * (1 - c(1)) * (1 + c(2));;
   dnds(0, 6) =   .125 * (1 + c(1)) * (1 + c(2));;
   dnds(0, 7) = - .125 * (1 + c(1)) * (1 + c(2));;
 
   dnds(1, 0) = - .125 * (1 - c(0)) * (1 - c(2));;
   dnds(1, 1) = - .125 * (1 + c(0)) * (1 - c(2));;
   dnds(1, 2) =   .125 * (1 + c(0)) * (1 - c(2));;
   dnds(1, 3) =   .125 * (1 - c(0)) * (1 - c(2));;
   dnds(1, 4) = - .125 * (1 - c(0)) * (1 + c(2));;
   dnds(1, 5) = - .125 * (1 + c(0)) * (1 + c(2));;
   dnds(1, 6) =   .125 * (1 + c(0)) * (1 + c(2));;
   dnds(1, 7) =   .125 * (1 - c(0)) * (1 + c(2));;
 
   dnds(2, 0) = - .125 * (1 - c(0)) * (1 - c(1));;
   dnds(2, 1) = - .125 * (1 + c(0)) * (1 - c(1));;
   dnds(2, 2) = - .125 * (1 + c(0)) * (1 + c(1));;
   dnds(2, 3) = - .125 * (1 - c(0)) * (1 + c(1));;
   dnds(2, 4) =   .125 * (1 - c(0)) * (1 - c(1));;
   dnds(2, 5) =   .125 * (1 + c(0)) * (1 - c(1));;
   dnds(2, 6) =   .125 * (1 + c(0)) * (1 + c(1));;
   dnds(2, 7) =   .125 * (1 - c(0)) * (1 + c(1));;
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline Real
 GeometricalElement<_gt_hexahedron_8>::getInradius(const Matrix<Real> & coord) {
   Vector<Real> u0 = coord(0);
   Vector<Real> u1 = coord(1);
   Vector<Real> u2 = coord(2);
   Vector<Real> u3 = coord(3);
   Vector<Real> u4 = coord(4);
   Vector<Real> u5 = coord(5);
   Vector<Real> u6 = coord(6);
   Vector<Real> u7 = coord(7);
 
   Real a = u0.distance(u1);
   Real b = u1.distance(u2);
   Real c = u2.distance(u3);
   Real d = u3.distance(u0);
   Real e = u0.distance(u4);
   Real f = u1.distance(u5);
   Real g = u2.distance(u6);
   Real h = u3.distance(u7);
   Real i = u4.distance(u5);
   Real j = u5.distance(u6);
   Real k = u6.distance(u7);
   Real l = u7.distance(u4);
 
   Real x = std::min(a, std::min(b, std::min(c, d)));
   Real y = std::min(e, std::min(f, std::min(g, h)));
   Real z = std::min(i, std::min(j, std::min(k, l)));
   Real p = std::min(x, std::min(y, z));
 
   return p;
 }
diff --git a/src/fe_engine/element_classes/element_class_pentahedron_15_inline_impl.cc b/src/fe_engine/element_classes/element_class_pentahedron_15_inline_impl.cc
index 2de767bcb..b69d2d6b1 100644
--- a/src/fe_engine/element_classes/element_class_pentahedron_15_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_pentahedron_15_inline_impl.cc
@@ -1,172 +1,170 @@
 /**
  * @file   element_class_pentahedron_15_inline_impl.cc
  *
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Sacha Laffely <sacha.laffely@epfl.ch>
  * @author Damien Scantamburlo <damien.scantamburlo@epfl.ch>
  *
  * @date creation: Tue Mar 31 2015
  * @date last modification: Wed Sep 16 2015
  *
  * @brief  Specialization of the element_class class for the type _pentahedron_15
  *
  * @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/>.
  *
  * @section DESCRIPTION
  *
  * @verbatim
              z
              ^
              |
              |
              |  1
              | /|\
              |/ | \
              10 7  6
             /   |   \
            /    |    \
            4    2--8--0
           | \  /      /
           |  \11     /
           13  12    9---------->y
           | /  \   /
           |/    \ /
           5--14--3
          /
         /
        /
       v
      x
        x   y    z
 * N0  -1   1    0
 * N1  -1   0    1
 * N2  -1   0    0
 * N3   1   1    0
 * N4   1   0    1
 * N5   1   0    0
 * N6  -1   0.5  0.5
 * N7  -1   0    0.5
 * N8  -1   0.5  0
 * N9   0   1    0
 * N10  0   0    1
 * N11  0   0    0
 * N12  1   0.5  0.5
 * N13  1   0    0.5
 * N14  1   0.5  0
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_pentahedron_15,
                                      _gt_pentahedron_15,
                                      _itp_lagrange_pentahedron_15,
                                      _ek_regular,
                                      3,
                                      _git_pentahedron,
                                      2);
 
-AKANTU_DEFINE_SHAPE(_gt_pentahedron_15, _gst_prism);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_pentahedron_15>::computeShapes(const vector_type & c,
                                                                  vector_type & N) {
   // Shape Functions, Natural coordinates
   N( 0) = 0.5 * c(1) * (1 - c(0)) * (2 * c(1) - 2 - c(0));
   N( 1) = 0.5 * c(2) * (1 - c(0)) * (2 * c(2) - 2 - c(0));
   N( 2) = 0.5 * (c(0) - 1) * (1 - c(1) - c(2)) * (c(0) + 2 * c(1) + 2 * c(2));
   N( 3) = 0.5 * c(1) * (1 + c(0)) * (2 * c(1) - 2 + c(0));
   N( 4) = 0.5 * c(2) * (1 + c(0)) * (2 * c(2) - 2 + c(0));
   N( 5) = 0.5 * (-c(0) - 1) * (1 - c(1) - c(2)) * (-c(0) + 2 * c(1) + 2 * c(2));
   N( 6) = 2.0 * c(1) * c(2) * (1 - c(0));
   N( 7) = 2.0 * c(2) * (1 - c(1) - c(2)) * (1 - c(0));
   N( 8) = 2.0 * c(1) * (1 - c(0)) * (1 - c(1) - c(2));
   N( 9) = c(1) * (1 - c(0) * c(0));
   N(10) = c(2) * (1 - c(0) * c(0));
   N(11) = (1 - c(1) - c(2)) * (1 - c(0) * c(0));
   N(12) = 2.0 * c(1) * c(2) * (1 + c(0));
   N(13) = 2.0 * c(2) * (1 - c(1) - c(2)) * (1 + c(0));
   N(14) = 2.0 * c(1) * (1 - c(1) - c(2)) * (1 + c(0));
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_pentahedron_15>::computeDNDS(const vector_type & c,
                                                               matrix_type & dnds) {
   //ddx
   dnds(0, 0) =  0.5 * c(1) * (2 * c(0) - 2 * c(1) + 1);
   dnds(0, 1) =  0.5 * c(2) * (2 * c(0) - 2 * c(2) + 1);
   dnds(0, 2) = -0.5 * (2 * c(0) + 2 * c(1) + 2 * c(2) - 1) * (c(1) + c(2) -1);
   dnds(0, 3) =  0.5 * c(1) * (2 * c(0) + 2 * c(1) - 1);
   dnds(0, 4) =  0.5 * c(2) * (2 * c(0) + 2 * c(2) - 1);
   dnds(0, 5) = -0.5 * (c(1) + c(2) - 1) * (2 * c(0) - 2 * c(1) - 2 * c(2) + 1);
   dnds(0, 6) = -2.0 * c(1) * c(2);
   dnds(0, 7) =  2.0 * c(2) * (c(1) + c(2) - 1);
   dnds(0, 8) =  2.0 * c(1) * (c(1) + c(2) - 1);
   dnds(0, 9) = -2.0 * c(0) * c(1);
   dnds(0,10) = -2.0 * c(0) * c(2);
   dnds(0,11) =  2.0 * c(0) * (c(1) + c(2) - 1);
   dnds(0,12) =  2.0 * c(1) * c(2);
   dnds(0,13) = -2.0 * c(2) * (c(1) + c(2) - 1);
   dnds(0,14) = -2.0 * c(1) * (c(1) + c(2) - 1);
 
   //ddy
   dnds(1, 0) = -0.5 * (c(0) - 1) * (4 * c(1) - c(0) - 2);
   dnds(1, 1) =  0.0;
   dnds(1, 2) = -0.5 * (c(0) - 1) * (4 * c(1) + c(0) + 2 * (2 * c(2) - 1));
   dnds(1, 3) =  0.5 * (c(0) + 1) * (4 * c(1) + c(0) - 2);
   dnds(1, 4) =  0.0;
   dnds(1, 5) =  0.5 * (c(0) + 1) * (4 * c(1) - c(0) + 2 * (2 * c(2) - 1));
   dnds(1, 6) = -2.0 * (c(0) - 1) * c(2);
   dnds(1, 7) =  2.0 * c(2) * (c(0) - 1);
   dnds(1, 8) =  2.0 * (2 * c(1) + c(2) - 1) * (c(0) - 1);
   dnds(1, 9) = -(c(0) * c(0) - 1);
   dnds(1,10) =  0.0;
   dnds(1,11) =  (c(0) * c(0) - 1);
   dnds(1,12) =  2.0 * c(2) * (c(0) + 1);
   dnds(1,13) = -2.0 * c(2) * (c(0) + 1);
   dnds(1,14) = -2.0 * (2 * c(1) + c(2) - 1) * (c(0) + 1);
 
   //ddz
   dnds(2, 0) =  0.0;
   dnds(2, 1) = -0.5 * (c(0) - 1) * (4 * c(2) - c(0) - 2);
   dnds(2, 2) = -0.5 * (c(0) - 1) * (4 * c(2) + c(0) + 2 * (2 * c(1) - 1));
   dnds(2, 3) =  0.0;
   dnds(2, 4) =  0.5 * (c(0) + 1) * (4 * c(2) + c(0) - 2);
   dnds(2, 5) =  0.5 * (c(0) + 1) * (4 * c(2) - c(0) + 2 * (2 * c(1) - 1));
   dnds(2, 6) = -2.0 * (c(0) - 1) * c(1);
   dnds(2, 7) =  2.0 * (c(0) - 1) * (2 * c(2) + c(1) - 1);
   dnds(2, 8) =  2.0 * c(1) * (c(0) - 1);
   dnds(2, 9) =  0.0;
   dnds(2,10) = -(c(0) * c(0) - 1);
   dnds(2,11) =  (c(0) * c(0) - 1);
   dnds(2,12) =  2.0 * (c(0) + 1) * c(1);
   dnds(2,13) = -2.0 * (c(0) + 1) * (2 * c(2) + c(1) - 1);
   dnds(2,14) = -2.0 * (c(0) + 1) * c(1);
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline Real
 GeometricalElement<_gt_pentahedron_15>::getInradius(const Matrix<Real> & coord) {
   return GeometricalElement<_gt_pentahedron_6>::getInradius(coord);
 }
diff --git a/src/fe_engine/element_classes/element_class_pentahedron_6_inline_impl.cc b/src/fe_engine/element_classes/element_class_pentahedron_6_inline_impl.cc
index 018f4d3a5..806c0370b 100644
--- a/src/fe_engine/element_classes/element_class_pentahedron_6_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_pentahedron_6_inline_impl.cc
@@ -1,133 +1,128 @@
 /**
  * @file   element_class_pentahedron_6_inline_impl.cc
  *
  * @author Marion Estelle Chambart <mchambart@stucky.ch>
  * @author Mauro Corrado <mauro.corrado@epfl.ch>
  * @author Thomas Menouillard <tmenouillard@stucky.ch>
  *
  * @date creation: Mon Mar 14 2011
  * @date last modification: Tue Sep 01 2015
  *
  * @brief  Specialization of the element_class class for the type _pentahedron_6
  *
  * @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
  *
  * @verbatim
              /z
              |
              |
              |  1
              | /|\
              |/ | \
              /  |  \
             /   |   \
            /    |    \
            4    2-----0
           | \  /      /
           |  \/      /
           |   \     /----------/y
           | /  \   /
           |/    \ /
           5---.--3
          /
         /
        /
       \x
        x   y    z
 * N0  -1   1    0
 * N1  -1   0    1
 * N2  -1   0    0
 * N3   1   1    0
 * N4   1   0    1
 * N5   1   0    0
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_pentahedron_6, _gt_pentahedron_6,
                                      _itp_lagrange_pentahedron_6, _ek_regular,
                                      3, _git_pentahedron, 1);
 
-template <> struct GeometricalShape<_gt_pentahedron_6> {
-  static const GeometricalShapeType shape = _gst_prism;
-};
-// AKANTU_DEFINE_SHAPE(_gt_pentahedron_6, _gst_prism);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void InterpolationElement<_itp_lagrange_pentahedron_6>::computeShapes(
     const vector_type & c, vector_type & N) {
   /// Natural coordinates
   N(0) = 0.5 * c(1) * (1 - c(0));              // N1(q)
   N(1) = 0.5 * c(2) * (1 - c(0));              // N2(q)
   N(2) = 0.5 * (1 - c(1) - c(2)) * (1 - c(0)); // N3(q)
   N(3) = 0.5 * c(1) * (1 + c(0));              // N4(q)
   N(4) = 0.5 * c(2) * (1 + c(0));              // N5(q)
   N(5) = 0.5 * (1 - c(1) - c(2)) * (1 + c(0)); // N6(q)
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void InterpolationElement<_itp_lagrange_pentahedron_6>::computeDNDS(
     const vector_type & c, matrix_type & dnds) {
   dnds(0, 0) = -0.5 * c(1);
   dnds(0, 1) = -0.5 * c(2);
   dnds(0, 2) = -0.5 * (1 - c(1) - c(2));
   dnds(0, 3) = 0.5 * c(1);
   dnds(0, 4) = 0.5 * c(2);
   dnds(0, 5) = 0.5 * (1 - c(1) - c(2));
 
   dnds(1, 0) = 0.5 * (1 - c(0));
   dnds(1, 1) = 0.0;
   dnds(1, 2) = -0.5 * (1 - c(0));
   dnds(1, 3) = 0.5 * (1 + c(0));
   dnds(1, 4) = 0.0;
   dnds(1, 5) = -0.5 * (1 + c(0));
 
   dnds(2, 0) = 0.0;
   dnds(2, 1) = 0.5 * (1 - c(0));
   dnds(2, 2) = -0.5 * (1 - c(0));
   dnds(2, 3) = 0.0;
   dnds(2, 4) = 0.5 * (1 + c(0));
   dnds(2, 5) = -0.5 * (1 + c(0));
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline Real
 GeometricalElement<_gt_pentahedron_6>::getInradius(const Matrix<Real> & coord) {
   Vector<Real> u0 = coord(0);
   Vector<Real> u1 = coord(1);
   Vector<Real> u2 = coord(2);
   Vector<Real> u3 = coord(3);
 
   Real a = u0.distance(u1);
   Real b = u1.distance(u2);
   Real c = u2.distance(u3);
   Real d = u3.distance(u0);
   Real s = (a + b + c) / 2;
   Real A = std::sqrt(s * (s - a) * (s - b) * (s - c));
   Real ra = 2 * s / A;
   Real p = std::min(ra, d);
 
   return p;
 }
diff --git a/src/fe_engine/element_classes/element_class_point_1_inline_impl.cc b/src/fe_engine/element_classes/element_class_point_1_inline_impl.cc
index 2bf14915c..ff0fbb514 100644
--- a/src/fe_engine/element_classes/element_class_point_1_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_point_1_inline_impl.cc
@@ -1,80 +1,79 @@
 /**
  * @file   element_class_point_1_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Specialization of the element_class class for the type _point_1
  *
  * @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
  *
  * @verbatim
       x
     (0)
  @endverbatim
  *
  * @subsection shapes Shape functions
  * @f{eqnarray*}{
  * N1 &=& 1
  * @f}
  *
  * @subsection quad_points Position of quadrature points
  * @f{eqnarray*}{
  * q_0 &=& 0
  * @f}
  */
 
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_point_1, _gt_point, _itp_lagrange_point_1,
                                      _ek_regular, 0, _git_point, 1);
-AKANTU_DEFINE_SHAPE(_gt_point, _gst_point);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void InterpolationElement<_itp_lagrange_point_1>::computeShapes(
     __attribute__((unused)) const vector_type & natural_coords,
     vector_type & N) {
   N(0) = 1; /// N1(q_0)
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void InterpolationElement<_itp_lagrange_point_1>::computeDNDS(
     __attribute__((unused)) const vector_type & natural_coords,
     __attribute__((unused)) matrix_type & dnds) {}
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void InterpolationElement<_itp_lagrange_point_1>::computeSpecialJacobian(
     __attribute__((unused)) const Matrix<Real> & J, Real & jac) {
   jac = 0.;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline Real
 GeometricalElement<_gt_point>::getInradius(__attribute__((unused))
                                            const Matrix<Real> & coord) {
   return 0.;
 }
diff --git a/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.cc b/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.cc
index 2e33b9542..6683e8a82 100644
--- a/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_quadrangle_4_inline_impl.cc
@@ -1,152 +1,150 @@
 /**
  * @file   element_class_quadrangle_4_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 13 2010
  * @date last modification: Mon Dec 08 2014
  *
  * @brief  Specialization of the element_class class for the type _quadrangle_4
  *
  * @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
  *
  * @verbatim
          \eta
  	  ^
  (-1,1)   |   (1,1)
      x---------x
      |    |    |
      |    |    |
    --|---------|----->  \xi
      |    |    |
      |    |    |
      x---------x
  (-1,-1)  |   (1,-1)
  @endverbatim
  *
  * @subsection shapes Shape functions
  * @f[
  * \begin{array}{lll}
  * N1 = (1 - \xi) (1 - \eta) / 4
  *       & \frac{\partial N1}{\partial \xi}  = - (1 - \eta) / 4
  *       & \frac{\partial N1}{\partial \eta} = - (1 - \xi) / 4 \\
  * N2 = (1 + \xi) (1 - \eta) / 4 \\
  *       & \frac{\partial N2}{\partial \xi}  = (1 - \eta) / 4
  *       & \frac{\partial N2}{\partial \eta} = - (1 + \xi) / 4 \\
  * N3 = (1 + \xi) (1 + \eta) / 4 \\
  *       & \frac{\partial N3}{\partial \xi}  = (1 + \eta) / 4
  *       & \frac{\partial N3}{\partial \eta} = (1 + \xi) / 4 \\
  * N4 = (1 - \xi) (1 + \eta) / 4
  *       & \frac{\partial N4}{\partial \xi}  = - (1 + \eta) / 4
  *       & \frac{\partial N4}{\partial \eta} = (1 - \xi) / 4 \\
  * \end{array}
  * @f]
  *
  * @subsection quad_points Position of quadrature points
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 0 \qquad  \eta_{q0} = 0
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_quadrangle_4, _gt_quadrangle_4, _itp_lagrange_quadrangle_4, _ek_regular, 2,
 				     _git_segment, 2);
 
-AKANTU_DEFINE_SHAPE(_gt_quadrangle_4, _gst_square);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_quadrangle_4>::computeShapes(const vector_type & c,
                                                                 vector_type & N) {
   N(0) = 1./4. * (1. - c(0)) * (1. - c(1)); /// N1(q_0)
   N(1) = 1./4. * (1. + c(0)) * (1. - c(1)); /// N2(q_0)
   N(2) = 1./4. * (1. + c(0)) * (1. + c(1)); /// N3(q_0)
   N(3) = 1./4. * (1. - c(0)) * (1. + c(1)); /// N4(q_0)
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_quadrangle_4>::computeDNDS(const vector_type & c,
                                                               matrix_type & dnds) {
   /**
    * @f[
    * dnds = \left(
    *          \begin{array}{cccc}
    *            \frac{\partial N1}{\partial \xi}  & \frac{\partial N2}{\partial \xi}
    *               & \frac{\partial N3}{\partial \xi}  & \frac{\partial N4}{\partial \xi}\\
    *            \frac{\partial N1}{\partial \eta} & \frac{\partial N2}{\partial \eta}
    *               & \frac{\partial N3}{\partial \eta} & \frac{\partial N4}{\partial \eta}
    *          \end{array}
    *        \right)
    * @f]
    */
 
   dnds(0, 0) = - 1./4. * (1. - c(1));
   dnds(0, 1) =   1./4. * (1. - c(1));
   dnds(0, 2) =   1./4. * (1. + c(1));
   dnds(0, 3) = - 1./4. * (1. + c(1));
 
   dnds(1, 0) = - 1./4. * (1. - c(0));
   dnds(1, 1) = - 1./4. * (1. + c(0));
   dnds(1, 2) =   1./4. * (1. + c(0));
   dnds(1, 3) =   1./4. * (1. - c(0));
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 InterpolationElement<_itp_lagrange_quadrangle_4>::computeSpecialJacobian(const Matrix<Real> & J,
                                                                          Real & jac){
   Vector<Real> vprod(J.cols());
   Matrix<Real> Jt(J.transpose(), true);
   vprod.crossProduct(Jt(0), Jt(1));
   jac = vprod.norm();
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline Real
 GeometricalElement<_gt_quadrangle_4>::getInradius(const Matrix<Real> & coord) {
   Vector<Real> u0 = coord(0);
   Vector<Real> u1 = coord(1);
   Vector<Real> u2 = coord(2);
   Vector<Real> u3 = coord(3);
   Real a = u0.distance(u1);
   Real b = u1.distance(u2);
   Real c = u2.distance(u3);
   Real d = u3.distance(u0);
 
   // Real septimetre = (a + b + c + d) / 2.;
 
   // Real p = Math::distance_2d(coord + 0, coord + 4);
   // Real q = Math::distance_2d(coord + 2, coord + 6);
 
   // Real area = sqrt(4*(p*p * q*q) - (a*a + b*b + c*c + d*d)*(a*a + c*c - b*b - d*d)) / 4.;
   // Real h = sqrt(area);  // to get a length
   // Real h = area / septimetre;  // formula of inradius for circumscritable quadrelateral
   Real h = std::min(a, std::min(b, std::min(c, d)));
 
   return h;
 }
diff --git a/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.cc b/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.cc
index 990d8bc3f..df4f635ca 100644
--- a/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_quadrangle_8_inline_impl.cc
@@ -1,188 +1,186 @@
 /**
  * @file   element_class_quadrangle_8_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed May 18 2011
  * @date last modification: Tue Apr 07 2015
  *
  * @brief  Specialization of the ElementClass for the _quadrangle_8
  *
  * @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
  *
  * @verbatim
               \eta
                ^
                |
    (-1,1)    (0,1)   (1,1)
        x-------x-------x
        |       |       |
        |       |       |
        |       |       |
  (-1,0)|       |       |(1,0)
    ----x---------------X----->  \xi
        |       |       |
        |       |       |
        |       |       |
        |       |       |
        x-------x-------x
    (-1,-1)   (0,-1)  (1,-1)
                |
  @endverbatim
  *
  * @subsection shapes Shape functions
  * @f[
  * \begin{array}{lll}
  * N1 = (1 - \xi) (1 - \eta)(- 1 - \xi - \eta) / 4
  *       & \frac{\partial N1}{\partial \xi}  = (1 - \eta)(2 \xi + \eta) / 4
  *       & \frac{\partial N1}{\partial \eta} = (1 - \xi)(\xi + 2 \eta) / 4 \\
  * N2 = (1 + \xi) (1 - \eta)(- 1 + \xi - \eta) / 4 \\
  *       & \frac{\partial N2}{\partial \xi}  = (1 - \eta)(2 \xi - \eta) / 4
  *       & \frac{\partial N2}{\partial \eta} = - (1 + \xi)(\xi - 2 \eta) / 4 \\
  * N3 = (1 + \xi) (1 + \eta)(- 1 + \xi + \eta) / 4 \\
  *       & \frac{\partial N3}{\partial \xi}  = (1 + \eta)(2 \xi + \eta) / 4
  *       & \frac{\partial N3}{\partial \eta} = (1 + \xi)(\xi + 2 \eta) / 4 \\
  * N4 = (1 - \xi) (1 + \eta)(- 1 - \xi + \eta) / 4
  *       & \frac{\partial N4}{\partial \xi}  = (1 + \eta)(2 \xi - \eta) / 4
  *       & \frac{\partial N4}{\partial \eta} = - (1 - \xi)(\xi - 2 \eta) / 4 \\
  * N5 = (1 - \xi^2) (1 - \eta) / 2
  *       & \frac{\partial N1}{\partial \xi}  = - \xi (1 - \eta)
  *       & \frac{\partial N1}{\partial \eta} = - (1 - \xi^2) / 2  \\
  * N6 = (1 + \xi) (1 - \eta^2) / 2 \\
  *       & \frac{\partial N2}{\partial \xi}  = (1 - \eta^2) / 2
  *       & \frac{\partial N2}{\partial \eta} = - \eta (1 + \xi) \\
  * N7 = (1 - \xi^2) (1 + \eta) / 2 \\
  *       & \frac{\partial N3}{\partial \xi}  = - \xi (1 + \eta)
  *       & \frac{\partial N3}{\partial \eta} = (1 - \xi^2) / 2 \\
  * N8 = (1 - \xi) (1 - \eta^2) / 2
  *       & \frac{\partial N4}{\partial \xi}  = - (1 - \eta^2) / 2
  *       & \frac{\partial N4}{\partial \eta} = - \eta (1 - \xi) \\
  * \end{array}
  * @f]
  *
  * @subsection quad_points Position of quadrature points
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 0 \qquad  \eta_{q0} = 0
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_quadrangle_8, _gt_quadrangle_8,
                                      _itp_serendip_quadrangle_8, _ek_regular, 2,
                                      _git_segment, 3);
 
-AKANTU_DEFINE_SHAPE(_gt_quadrangle_8, _gst_square);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void InterpolationElement<_itp_serendip_quadrangle_8>::computeShapes(
     const vector_type & c, vector_type & N) {
 
   /// Natural coordinates
   const Real xi = c(0);
   const Real eta = c(1);
 
   N(0) = .25 * (1 - xi) * (1 - eta) * (-1 - xi - eta);
   N(1) = .25 * (1 + xi) * (1 - eta) * (-1 + xi - eta);
   N(2) = .25 * (1 + xi) * (1 + eta) * (-1 + xi + eta);
   N(3) = .25 * (1 - xi) * (1 + eta) * (-1 - xi + eta);
   N(4) = .5 * (1 - xi * xi) * (1 - eta);
   N(5) = .5 * (1 + xi) * (1 - eta * eta);
   N(6) = .5 * (1 - xi * xi) * (1 + eta);
   N(7) = .5 * (1 - xi) * (1 - eta * eta);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void InterpolationElement<_itp_serendip_quadrangle_8>::computeDNDS(
     const vector_type & c, matrix_type & dnds) {
 
   const Real xi = c(0);
   const Real eta = c(1);
 
   /// dN/dxi
   dnds(0, 0) = .25 * (1 - eta) * (2 * xi + eta);
   dnds(0, 1) = .25 * (1 - eta) * (2 * xi - eta);
   dnds(0, 2) = .25 * (1 + eta) * (2 * xi + eta);
   dnds(0, 3) = .25 * (1 + eta) * (2 * xi - eta);
   dnds(0, 4) = -xi * (1 - eta);
   dnds(0, 5) = .5 * (1 - eta * eta);
   dnds(0, 6) = -xi * (1 + eta);
   dnds(0, 7) = -.5 * (1 - eta * eta);
 
   /// dN/deta
   dnds(1, 0) = .25 * (1 - xi) * (2 * eta + xi);
   dnds(1, 1) = .25 * (1 + xi) * (2 * eta - xi);
   dnds(1, 2) = .25 * (1 + xi) * (2 * eta + xi);
   dnds(1, 3) = .25 * (1 - xi) * (2 * eta - xi);
   dnds(1, 4) = -.5 * (1 - xi * xi);
   dnds(1, 5) = -eta * (1 + xi);
   dnds(1, 6) = .5 * (1 - xi * xi);
   dnds(1, 7) = -eta * (1 - xi);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline Real
 GeometricalElement<_gt_quadrangle_8>::getInradius(const Matrix<Real> & coord) {
   Real a, b, h;
 
   Vector<Real> u0 = coord(0);
   Vector<Real> u1 = coord(1);
   Vector<Real> u2 = coord(2);
   Vector<Real> u3 = coord(3);
   Vector<Real> u4 = coord(4);
   Vector<Real> u5 = coord(5);
   Vector<Real> u6 = coord(6);
   Vector<Real> u7 = coord(7);
 
   a = u0.distance(u4);
   b = u4.distance(u1);
   h = std::min(a, b);
 
   a = u1.distance(u5);
   b = u5.distance(u2);
   h = std::min(h, std::min(a, b));
 
   a = u2.distance(u6);
   b = u6.distance(u3);
   h = std::min(h, std::min(a, b));
 
   a = u3.distance(u7);
   b = u7.distance(u0);
   h = std::min(h, std::min(a, b));
 
   return h;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 InterpolationElement<_itp_serendip_quadrangle_8>::computeSpecialJacobian(
     const Matrix<Real> & J, Real & jac) {
   Vector<Real> vprod(J.cols());
   Matrix<Real> Jt(J.transpose(), true);
   vprod.crossProduct(Jt(0), Jt(1));
   jac = vprod.norm();
 }
diff --git a/src/fe_engine/element_classes/element_class_segment_2_inline_impl.cc b/src/fe_engine/element_classes/element_class_segment_2_inline_impl.cc
index 0ea08bf68..0ac10eca0 100644
--- a/src/fe_engine/element_classes/element_class_segment_2_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_segment_2_inline_impl.cc
@@ -1,107 +1,105 @@
 /**
  * @file   element_class_segment_2_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Specialization of the element_class class for the type _segment_2
  *
  * @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
  *
  * @verbatim
               q
    --x--------|--------x---> x
     -1        0        1
  @endverbatim
  *
  * @subsection shapes Shape functions
  * @f{eqnarray*}{
  * w_1(x) &=& 1/2(1 - x) \\
  * w_2(x) &=& 1/2(1 + x)
  * @f}
  *
  * @subsection quad_points Position of quadrature points
  * @f{eqnarray*}{
  * x_{q}  &=& 0
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_segment_2, _gt_segment_2,
                                      _itp_lagrange_segment_2, _ek_regular, 1,
                                      _git_segment, 1);
 
-AKANTU_DEFINE_SHAPE(_gt_segment_2, _gst_square);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void InterpolationElement<_itp_lagrange_segment_2>::computeShapes(
     const vector_type & natural_coords, vector_type & N) {
 
   /// natural coordinate
   Real c = natural_coords(0);
   /// shape functions
   N(0) = 0.5 * (1 - c);
   N(1) = 0.5 * (1 + c);
 }
 /* -------------------------------------------------------------------------- */
 
 template <>
 template <class vector_type, class matrix_type>
 inline void InterpolationElement<_itp_lagrange_segment_2>::computeDNDS(
     __attribute__((unused)) const vector_type & natural_coords,
     matrix_type & dnds) {
 
   /// dN1/de
   dnds(0, 0) = -.5;
   /// dN2/de
   dnds(0, 1) = .5;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 InterpolationElement<_itp_lagrange_segment_2>::computeSpecialJacobian(
     const Matrix<Real> & dxds, Real & jac) {
   jac = dxds.norm<L_2>();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline Real
 GeometricalElement<_gt_segment_2>::getInradius(const Matrix<Real> & coord) {
   return std::abs(coord(0, 0) - coord(0, 1));
 }
 
 // /* --------------------------------------------------------------------------
 // */
 // template<> inline bool ElementClass<_segment_2>::contains(const Vector<Real>
 // & natural_coords) {
 //   if (natural_coords(0) < -1.) return false;
 //   if (natural_coords(0) > 1.) return false;
 //   return true;
 // }
 
 /* -------------------------------------------------------------------------- */
diff --git a/src/fe_engine/element_classes/element_class_segment_3_inline_impl.cc b/src/fe_engine/element_classes/element_class_segment_3_inline_impl.cc
index 4d40de751..3fa83ddc8 100644
--- a/src/fe_engine/element_classes/element_class_segment_3_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_segment_3_inline_impl.cc
@@ -1,108 +1,106 @@
 /**
  * @file   element_class_segment_3_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Specialization of the element_class class for the type _segment_3
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  * @section DESCRIPTION
  *
  * @verbatim
          -1         0         1
   	 -----x---------x---------x-----> x
 	      1         3         2
  @endverbatim
  *
  * @subsection coords Nodes coordinates
  *
  * @f[
  * \begin{array}{lll}
  *   x_{1}  = -1   &  x_{2} = 1 & x_{3} = 0
  * \end{array}
  * @f]
  *
  * @subsection shapes Shape functions
  * @f[
  * \begin{array}{ll}
  *   w_1(x) = \frac{x}{2}(x - 1) & w'_1(x) = x - \frac{1}{2}\\
  *   w_2(x) = \frac{x}{2}(x + 1) & w'_2(x) = x + \frac{1}{2}\\
  *   w_3(x) =  1-x^2 & w'_3(x) = -2x
  * \end{array}
  * @f]
  *
  * @subsection quad_points Position of quadrature points
  * @f[
  * \begin{array}{ll}
  * x_{q1}  = -1/\sqrt{3} & x_{q2} = 1/\sqrt{3}
  * \end{array}
  * @f]
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_segment_3, _gt_segment_3, _itp_lagrange_segment_3, _ek_regular, 1,
                                      _git_segment, 2);
 
-AKANTU_DEFINE_SHAPE(_gt_segment_3, _gst_square);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_segment_3>::computeShapes(const vector_type & natural_coords,
                                                              vector_type & N) {
 
   Real c = natural_coords(0);
   N(0) = (c - 1) * c / 2;
   N(1) = (c + 1) * c / 2;
   N(2) = 1 - c * c;
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_segment_3>::computeDNDS(const vector_type & natural_coords,
                                                            matrix_type & dnds){
 
   Real c = natural_coords(0);
   dnds(0, 0)  = c - .5;
   dnds(0, 1)  = c + .5;
   dnds(0, 2)  = -2 * c;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 InterpolationElement<_itp_lagrange_segment_3>::computeSpecialJacobian(const Matrix<Real> & dxds,
 								      Real & jac) {
   jac = Math::norm2(dxds.storage());
 }
 
 /* -------------------------------------------------------------------------- */
 template<> inline Real
 GeometricalElement<_gt_segment_3>::getInradius(const Matrix<Real> & coord) {
   Real dist1 = std::abs(coord(0, 0) - coord(0, 1));
   Real dist2 = std::abs(coord(0, 1) - coord(0, 2));
   return std::min(dist1, dist2);
 }
diff --git a/src/fe_engine/element_classes/element_class_tetrahedron_10_inline_impl.cc b/src/fe_engine/element_classes/element_class_tetrahedron_10_inline_impl.cc
index 7ea9c69cd..b585f209e 100644
--- a/src/fe_engine/element_classes/element_class_tetrahedron_10_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_tetrahedron_10_inline_impl.cc
@@ -1,265 +1,263 @@
 /**
  * @file   element_class_tetrahedron_10_inline_impl.cc
  *
  * @author Peter Spijker <peter.spijker@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Specialization of the element_class class for the type _tetrahedron_10
  *
  * @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
  *
  * @verbatim
  \zeta
  ^
  |
  (0,0,1)
  x
  |` .
  |  `  .
  |    `   .
  |      `    .  (0,0.5,0.5)
  |        `    x.
  |     q4 o `      .                   \eta
  |            `       .             -,
  (0,0,0.5) x             ` x (0.5,0,0.5)  -
  |                `        x-(0,1,0)
  |              q3 o`   -   '
  |       (0,0.5,0)  - `      '
  |             x-       `     x (0.5,0.5,0)
  |     q1 o -         o q2`    '
  |      -                   `   '
  |  -                         `  '
  x---------------x--------------` x-----> \xi
  (0,0,0)        (0.5,0,0)        (1,0,0)
  @endverbatim
  *
  * @subsection coords Nodes coordinates
  *
  * @f[
  * \begin{array}{lll}
  *   \xi_{0}  = 0   &  \eta_{0}  = 0   &  \zeta_{0}  = 0   \\
  *   \xi_{1}  = 1   &  \eta_{1}  = 0   &  \zeta_{1}  = 0   \\
  *   \xi_{2}  = 0   &  \eta_{2}  = 1   &  \zeta_{2}  = 0   \\
  *   \xi_{3}  = 0   &  \eta_{3}  = 0   &  \zeta_{3}  = 1   \\
  *   \xi_{4}  = 1/2 &  \eta_{4}  = 0   &  \zeta_{4}  = 0   \\
  *   \xi_{5}  = 1/2 &  \eta_{5}  = 1/2 &  \zeta_{5}  = 0   \\
  *   \xi_{6}  = 0   &  \eta_{6}  = 1/2 &  \zeta_{6}  = 0   \\
  *   \xi_{7}  = 0   &  \eta_{7}  = 0   &  \zeta_{7}  = 1/2 \\
  *   \xi_{8}  = 1/2 &  \eta_{8}  = 0   &  \zeta_{8}  = 1/2 \\
  *   \xi_{9}  = 0   &  \eta_{9}  = 1/2 &  \zeta_{9}  = 1/2
  * \end{array}
  * @f]
  *
  * @subsection shapes Shape functions
  * @f[
  * \begin{array}{llll}
  *     N1  = (1 - \xi - \eta - \zeta) (1 - 2 \xi - 2 \eta - 2 \zeta)
  *           & \frac{\partial N1}{\partial \xi}    = 4 \xi + 4 \eta + 4 \zeta - 3
  *           & \frac{\partial N1}{\partial \eta}   = 4 \xi + 4 \eta + 4 \zeta - 3
  *           & \frac{\partial N1}{\partial \zeta}  = 4 \xi + 4 \eta + 4 \zeta - 3 \\
  *     N2  = \xi (2 \xi - 1)
  *           & \frac{\partial N2}{\partial \xi}    = 4 \xi - 1
  *           & \frac{\partial N2}{\partial \eta}   = 0
  *           & \frac{\partial N2}{\partial \zeta}  = 0 \\
  *     N3  = \eta (2 \eta - 1)
  *           & \frac{\partial N3}{\partial \xi}    = 0
  *           & \frac{\partial N3}{\partial \eta}   = 4 \eta - 1
  *           & \frac{\partial N3}{\partial \zeta}  = 0 \\
  *     N4  = \zeta (2 \zeta - 1)
  *           & \frac{\partial N4}{\partial \xi}    = 0
  *           & \frac{\partial N4}{\partial \eta}   = 0
  *           & \frac{\partial N4}{\partial \zeta}  = 4 \zeta - 1 \\
  *     N5  = 4 \xi (1 - \xi - \eta - \zeta)
  *           & \frac{\partial N5}{\partial \xi}    = 4 - 8 \xi - 4 \eta - 4 \zeta
  *           & \frac{\partial N5}{\partial \eta}   = -4 \xi
  *           & \frac{\partial N5}{\partial \zeta}  = -4 \xi \\
  *     N6  = 4 \xi \eta
  *           & \frac{\partial N6}{\partial \xi}    = 4 \eta
  *           & \frac{\partial N6}{\partial \eta}   = 4 \xi
  *           & \frac{\partial N6}{\partial \zeta}  = 0 \\
  *     N7  = 4 \eta (1 - \xi - \eta - \zeta)
  *           & \frac{\partial N7}{\partial \xi}    = -4 \eta
  *           & \frac{\partial N7}{\partial \eta}   = 4 - 4 \xi - 8 \eta - 4 \zeta
  *           & \frac{\partial N7}{\partial \zeta}  = -4 \eta \\
  *     N8  = 4 \zeta (1 - \xi - \eta - \zeta)
  *           & \frac{\partial N8}{\partial \xi}    = -4 \zeta
  *           & \frac{\partial N8}{\partial \eta}   = -4 \zeta
  *           & \frac{\partial N8}{\partial \zeta}  = 4 - 4 \xi - 4 \eta - 8 \zeta \\
  *     N9  = 4 \zeta \xi
  *           & \frac{\partial N9}{\partial \xi}    = 4 \zeta
  *           & \frac{\partial N9}{\partial \eta}   = 0
  *           & \frac{\partial N9}{\partial \zeta}  = 4 \xi \\
  *     N10 = 4 \eta \zeta
  *           & \frac{\partial N10}{\partial \xi}   = 0
  *           & \frac{\partial N10}{\partial \eta}  = 4 \zeta
  *           & \frac{\partial N10}{\partial \zeta} = 4 \eta \\
  * \end{array}
  * @f]
  *
  * @subsection quad_points Position of quadrature points
  * @f[
  * a = \frac{5 - \sqrt{5}}{20}\\
  * b = \frac{5 + 3 \sqrt{5}}{20}
  * \begin{array}{lll}
  *   \xi_{q_0}  = a   &  \eta_{q_0}  = a   &  \zeta_{q_0}  = a \\
  *   \xi_{q_1}  = b   &  \eta_{q_1}  = a   &  \zeta_{q_1}  = a \\
  *   \xi_{q_2}  = a   &  \eta_{q_2}  = b   &  \zeta_{q_2}  = a \\
  *   \xi_{q_3}  = a   &  \eta_{q_3}  = a   &  \zeta_{q_3}  = b
  * \end{array}
  * @f]
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_tetrahedron_10, _gt_tetrahedron_10, _itp_lagrange_tetrahedron_10, _ek_regular, 3,
 				     _git_tetrahedron, 2);
 
-AKANTU_DEFINE_SHAPE(_gt_tetrahedron_10, _gst_triangle);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_tetrahedron_10>::computeShapes(const vector_type & natural_coords,
                                                                   vector_type & N) {
   /// Natural coordinates
   Real xi = natural_coords(0);
   Real eta = natural_coords(1);
   Real zeta = natural_coords(2);
   Real sum = xi + eta + zeta;
   Real c0  = 1 - sum;
   Real c1  = 1 - 2*sum;
   Real c2  = 2*xi - 1;
   Real c3  = 2*eta - 1;
   Real c4  = 2*zeta - 1;
 
   /// Shape functions
   N(0) = c0  * c1;
   N(1) = xi  * c2;
   N(2) = eta  * c3;
   N(3) = zeta * c4;
   N(4) = 4 * xi  * c0;
   N(5) = 4 * xi * eta;
   N(6) = 4 * eta * c0;
   N(7) = 4 * zeta * c0;
   N(8) = 4 * xi * zeta;
   N(9) = 4 * eta * zeta;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_tetrahedron_10>::computeDNDS(const vector_type & natural_coords,
                                                                 matrix_type & dnds) {
   /**
    * @f[
    * dnds = \left(
    *          \begin{array}{cccccccccc}
    *            \frac{\partial N1}{\partial \xi}   & \frac{\partial N2}{\partial \xi}
    *          & \frac{\partial N3}{\partial \xi}   & \frac{\partial N4}{\partial \xi}
    *          & \frac{\partial N5}{\partial \xi}   & \frac{\partial N6}{\partial \xi}
    *          & \frac{\partial N7}{\partial \xi}   & \frac{\partial N8}{\partial \xi}
    *          & \frac{\partial N9}{\partial \xi}   & \frac{\partial N10}{\partial \xi} \\
    *            \frac{\partial N1}{\partial \eta}  & \frac{\partial N2}{\partial \eta}
    *          & \frac{\partial N3}{\partial \eta}  & \frac{\partial N4}{\partial \eta}
    *          & \frac{\partial N5}{\partial \eta}  & \frac{\partial N6}{\partial \eta}
    *          & \frac{\partial N7}{\partial \eta}  & \frac{\partial N8}{\partial \eta}
    *          & \frac{\partial N9}{\partial \eta}  & \frac{\partial N10}{\partial \eta} \\
    *            \frac{\partial N1}{\partial \zeta} & \frac{\partial N2}{\partial \zeta}
    *          & \frac{\partial N3}{\partial \zeta} & \frac{\partial N4}{\partial \zeta}
    *          & \frac{\partial N5}{\partial \zeta} & \frac{\partial N6}{\partial \zeta}
    *          & \frac{\partial N7}{\partial \zeta} & \frac{\partial N8}{\partial \zeta}
    *          & \frac{\partial N9}{\partial \zeta} & \frac{\partial N10}{\partial \zeta}
    *          \end{array}
    *        \right)
    * @f]
    */
 
   /// Natural coordinates
   Real xi   = natural_coords(0);
   Real eta  = natural_coords(1);
   Real zeta = natural_coords(2);
   Real sum = xi + eta + zeta;
 
   /// \frac{\partial N_i}{\partial \xi}
   dnds(0, 0) =  4 * sum - 3;
   dnds(0, 1) =  4 * xi - 1;
   dnds(0, 2) =  0;
   dnds(0, 3) =  0;
   dnds(0, 4) =  4 * (1 - sum - xi);
   dnds(0, 5) =  4 * eta;
   dnds(0, 6) = -4 * eta;
   dnds(0, 7) = -4 * zeta;
   dnds(0, 8) =  4 * zeta;
   dnds(0, 9) =  0;
 
   /// \frac{\partial N_i}{\partial \eta}
   dnds(1, 0) =  4 * sum - 3;
   dnds(1, 1) =  0;
   dnds(1, 2) =  4 * eta - 1;
   dnds(1, 3) =  0;
   dnds(1, 4) = -4 * xi;
   dnds(1, 5) =  4 * xi;
   dnds(1, 6) =  4 * (1 - sum - eta);
   dnds(1, 7) = -4 * zeta;
   dnds(1, 8) =  0;
   dnds(1, 9) =  4 * zeta;
 
   /// \frac{\partial N_i}{\partial \zeta}
   dnds(2, 0) =  4 * sum - 3;
   dnds(2, 1) =  0;
   dnds(2, 2) =  0;
   dnds(2, 3) =  4 * zeta - 1;
   dnds(2, 4) = -4 * xi;
   dnds(2, 5) =  0;
   dnds(2, 6) = -4 * eta;
   dnds(2, 7) =  4 * (1 - sum - zeta);
   dnds(2, 8) =  4 * xi;
   dnds(2, 9) =  4 * eta;
 
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline Real
 GeometricalElement<_gt_tetrahedron_10>::getInradius(const Matrix<Real> & coord) {
   // Only take the four corner tetrahedra
   UInt tetrahedra[4][4] = {
     {0, 4, 6, 7},
     {4, 1, 5, 8},
     {6, 5, 2, 9},
     {7, 8, 9, 3}
   };
 
   Real inradius = std::numeric_limits<Real>::max();
   for (UInt t = 0; t < 4; t++) {
     Real ir = Math::tetrahedron_inradius(coord(tetrahedra[t][0]).storage(),
 					 coord(tetrahedra[t][1]).storage(),
 					 coord(tetrahedra[t][2]).storage(),
 					 coord(tetrahedra[t][3]).storage());
     inradius = std::min(ir, inradius);
   }
 
   return inradius;
 }
diff --git a/src/fe_engine/element_classes/element_class_tetrahedron_4_inline_impl.cc b/src/fe_engine/element_classes/element_class_tetrahedron_4_inline_impl.cc
index 0c4fc13a5..262843501 100644
--- a/src/fe_engine/element_classes/element_class_tetrahedron_4_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_tetrahedron_4_inline_impl.cc
@@ -1,124 +1,123 @@
 /**
  * @file   element_class_tetrahedron_4_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Specialization of the element_class class for the type _tetrahedron_4
  *
  * @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
  *
  * @verbatim
    \eta
      ^
      |
      x (0,0,1,0)
      |`
      |  `  °             \xi
      |    `    °       -
      |      `       x (0,0,0,1)
      |      q.`   -  '
      |         -`     '
      |     -       `   '
      | -             `  '
      x------------------x-----> \zeta
  (1,0,0,0)           (0,1,0,0)
  @endverbatim
  *
  * @subsection shapes Shape functions
  * @f{eqnarray*}{
  * N1 &=& 1 - \xi - \eta - \zeta \\
  * N2 &=& \xi \\
  * N3 &=& \eta \\
  * N4 &=& \zeta
  * @f}
  *
  * @subsection quad_points Position of quadrature points
  * @f[
  * \xi_{q0} = 1/4 \qquad  \eta_{q0} = 1/4  \qquad  \zeta_{q0} = 1/4
  * @f]
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_tetrahedron_4, _gt_tetrahedron_4, _itp_lagrange_tetrahedron_4, _ek_regular, 3,
 				     _git_tetrahedron, 1);
 
-AKANTU_DEFINE_SHAPE(_gt_tetrahedron_4, _gst_triangle);
 
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_tetrahedron_4>::computeShapes(const vector_type & natural_coords,
 								 vector_type & N) {
 
   Real c0 = 1 - natural_coords(0) -  natural_coords(1) -  natural_coords(2);/// @f$ c2 = 1 - \xi - \eta - \zeta @f$
   Real c1 = natural_coords(1); /// @f$ c0 = \xi @f$
   Real c2 = natural_coords(2); /// @f$ c1 = \eta @f$
   Real c3 = natural_coords(0); /// @f$ c2 = \zeta @f$
 
   N(0) = c0;
   N(1) = c1;
   N(2) = c2;
   N(3) = c3;
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_tetrahedron_4>::computeDNDS(__attribute__ ((unused)) const vector_type & natural_coords,
 							       matrix_type & dnds) {
 
   /**
    * @f[
    * dnds = \left(
    *          \begin{array}{cccccc}
    *            \frac{\partial N1}{\partial \xi}   & \frac{\partial N2}{\partial \xi}
    *          & \frac{\partial N3}{\partial \xi}   & \frac{\partial N4}{\partial \xi} \\
    *            \frac{\partial N1}{\partial \eta}  & \frac{\partial N2}{\partial \eta}
    *          & \frac{\partial N3}{\partial \eta}  & \frac{\partial N4}{\partial \eta} \\
    *            \frac{\partial N1}{\partial \zeta} & \frac{\partial N2}{\partial \zeta}
    *          & \frac{\partial N3}{\partial \zeta} & \frac{\partial N4}{\partial \zeta}
    *          \end{array}
    *        \right)
    * @f]
    */
 
   dnds(0, 0) = -1.; dnds(0, 1) = 1.; dnds(0, 2) = 0.; dnds(0, 3) = 0.;
   dnds(1, 0) = -1.; dnds(1, 1) = 0.; dnds(1, 2) = 1.; dnds(1, 3) = 0.;
   dnds(2, 0) = -1.; dnds(2, 1) = 0.; dnds(2, 2) = 0.; dnds(2, 3) = 1.;
 
 
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline Real
 GeometricalElement<_gt_tetrahedron_4>::getInradius(const Matrix<Real> & coord) {
   return Math::tetrahedron_inradius(coord(0).storage(),
 				    coord(1).storage(),
 				    coord(2).storage(),
 				    coord(3).storage());
 }
diff --git a/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.cc b/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.cc
index bcb991f70..ce9633036 100644
--- a/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_triangle_3_inline_impl.cc
@@ -1,134 +1,132 @@
 /**
  * @file   element_class_triangle_3_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Specialization of the element_class class for the type _triangle_3
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  * @section DESCRIPTION
  *
  * @verbatim
        \eta
 	 ^
 	 |
 	 x (0,0,1)
 	 |`
 	 |  `
 	 |  q `
 	 |  °   `
 	 x--------x----->  \xi
     (1,0,0)      (0,1,0)
  @endverbatim
  *
  * @subsection shapes Shape functions
  * @f{eqnarray*}{
  * N1 &=& 1 - \xi - \eta \\
  * N2 &=& \xi \\
  * N3 &=& \eta
  * @f}
  *
  * @subsection quad_points Position of quadrature points
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 1/3 \qquad  \eta_{q0} = 1/3
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_triangle_3, _gt_triangle_3, _itp_lagrange_triangle_3, _ek_regular, 2,
 				     _git_triangle, 1);
 
-AKANTU_DEFINE_SHAPE(_gt_triangle_3, _gst_triangle);
-
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_triangle_3>::computeShapes(const vector_type & natural_coords,
                                                               vector_type & N) {
 
   /// Natural coordinates
   Real c0 = 1 - natural_coords(0) - natural_coords(1); /// @f$ c0 = 1 - \xi - \eta @f$
   Real c1 = natural_coords(0);                         /// @f$ c1 = \xi @f$
   Real c2 = natural_coords(1);                         /// @f$ c2 = \eta @f$
 
   N(0) = c0; /// N1(q_0)
   N(1) = c1; /// N2(q_0)
   N(2) = c2; /// N3(q_0)
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_triangle_3>::computeDNDS(__attribute__ ((unused)) const vector_type & natural_coords,
                                                             matrix_type & dnds) {
   /**
    * @f[
    * dnds = \left(
    *          \begin{array}{cccccc}
    *            \frac{\partial N1}{\partial \xi}  & \frac{\partial N2}{\partial \xi}  & \frac{\partial N3}{\partial \xi} \\
    *            \frac{\partial N1}{\partial \eta} & \frac{\partial N2}{\partial \eta} & \frac{\partial N3}{\partial \eta}
    *          \end{array}
    *        \right)
    * @f]
    */
   dnds(0, 0) = -1.; dnds(0, 1) =  1.; dnds(0, 2) =  0.;
   dnds(1, 0) = -1.; dnds(1, 1) =  0.; dnds(1, 2) =  1.;
 }
 
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 InterpolationElement<_itp_lagrange_triangle_3>::computeSpecialJacobian(const Matrix<Real> & J,
 								       Real & jac) {
   Vector<Real> vprod(J.cols());
   Matrix<Real> Jt(J.transpose(), true);
   vprod.crossProduct(Jt(0), Jt(1));
   jac = vprod.norm();
 }
 
 
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline Real
 GeometricalElement<_gt_triangle_3>::getInradius(const Matrix<Real> & coord) {
   return Math::triangle_inradius(coord(0).storage(),
 				 coord(1).storage(),
 				 coord(2).storage());
 }
 
 /* -------------------------------------------------------------------------- */
 // template<> inline bool ElementClass<_triangle_3>::contains(const Vector<Real> & natural_coords) {
 //   if (natural_coords[0] < 0.) return false;
 //   if (natural_coords[0] > 1.) return false;
 //   if (natural_coords[1] < 0.) return false;
 //   if (natural_coords[1] > 1.) return false;
 //   if (natural_coords[0]+natural_coords[1] > 1.) return false;
 //   return true;
 // }
 /* -------------------------------------------------------------------------- */
 
 
diff --git a/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.cc b/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.cc
index 4c9885366..f3ae35402 100644
--- a/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.cc
+++ b/src/fe_engine/element_classes/element_class_triangle_6_inline_impl.cc
@@ -1,206 +1,204 @@
 /**
  * @file   element_class_triangle_6_inline_impl.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jul 16 2010
  * @date last modification: Sun Oct 19 2014
  *
  * @brief  Specialization of the element_class class for the type _triangle_6
  *
  * @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
  *
  * @verbatim
 	    \eta
 	      ^
 	      |
 	      x 2
 	      | `
 	      |   `
 	      |  .  `
 	      |   q2  `
 	    5 x          x 4
  	      |           `
  	      |             `
  	      |  .q0     q1.  `
  	      |                 `
   	      x---------x---------x-----> \xi
 	      0         3         1
  @endverbatim
  *
  * @subsection coords Nodes coordinates
  *
  * @f[
  * \begin{array}{ll}
  *   \xi_{0}  = 0   &  \eta_{0} = 0   \\
  *   \xi_{1}  = 1   &  \eta_{1} = 0   \\
  *   \xi_{2}  = 0   &  \eta_{2} = 1   \\
  *   \xi_{3}  = 1/2 &  \eta_{3} = 0   \\
  *   \xi_{4}  = 1/2 &  \eta_{4} = 1/2 \\
  *   \xi_{5}  = 0   &  \eta_{5} = 1/2
  * \end{array}
  * @f]
  *
  * @subsection shapes Shape functions
  * @f[
  * \begin{array}{lll}
  * N1 = -(1 - \xi - \eta) (1 - 2 (1 - \xi - \eta))
  *       & \frac{\partial N1}{\partial \xi}  = 1 - 4(1 - \xi - \eta)
  *       & \frac{\partial N1}{\partial \eta} = 1 - 4(1 - \xi - \eta) \\
  * N2 = - \xi (1 - 2 \xi)
  *       & \frac{\partial N2}{\partial \xi}  = - 1 + 4 \xi
  *       & \frac{\partial N2}{\partial \eta} = 0 \\
  * N3 = - \eta (1 - 2 \eta)
  *       & \frac{\partial N3}{\partial \xi}  = 0
  *       & \frac{\partial N3}{\partial \eta} = - 1 + 4 \eta \\
  * N4 = 4 \xi (1 - \xi - \eta)
  *       & \frac{\partial N4}{\partial \xi}  = 4 (1 - 2 \xi - \eta)
  *       & \frac{\partial N4}{\partial \eta} = - 4 \xi \\
  * N5 = 4 \xi \eta
  *       & \frac{\partial N5}{\partial \xi}  = 4 \eta
  *       & \frac{\partial N5}{\partial \eta} = 4 \xi \\
  * N6 = 4 \eta (1 - \xi - \eta)
  *       & \frac{\partial N6}{\partial \xi}  = - 4 \eta
  *       & \frac{\partial N6}{\partial \eta} = 4 (1 - \xi - 2 \eta)
  * \end{array}
  * @f]
  *
  * @subsection quad_points Position of quadrature points
  * @f{eqnarray*}{
  * \xi_{q0}  &=& 1/6 \qquad  \eta_{q0} = 1/6 \\
  * \xi_{q1}  &=& 2/3 \qquad  \eta_{q1} = 1/6 \\
  * \xi_{q2}  &=& 1/6 \qquad  \eta_{q2} = 2/3
  * @f}
  */
 
 /* -------------------------------------------------------------------------- */
 AKANTU_DEFINE_ELEMENT_CLASS_PROPERTY(_triangle_6, _gt_triangle_6, _itp_lagrange_triangle_6, _ek_regular, 2,
 				     _git_triangle, 2);
 
-AKANTU_DEFINE_SHAPE(_gt_triangle_6, _gst_triangle);
-
 /* -------------------------------------------------------------------------- */
 
 template <>
 template <class vector_type>
 inline void
 InterpolationElement<_itp_lagrange_triangle_6>::computeShapes(const vector_type & natural_coords,
                                                               vector_type & N) {
   /// Natural coordinates
   Real c0 = 1 - natural_coords(0) - natural_coords(1); /// @f$ c0 = 1 - \xi - \eta @f$
   Real c1 = natural_coords(0);                         /// @f$ c1 = \xi @f$
   Real c2 = natural_coords(1);                         /// @f$ c2 = \eta @f$
 
   N(0) = c0 * (2 * c0 - 1.);
   N(1) = c1 * (2 * c1 - 1.);
   N(2) = c2 * (2 * c2 - 1.);
   N(3) = 4 * c0 * c1;
   N(4) = 4 * c1 * c2;
   N(5) = 4 * c2 * c0;
 }
 /* -------------------------------------------------------------------------- */
 template <>
 template <class vector_type, class matrix_type>
 inline void
 InterpolationElement<_itp_lagrange_triangle_6>::computeDNDS(const vector_type & natural_coords,
                                                             matrix_type & dnds) {
 
   /**
    * @f[
    * dnds =  \left(
    *   \begin{array}{cccccc}
    *       \frac{\partial N1}{\partial \xi}
    *     & \frac{\partial N2}{\partial \xi}
    *     & \frac{\partial N3}{\partial \xi}
    *     & \frac{\partial N4}{\partial \xi}
    *     & \frac{\partial N5}{\partial \xi}
    *     & \frac{\partial N6}{\partial \xi} \\
    *
    *       \frac{\partial N1}{\partial \eta}
    *     & \frac{\partial N2}{\partial \eta}
    *     & \frac{\partial N3}{\partial \eta}
    *     & \frac{\partial N4}{\partial \eta}
    *     & \frac{\partial N5}{\partial \eta}
    *     & \frac{\partial N6}{\partial \eta}
    *   \end{array}
    * \right)
    * @f]
    */
 
   /// Natural coordinates
   Real c0 = 1 - natural_coords(0) - natural_coords(1); /// @f$ c0 = 1 - \xi - \eta @f$
   Real c1 = natural_coords(0);                         /// @f$ c1 = \xi @f$
   Real c2 = natural_coords(1);                         /// @f$ c2 = \eta @f$
 
   dnds(0, 0)  = 1 - 4 * c0;
   dnds(0, 1)  = 4 * c1 - 1.;
   dnds(0, 2)  = 0.;
   dnds(0, 3)  = 4 * (c0 - c1);
   dnds(0, 4)  = 4 * c2;
   dnds(0, 5)  = - 4 * c2;
 
   dnds(1, 0) = 1 - 4 * c0;
   dnds(1, 1) = 0.;
   dnds(1, 2) = 4 * c2 - 1.;
   dnds(1, 3) = - 4 * c1;
   dnds(1, 4) = 4 * c1;
   dnds(1, 5) = 4 * (c0 - c2);
 }
 
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 InterpolationElement<_itp_lagrange_triangle_6>::computeSpecialJacobian( const Matrix<Real> & J,
 								       Real & jac){
   Vector<Real> vprod(J.cols());
   Matrix<Real> Jt(J.transpose(), true);
   vprod.crossProduct(Jt(0), Jt(1));
   jac = vprod.norm();
 }
 
 /* -------------------------------------------------------------------------- */
 template<>
 inline Real
 GeometricalElement<_gt_triangle_6>::getInradius(const Matrix<Real> & coord) {
   UInt triangles[4][3] = {
     {0, 3, 5},
     {3, 1, 4},
     {3, 4, 5},
     {5, 4, 2}
   };
 
   Real inradius = std::numeric_limits<Real>::max();
   for (UInt t = 0; t < 4; t++) {
     Real ir = Math::triangle_inradius(coord(triangles[t][0]).storage(),
 				      coord(triangles[t][1]).storage(),
 				      coord(triangles[t][2]).storage());
     inradius = std::min(ir, inradius);
   }
 
   return inradius;
 }
 
 /* -------------------------------------------------------------------------- */
 // template<> inline bool ElementClass<_triangle_6>::contains(const Vector<Real> & natural_coords) {
 //   return ElementClass<_triangle_3>::contains(natural_coords);
 // }
diff --git a/src/fe_engine/fe_engine_template.hh b/src/fe_engine/fe_engine_template.hh
index fcca5d08e..026963159 100644
--- a/src/fe_engine/fe_engine_template.hh
+++ b/src/fe_engine/fe_engine_template.hh
@@ -1,394 +1,393 @@
 /**
  * @file   fe_engine_template.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Tue Dec 08 2015
  *
  * @brief  templated class that calls integration and shape objects
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_FE_ENGINE_TEMPLATE_HH__
 #define __AKANTU_FE_ENGINE_TEMPLATE_HH__
 
 /* -------------------------------------------------------------------------- */
 #include "fe_engine.hh"
 #include "integrator.hh"
 #include "shape_functions.hh"
 /* -------------------------------------------------------------------------- */
 #include <type_traits>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 class DOFManager;
 namespace fe_engine {
   namespace details {
     template <ElementKind> struct AssembleLumpedTemplateHelper;
     template <ElementKind> struct AssembleFieldMatrixHelper;
   } // namespace details
 } // namespace fe_engine
 
 template <ElementKind, typename> struct AssembleFieldMatrixStructHelper;
 
 struct DefaultIntegrationOrderFunctor {
   template <ElementType type> static inline constexpr int getOrder() {
     return ElementClassProperty<type>::polynomial_degree;
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <template <ElementKind, class> class I, template <ElementKind> class S,
           ElementKind kind = _ek_regular,
           class IntegrationOrderFunctor = DefaultIntegrationOrderFunctor>
 class FEEngineTemplate : public FEEngine {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef I<kind, IntegrationOrderFunctor> Integ;
   typedef S<kind> Shape;
 
   FEEngineTemplate(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
                    ID id = "fem", MemoryID memory_id = 0);
 
   virtual ~FEEngineTemplate();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// pre-compute all the shape functions, their derivatives and the jacobians
   void initShapeFunctions(const GhostType & ghost_type = _not_ghost) override;
   void initShapeFunctions(const Array<Real> & nodes,
                           const GhostType & ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   /* Integration method bridges                                               */
   /* ------------------------------------------------------------------------ */
   /// integrate f for all elements of type "type"
   void
   integrate(const Array<Real> & f, Array<Real> & intf,
             UInt nb_degree_of_freedom, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// integrate a scalar value on all elements of type "type"
   Real
   integrate(const Array<Real> & f, const ElementType & type,
             const GhostType & ghost_type = _not_ghost,
             const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// integrate one element scalar value on all elements of type "type"
   virtual Real
   integrate(const Vector<Real> & f, const ElementType & type, UInt index,
             const GhostType & ghost_type = _not_ghost) const override;
 
   /// integrate partially around an integration point (@f$ intf_q = f_q * J_q *
   /// w_q @f$)
   void integrateOnIntegrationPoints(
       const Array<Real> & f, Array<Real> & intf, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate on a phyiscal point inside an element
   void interpolate(const Vector<Real> & real_coords,
                    const Matrix<Real> & nodal_values,
                    Vector<Real> & interpolated,
                    const Element & element) const override;
 
   /// get the number of integration points
   UInt getNbIntegrationPoints(
       const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /// get shapes precomputed
   const Array<Real> & getShapes(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost,
                                 UInt id = 0) const override;
 
   /// get the derivatives of shapes
   const Array<Real> &
   getShapesDerivatives(const ElementType & type,
                        const GhostType & ghost_type = _not_ghost,
                        UInt id = 0) const override;
 
   /// get integration points
   const inline Matrix<Real> & getIntegrationPoints(
       const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Shape method bridges                                                     */
   /* ------------------------------------------------------------------------ */
 
   /// compute the gradient of a nodal field on the integration points
   void gradientOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & nablauq,
       const UInt nb_degree_of_freedom, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate a nodal field on the integration points
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, Array<Real> & uq, UInt nb_degree_of_freedom,
       const ElementType & type, const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate a nodal field on the integration points given a
   /// by_element_type
   void interpolateOnIntegrationPoints(
       const Array<Real> & u, ElementTypeMapArray<Real> & uq,
       const ElementTypeMapArray<UInt> * filter_elements = NULL) const override;
 
   /// compute the position of integration points given by an element_type_map
   /// from nodes position
   inline void computeIntegrationPointsCoordinates(
       ElementTypeMapArray<Real> & quadrature_points_coordinates,
       const ElementTypeMapArray<UInt> * filter_elements = NULL) const override;
 
   /// compute the position of integration points from nodes position
   inline void computeIntegrationPointsCoordinates(
       Array<Real> & quadrature_points_coordinates, const ElementType & type,
       const GhostType & ghost_type = _not_ghost,
       const Array<UInt> & filter_elements = empty_filter) const override;
 
   /// interpolate field at given position (interpolation_points) from given
   /// values of this field at integration points (field)
   inline void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const override;
 
   /// Interpolate field at given position from given values of this field at
   /// integration points (field)
   /// using matrices precomputed with
   /// initElementalFieldInterplationFromIntegrationPoints
   inline void interpolateElementalFieldFromIntegrationPoints(
       const ElementTypeMapArray<Real> & field,
       const ElementTypeMapArray<Real> &
           interpolation_points_coordinates_matrices,
       const ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
       ElementTypeMapArray<Real> & result, const GhostType ghost_type,
       const ElementTypeMapArray<UInt> * element_filter) const override;
 
   /// Build pre-computed matrices for interpolation of field form integration
   /// points at other given positions (interpolation_points)
   inline void initElementalFieldInterpolationFromIntegrationPoints(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates,
       ElementTypeMapArray<Real> & interpolation_points_coordinates_matrices,
       ElementTypeMapArray<Real> & quad_points_coordinates_inv_matrices,
       const ElementTypeMapArray<UInt> * element_filter = NULL) const override;
 
   /// find natural coords from real coords provided an element
   void inverseMap(const Vector<Real> & real_coords, UInt element,
                   const ElementType & type, Vector<Real> & natural_coords,
                   const GhostType & ghost_type = _not_ghost) const;
 
   /// return true if the coordinates provided are inside the element, false
   /// otherwise
   inline bool contains(const Vector<Real> & real_coords, UInt element,
                        const ElementType & type,
                        const GhostType & ghost_type = _not_ghost) const;
 
   /// compute the shape on a provided point
   inline void
   computeShapes(const Vector<Real> & real_coords, UInt element,
                 const ElementType & type, Vector<Real> & shapes,
                 const GhostType & ghost_type = _not_ghost) const override;
 
   /// compute the shape derivatives on a provided point
   inline void computeShapeDerivatives(
       const Vector<Real> & real__coords, UInt element, const ElementType & type,
       Matrix<Real> & shape_derivatives,
       const GhostType & ghost_type = _not_ghost) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Other methods                                                            */
   /* ------------------------------------------------------------------------ */
 
   /// pre-compute normals on integration points
   void computeNormalsOnIntegrationPoints(
       const GhostType & ghost_type = _not_ghost) override;
   void computeNormalsOnIntegrationPoints(
       const Array<Real> & field,
       const GhostType & ghost_type = _not_ghost) override;
   void computeNormalsOnIntegrationPoints(
       const Array<Real> & field, Array<Real> & normal, const ElementType & type,
       const GhostType & ghost_type = _not_ghost) const override;
   template <ElementType type>
   void computeNormalsOnIntegrationPoints(const Array<Real> & field,
                                          Array<Real> & normal,
                                          const GhostType & ghost_type) const;
 
 private:
   // To avoid a weird full specialization of a method in a non specalized class
   void
   computeNormalsOnIntegrationPointsPoint1(const Array<Real> &,
                                           Array<Real> & normal,
                                           const GhostType & ghost_type) const;
 
 public:
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /// assemble a field as a lumped matrix (ex. rho in lumped mass)
   template <class Functor>
   void assembleFieldLumped(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            ElementType type,
                            const GhostType & ghost_type) const;
 
   /// assemble a field as a matrix (ex. rho to mass matrix)
   template <class Functor>
   void assembleFieldMatrix(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            ElementType type,
                            const GhostType & ghost_type) const;
 
 #ifdef AKANTU_STRUCTURAL_MECHANICS
   /// assemble a field as a matrix (ex. rho to mass matrix)
   void assembleFieldMatrix(const Array<Real> & field_1,
                            UInt nb_degree_of_freedom, SparseMatrix & M,
                            Array<Real> * n,
                            ElementTypeMapArray<Real> & rotation_mat,
                            const ElementType & type,
                            const GhostType & ghost_type = _not_ghost) const;
 
   /// compute shapes function in a matrix for structural elements
   void computeShapesMatrix(const ElementType & type, UInt nb_degree_of_freedom,
                            UInt nb_nodes_per_element, Array<Real> * n, UInt id,
                            UInt degree_to_interpolate, UInt degree_interpolated,
                            const bool sign,
                            const GhostType & ghost_type = _not_ghost) const;
 #endif
 
 private:
   friend struct fe_engine::details::AssembleLumpedTemplateHelper<kind>;
   friend struct fe_engine::details::AssembleFieldMatrixHelper<kind>;
   friend struct AssembleFieldMatrixStructHelper<kind, void>;
 
   /// templated function to compute the scaling to assemble a lumped matrix
   template <class Functor, ElementType type>
   void assembleFieldLumped(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            const GhostType & ghost_type) const;
 
   /// @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j
   /// dV = \int \rho \varphi_i dV @f$
   template <ElementType type>
   void assembleLumpedRowSum(const Array<Real> & field, const ID & matrix_id,
                             const ID & dof_id, DOFManager & dof_manager,
                             const GhostType & ghost_type) const;
 
   /// @f$ \tilde{M}_{i} = c * M_{ii} = \int_{V_e} \rho dV @f$
   template <ElementType type>
   void assembleLumpedDiagonalScaling(const Array<Real> & field,
                                      const ID & matrix_id, const ID & dof_id,
                                      DOFManager & dof_manager,
                                      const GhostType & ghost_type) const;
 
   /// assemble a field as a matrix (ex. rho to mass matrix)
   template <class Functor, ElementType type>
   void assembleFieldMatrix(const Functor & field_funct, const ID & matrix_id,
                            const ID & dof_id, DOFManager & dof_manager,
                            const GhostType & ghost_type) const;
 
 #ifdef AKANTU_STRUCTURAL_MECHANICS
 
   /// assemble a field as a matrix for structural elements (ex. rho to mass
   /// matrix)
   template <ElementType type>
   void assembleFieldMatrix(const Array<Real> & field_1,
                            UInt nb_degree_of_freedom, SparseMatrix & M,
                            Array<Real> * n,
                            ElementTypeMapArray<Real> & rotation_mat,
                            __attribute__((unused))
                            const GhostType & ghost_type) const;
 
 #endif
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler interface                                             */
   /* ------------------------------------------------------------------------ */
 public:
   void onElementsAdded(const Array<Element> &,
                        const NewElementsEvent &) override;
   void onElementsRemoved(const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const RemovedElementsEvent &) override;
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the shape class (probably useless: see getShapeFunction)
   const ShapeFunctions & getShapeFunctionsInterface() const override {
     return shape_functions;
   };
   /// get the shape class
   const Shape & getShapeFunctions() const { return shape_functions; };
 
   /// get the integrator class (probably useless: see getIntegrator)
   const Integrator & getIntegratorInterface() const override {
     return integrator;
   };
   /// get the integrator class
   const Integ & getIntegrator() const { return integrator; };
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   Integ integrator;
   Shape shape_functions;
 };
 
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "fe_engine_template_tmpl.hh"
 #include "fe_engine_template_tmpl_field.hh"
 /* -------------------------------------------------------------------------- */
 /* Shape Linked specialization                                                */
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 #include "fe_engine_template_tmpl_struct.hh"
 #endif
-
 /* -------------------------------------------------------------------------- */
 /* Shape IGFEM specialization                                                 */
 /* -------------------------------------------------------------------------- */
 #if defined(AKANTU_IGFEM)
 #include "fe_engine_template_tmpl_igfem.hh"
 #endif
 
 #endif /* __AKANTU_FE_ENGINE_TEMPLATE_HH__ */
diff --git a/src/fe_engine/gauss_integration_tmpl.hh b/src/fe_engine/gauss_integration_tmpl.hh
index 01b1aa7b3..1c353f38b 100644
--- a/src/fe_engine/gauss_integration_tmpl.hh
+++ b/src/fe_engine/gauss_integration_tmpl.hh
@@ -1,271 +1,271 @@
 /**
  * @file   gauss_integration_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Tue May 10 10:48:21 2016
  *
  * @brief  implementation of the gauss integration helpers
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_GAUSS_INTEGRATION_TMPL_HH__
 #define __AKANTU_GAUSS_INTEGRATION_TMPL_HH__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* GaussIntegrationElement                                                    */
 /* -------------------------------------------------------------------------- */
 namespace _aka_gauss_helpers {
 template <GaussIntegrationType type, UInt n> struct GaussIntegrationNbPoints {
 
 };
 
 template <UInt n> struct GaussIntegrationNbPoints<_git_not_defined, n> {
   static const UInt nb_points = 0;
 };
 
 template <UInt n> struct GaussIntegrationNbPoints<_git_point, n> {
   static const UInt nb_points = 1;
 };
 
 template <UInt n> struct GaussIntegrationNbPoints<_git_segment, n> {
   static const UInt nb_points = (n + 1) / 2 + ((n + 1) % 2 ? 1 : 0);
 };
 
 #define DECLARE_GAUSS_NB_POINTS(type, order, points)                           \
   template <> struct GaussIntegrationNbPoints<type, order> {                   \
     static const UInt nb_points = points;                                      \
   }
 
 #define DECLARE_GAUSS_NB_POINTS_PENT(type, order, xo, yo)                      \
   template <> struct GaussIntegrationNbPoints<type, order> {                   \
     static const UInt x_order = xo;                                            \
     static const UInt yz_order = yo;                                           \
     static const UInt nb_points = 1;                                           \
   }
 
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 1, 1);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 2, 3);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 3, 4);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 4, 6);
 DECLARE_GAUSS_NB_POINTS(_git_triangle, 5, 7);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 1, 1);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 2, 4);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 3, 5);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 4, 15);
 DECLARE_GAUSS_NB_POINTS(_git_tetrahedron, 5, 15);
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 1, 3,
                              2); // order 3 in x, order 2 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 2, 3,
                              2); // order 3 in x, order 2 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 3, 3,
                              3); // order 3 in x, order 3 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 4, 5,
                              5); // order 5 in x, order 5 in y and z
 DECLARE_GAUSS_NB_POINTS_PENT(_git_pentahedron, 5, 5,
                              5); // order 5 in x, order 5 in y and z
 
 template <GaussIntegrationType type, UInt n, UInt on = n,
           bool end_recurse = false>
 struct GaussIntegrationNbPointsHelper {
   static const UInt pnp = GaussIntegrationNbPoints<type, n>::nb_points;
   static const UInt order = n;
   static const UInt nb_points = pnp;
 };
 
 template <GaussIntegrationType type, UInt n, UInt on>
 struct GaussIntegrationNbPointsHelper<type, n, on, true> {
   static const UInt nb_points = 0;
 };
 
 /* ------------------------------------------------------------------------ */
 /* Generic helper                                                           */
 /* ------------------------------------------------------------------------ */
 template <GaussIntegrationType type, UInt dimension, UInt n>
 struct GaussIntegrationTypeDataHelper {
   typedef GaussIntegrationNbPoints<type, n> git_np;
   typedef GaussIntegrationTypeData<type, git_np::nb_points> git_data;
 
   static UInt getNbQuadraturePoints() { return git_np::nb_points; }
 
   static const Matrix<Real> getQuadraturePoints() {
     return Matrix<Real>(git_data::quad_positions, dimension, git_np::nb_points);
   }
 
   static const Vector<Real> getWeights() {
     return Vector<Real>(git_data::quad_weights, git_np::nb_points);
   }
 };
 
 /* ------------------------------------------------------------------------ */
 /* helper for _segment _quadrangle _hexahedron                              */
 /* ------------------------------------------------------------------------ */
 template <UInt dimension, UInt dp>
 struct GaussIntegrationTypeDataHelper<_git_segment, dimension, dp> {
   typedef GaussIntegrationNbPoints<_git_segment, dp> git_np;
   typedef GaussIntegrationTypeData<_git_segment, git_np::nb_points> git_data;
 
   static UInt getNbQuadraturePoints() {
     return Math::pow<dimension>(git_np::nb_points);
   }
 
   static const Matrix<Real> getQuadraturePoints() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad = git_np::nb_points;
 
     Matrix<Real> quads(dimension, tot_nquad);
     Vector<Real> pos(git_data::quad_positions, nquad);
 
     UInt offset = 1;
     for (UInt d = 0; d < dimension; ++d) {
       for (UInt n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
         UInt rq = q % tot_nquad + q / tot_nquad;
         quads(d, rq) = pos(n % nquad);
       }
       offset *= nquad;
     }
     return quads;
   }
 
   static const Vector<Real> getWeights() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad = git_np::nb_points;
 
     Vector<Real> quads_weights(tot_nquad, 1.);
     Vector<Real> weights(git_data::quad_weights, nquad);
 
     UInt offset = 1;
     for (UInt d = 0; d < dimension; ++d) {
       for (UInt n = 0, q = 0; n < tot_nquad; ++n, q += offset) {
         UInt rq = q % tot_nquad + q / tot_nquad;
         quads_weights(rq) *= weights(n % nquad);
       }
       offset *= nquad;
     }
     return quads_weights;
   }
 };
 
 /* ------------------------------------------------------------------------ */
 /* helper for _pentahedron                                                  */
 /* ------------------------------------------------------------------------ */
 template <UInt dimension, UInt dp>
 struct GaussIntegrationTypeDataHelper<_git_pentahedron, dimension, dp> {
   typedef GaussIntegrationNbPoints<_git_pentahedron, dp> git_info;
   typedef GaussIntegrationNbPoints<_git_segment, git_info::x_order> git_np_seg;
   typedef GaussIntegrationNbPoints<_git_triangle, git_info::yz_order> git_np_tri;
 
   typedef GaussIntegrationTypeData<_git_segment, git_np_seg::nb_points>
       git_data_seg;
   typedef GaussIntegrationTypeData<_git_triangle, git_np_tri::nb_points>
       git_data_tri;
 
   static UInt getNbQuadraturePoints() {
     return git_np_seg::nb_points * git_np_tri::nb_points;
   }
 
   static const Matrix<Real> getQuadraturePoints() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad_seg = git_np_seg::nb_points;
     UInt nquad_tri = git_np_tri::nb_points;
 
     Matrix<Real> quads(dimension, tot_nquad);
     Matrix<Real> pos_seg_w(git_data_seg::quad_positions, 1, nquad_seg);
     Matrix<Real> pos_tri_w(git_data_tri::quad_positions, 2, nquad_tri);
 
     for (UInt ns = 0, q = 0; ns < nquad_seg; ++ns) {
       Vector<Real> pos_seg = pos_seg_w(ns);
       for (UInt nt = 0; nt < nquad_tri; ++nt, ++q) {
         Vector<Real> pos_tri = pos_tri_w(nt);
         Vector<Real> quad = quads(q);
         quad(_x) = pos_seg(_x);
         quad(_y) = pos_tri(_x);
         quad(_z) = pos_tri(_y);
       }
     }
     return quads;
   }
 
   static const Vector<Real> getWeights() {
     UInt tot_nquad = getNbQuadraturePoints();
     UInt nquad_seg = git_np_seg::nb_points;
     UInt nquad_tri = git_np_tri::nb_points;
 
     Vector<Real> quads_weights(tot_nquad);
 
     Vector<Real> weight_seg(git_data_seg::quad_weights, nquad_seg);
     Vector<Real> weight_tri(git_data_tri::quad_weights, nquad_tri);
 
     for (UInt ns = 0, q = 0; ns < nquad_seg; ++ns) {
       for (UInt nt = 0; nt < nquad_tri; ++nt, ++q) {
         quads_weights(q) = weight_seg(ns) * weight_tri(nt);
       }
     }
     return quads_weights;
   }
 };
 }
 
 template <ElementType element_type, UInt n>
 const Matrix<Real>
 GaussIntegrationElement<element_type, n>::getQuadraturePoints() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
-  typedef InterpolationPorperty<itp_type> interpolation_property;
+  typedef InterpolationProperty<itp_type> interpolation_property;
   typedef _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n> data_helper;
   Matrix<Real> tmp(data_helper::getQuadraturePoints());
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type, UInt n>
 const Vector<Real> GaussIntegrationElement<element_type, n>::getWeights() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
-  typedef InterpolationPorperty<itp_type> interpolation_property;
+  typedef InterpolationProperty<itp_type> interpolation_property;
   typedef _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n> data_helper;
   Vector<Real> tmp(data_helper::getWeights());
   return tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <ElementType element_type, UInt n>
 UInt GaussIntegrationElement<element_type, n>::getNbQuadraturePoints() {
   const InterpolationType itp_type =
       ElementClassProperty<element_type>::interpolation_type;
-  typedef InterpolationPorperty<itp_type> interpolation_property;
+  typedef InterpolationProperty<itp_type> interpolation_property;
   typedef _aka_gauss_helpers::GaussIntegrationTypeDataHelper<
       ElementClassProperty<element_type>::gauss_integration_type,
       interpolation_property::natural_space_dimension, n> data_helper;
   return data_helper::getNbQuadraturePoints();
 }
 
 } // akantu
 
 #endif /* __AKANTU_GAUSS_INTEGRATION_TMPL_HH__ */
diff --git a/src/fe_engine/interpolation_element_tmpl.hh b/src/fe_engine/interpolation_element_tmpl.hh
index 36d398faa..d1b4bf96b 100644
--- a/src/fe_engine/interpolation_element_tmpl.hh
+++ b/src/fe_engine/interpolation_element_tmpl.hh
@@ -1,57 +1,58 @@
 /**
  * @file   interpolation_element_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Jun 06 2013
  * @date last modification: Tue Apr 07 2015
  *
  * @brief  interpolation property description
  *
  * @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_class.hh"
+/* -------------------------------------------------------------------------- */
+
+#ifndef __AKANTU_INTERPOLATION_ELEMENT_TMPL_HH__
+#define __AKANTU_INTERPOLATION_ELEMENT_TMPL_HH__
+
+namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 /* Regular Elements                                                           */
 /* -------------------------------------------------------------------------- */
-
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_point_1,        _itk_lagrangian,  1, 0);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_segment_2,      _itk_lagrangian,  2, 1);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_segment_3,      _itk_lagrangian,  3, 1);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_triangle_3,     _itk_lagrangian,  3, 2);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_triangle_6,     _itk_lagrangian,  6, 2);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_tetrahedron_4,  _itk_lagrangian,  4, 3);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_tetrahedron_10, _itk_lagrangian, 10, 3);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_quadrangle_4,   _itk_lagrangian,  4, 2);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_serendip_quadrangle_8,   _itk_lagrangian,  8, 2);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_hexahedron_8,   _itk_lagrangian,  8, 3);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_serendip_hexahedron_20,  _itk_lagrangian,  20, 3);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_pentahedron_6,  _itk_lagrangian,  6, 3);
 AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_lagrange_pentahedron_15, _itk_lagrangian,  15, 3);
 
-/* -------------------------------------------------------------------------- */
-/* Structural elements                                                        */
-/* -------------------------------------------------------------------------- */
-#if defined(AKANTU_STRUCTURAL_MECHANICS)
-AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_bernoulli_beam, _itk_structural, 2, 1);
-AKANTU_DEFINE_INTERPOLATION_TYPE_PROPERTY(_itp_kirchhoff_shell, _itk_structural, 3, 2);
-#endif
+}  // akantu
+#endif /* __AKANTU_INTERPOLATION_ELEMENT_TMPL_HH__ */
diff --git a/src/io/dumper/dumpable_dummy.hh b/src/io/dumper/dumpable_dummy.hh
index 7973056b1..ae8f5551b 100644
--- a/src/io/dumper/dumpable_dummy.hh
+++ b/src/io/dumper/dumpable_dummy.hh
@@ -1,252 +1,252 @@
 /**
  * @file   dumpable_dummy.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Oct 26 2012
  * @date last modification: Fri Aug 21 2015
  *
  * @brief  Interface for object who wants to dump themselves
  *
  * @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_DUMPABLE_DUMMY_HH__
 #define __AKANTU_DUMPABLE_DUMMY_HH__
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused"
 
 namespace dumper {
   class Field;
 }
 
 class DumperIOHelper;
 class Mesh;
 
 /* -------------------------------------------------------------------------- */
 class Dumpable {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
 
   Dumpable() {};
   virtual ~Dumpable() { };
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template<class T>
   inline void registerDumper(const std::string & dumper_name,
                       const std::string & file_name = "",
                       const bool is_default = false) { }
 
   void registerExternalDumper(DumperIOHelper * dumper,
                               const std::string & dumper_name,
                               const bool is_default = false) { }
 
   void addDumpMesh(const Mesh & mesh,
                    UInt spatial_dimension = _all_dimensions,
                    const GhostType & ghost_type = _not_ghost,
                    const ElementKind & element_kind = _ek_not_defined) {
   }
 
   void addDumpMeshToDumper(const std::string & dumper_name,
                            const Mesh & mesh,
                            UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & element_kind = _ek_not_defined) {
   }
 
   void addDumpFilteredMesh(const Mesh & mesh,
                            const ElementTypeMapArray<UInt> & elements_filter,
                            const Array<UInt> & nodes_filter,
                            UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & element_kind = _ek_not_defined) {
   }
 
   void addDumpFilteredMeshToDumper(const std::string & dumper_name,
                                    const Mesh & mesh,
                                    const ElementTypeMapArray<UInt> & elements_filter,
                                    const Array<UInt> & nodes_filter,
                                    UInt spatial_dimension = _all_dimensions,
                                    const GhostType & ghost_type = _not_ghost,
                                    const ElementKind & element_kind = _ek_not_defined) {
   }
 
   virtual void addDumpField(const std::string & field_id){
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
   virtual void addDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id){
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   virtual void addDumpFieldExternal(const std::string & field_id,
                                     dumper::Field * field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   virtual void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     dumper::Field * field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   template<typename T>
   void addDumpFieldExternal(const std::string & field_id,
                             const Array<T> & field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   template<typename T>
   void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     const Array<T> & field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   template<typename T>
   void addDumpFieldExternal(const std::string & field_id,
                             const ElementTypeMapArray<T> & field,
                             UInt spatial_dimension = _all_dimensions,
                             const GhostType & ghost_type = _not_ghost,
                             const ElementKind & element_kind = _ek_not_defined) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   template<typename T>
   void addDumpFieldExternalToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     const ElementTypeMapArray<T> & field,
                                     UInt spatial_dimension = _all_dimensions,
                                     const GhostType & ghost_type = _not_ghost,
                                     const ElementKind & element_kind = _ek_not_defined) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void removeDumpField(const std::string & field_id) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void removeDumpFieldFromDumper(const std::string & dumper_name,
                                const std::string & field_id) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
-  void setDirectory(const std::string & directory) {
+  void setDirecory(const std::string & directory) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void setDirectoryToDumper(const std::string & dumper_name,
                             const std::string & directory) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void setBaseName(const std::string & basename) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void setBaseNameToDumper(const std::string & dumper_name,
                            const std::string & basename) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void setTextModeToDumper(const std::string & dumper_name){
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void setTextModeToDumper(){
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
 
   void dump() {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void dump(const std::string & dumper_name) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void dump(UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void dump(const std::string & dumper_name,
             UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   void dump(Real current_time,
             UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
   void dump(const std::string & dumper_name,
             Real current_time,
             UInt step) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
 protected:
 
   void internalAddDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id,
                                     dumper::Field * field) {
     AKANTU_DEBUG_WARNING("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
 protected:
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
 
   DumperIOHelper & getDumper() {
     AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   DumperIOHelper & getDumper(const std::string & dumper_name){
     AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   template<class T>
   T & getDumper(const std::string & dumper_name) {
     AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   std::string getDefaultDumperName() {
     AKANTU_DEBUG_ERROR("No dumper activated at compilation, turn on AKANTU_USE_IOHELPER in cmake.");
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
 };
 
 #pragma GCC diagnostic pop
 
 } // akantu
 
 #endif /* __AKANTU_DUMPABLE_DUMMY_HH__ */
diff --git a/src/io/parser/parameter_registry_tmpl.hh b/src/io/parser/parameter_registry_tmpl.hh
index 38f58e3be..2beda2f33 100644
--- a/src/io/parser/parameter_registry_tmpl.hh
+++ b/src/io/parser/parameter_registry_tmpl.hh
@@ -1,346 +1,346 @@
 /**
  * @file   parameter_registry_tmpl.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Aug 09 2012
  * @date last modification: Fri Mar 27 2015
  *
  * @brief implementation of the templated part of ParameterRegistry class and
  * the derivated ones
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_error.hh"
 #include "parameter_registry.hh"
 #include "parser.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <string>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PARAMETER_REGISTRY_TMPL_HH__
 #define __AKANTU_PARAMETER_REGISTRY_TMPL_HH__
 
 namespace akantu {
 
 namespace debug {
   class ParameterException : public Exception {
   public:
     ParameterException(const std::string & name, const std::string & message)
         : Exception(message), name(name) {}
     const std::string & name;
   };
 
   class ParameterUnexistingException : public ParameterException {
   public:
     ParameterUnexistingException(const std::string & name,
                                  const ParameterRegistry & registery)
         : ParameterException(name, "Parameter " + name +
                                        " does not exists in this scope") {
       auto && params = registery.listParameters();
       this->_info =
           std::accumulate(params.begin(), params.end(),
                           this->_info + "\n Possible parameters are: ",
                           [](auto && str, auto && param) {
                             static auto first = true;
                             auto && ret = str + (first ? " " : ", ") + param;
                             first = false;
                             return ret;
                           });
     }
   };
 
   class ParameterAccessRightException : public ParameterException {
   public:
     ParameterAccessRightException(const std::string & name,
                                   const std::string & perm)
         : ParameterException(name, "Parameter " + name + " is not " + perm) {}
   };
 
   class ParameterWrongTypeException : public ParameterException {
   public:
     ParameterWrongTypeException(const std::string name,
                                 const std::type_info & wrong_type,
                                 const std::type_info & type)
         : ParameterException(name, "Parameter " + name +
                                        " type error, cannot convert " +
                                        debug::demangle(type.name()) + " to " +
                                        debug::demangle(wrong_type.name())) {}
   };
 } // namespace debug
 /* -------------------------------------------------------------------------- */
 template <typename T>
 const ParameterTyped<T> & Parameter::getParameterTyped() const {
   try {
     const ParameterTyped<T> & tmp =
         dynamic_cast<const ParameterTyped<T> &>(*this);
     return tmp;
   } catch (std::bad_cast &) {
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterWrongTypeException(name, typeid(T), this->type()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> ParameterTyped<T> & Parameter::getParameterTyped() {
   try {
     ParameterTyped<T> & tmp = dynamic_cast<ParameterTyped<T> &>(*this);
     return tmp;
   } catch (std::bad_cast &) {
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterWrongTypeException(name, typeid(T), this->type()));
   }
 }
 
 /* ------------------------------------------------------------------------ */
 template <typename T, typename V> void Parameter::set(const V & value) {
   if (!(isWritable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "writable"));
   ParameterTyped<T> & typed_param = getParameterTyped<T>();
   typed_param.setTyped(value);
 }
 
 /* ------------------------------------------------------------------------ */
 inline void Parameter::setAuto(__attribute__((unused))
                                const ParserParameter & value) {
   if (!(isParsable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "parsable"));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> const T & Parameter::get() const {
   if (!(isReadable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "readable"));
   const ParameterTyped<T> & typed_param = getParameterTyped<T>();
   return typed_param.getTyped();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> T & Parameter::get() {
   ParameterTyped<T> & typed_param = getParameterTyped<T>();
   if (!(isReadable()) || !(this->isWritable()))
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "accessible"));
   return typed_param.getTyped();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> inline Parameter::operator T() const {
   return this->get<T>();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ParameterTyped<T>::ParameterTyped(std::string name, std::string description,
                                   ParameterAccessType param_type, T & param)
     : Parameter(name, description, param_type), param(param) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 template <typename V>
 void ParameterTyped<T>::setTyped(const V & value) {
   param = value;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParameterTyped<T>::setAuto(const ParserParameter & value) {
   Parameter::setAuto(value);
   param = static_cast<T>(value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<std::string>::setAuto(const ParserParameter & value) {
   Parameter::setAuto(value);
   param = value.getValue();
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<Vector<Real>>::setAuto(const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   Vector<Real> tmp = in_param;
   for (UInt i = 0; i < param.size(); ++i) {
     param(i) = tmp(i);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void
 ParameterTyped<Matrix<Real>>::setAuto(const ParserParameter & in_param) {
   Parameter::setAuto(in_param);
   Matrix<Real> tmp = in_param;
   for (UInt i = 0; i < param.rows(); ++i) {
     for (UInt j = 0; j < param.cols(); ++j) {
       param(i, j) = tmp(i, j);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> const T & ParameterTyped<T>::getTyped() const {
   return param;
 }
 /* -------------------------------------------------------------------------- */
 template <typename T> T & ParameterTyped<T>::getTyped() { return param; }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void ParameterTyped<T>::printself(std::ostream & stream) const {
   Parameter::printself(stream);
   stream << param << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 inline void ParameterTyped<bool>::printself(std::ostream & stream) const {
   Parameter::printself(stream);
   stream << std::boolalpha << param << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void ParameterRegistry::registerParam(std::string name, T & variable,
                                       ParameterAccessType type,
                                       const std::string & description) {
   std::map<std::string, Parameter *>::iterator it = params.find(name);
   if (it != params.end())
     AKANTU_CUSTOM_EXCEPTION(debug::ParameterException(
         name, "Parameter named " + name + " already registered."));
   ParameterTyped<T> * param =
       new ParameterTyped<T>(name, description, type, variable);
   params[name] = param;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void ParameterRegistry::registerParam(std::string name, T & variable,
                                       const T & default_value,
                                       ParameterAccessType type,
                                       const std::string & description) {
   variable = default_value;
   registerParam(name, variable, type, description);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename V>
 void ParameterRegistry::setMixed(const std::string & name, const V & value) {
   std::map<std::string, Parameter *>::iterator it = params.find(name);
   if (it == params.end()) {
     if (consisder_sub) {
       for (SubRegisteries::iterator it = sub_registries.begin();
            it != sub_registries.end(); ++it) {
         it->second->setMixed<T>(name, value);
       }
     } else {
       AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name, *this));
     }
   } else {
     Parameter & param = *(it->second);
     param.set<T>(value);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void ParameterRegistry::set(const std::string & name, const T & value) {
   this->template setMixed<T>(name, value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T> T & ParameterRegistry::get(const std::string & name) {
   Parameters::iterator it = params.find(name);
   if (it == params.end()) {
     if (consisder_sub) {
       for (SubRegisteries::iterator it = sub_registries.begin();
            it != sub_registries.end(); ++it) {
         try {
           return it->second->get<T>(name);
         } catch (...) {
         }
       }
     }
 
     // nothing was found not even in sub registries
-    AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name));
+    AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name, *this));
   }
 
   Parameter & param = *(it->second);
   return param.get<T>();
 }
 
 /* -------------------------------------------------------------------------- */
 const Parameter & ParameterRegistry::get(const std::string & name) const {
   Parameters::const_iterator it = params.find(name);
   if (it == params.end()) {
     if (consisder_sub) {
       for (SubRegisteries::const_iterator it = sub_registries.begin();
            it != sub_registries.end(); ++it) {
         try {
           return it->second->get(name);
         } catch (...) {
         }
       }
     }
 
     // nothing was found not even in sub registries
     AKANTU_CUSTOM_EXCEPTION(debug::ParameterUnexistingException(name, *this));
   }
 
   Parameter & param = *(it->second);
   return param;
 }
 
 /* -------------------------------------------------------------------------- */
 namespace {
   namespace details {
     template <class T, class R, class Enable = void> struct CastHelper {
       static R convert(const T &) { throw std::bad_cast(); }
     };
 
     template <class T, class R>
     struct CastHelper<T, R,
                       std::enable_if_t<std::is_convertible<T, R>::value>> {
       static R convert(const T & val) { return val; }
     };
   } // namespace details
 } // namespace
 
 template <typename T> inline ParameterTyped<T>::operator Real() const {
   if (not isReadable())
     AKANTU_CUSTOM_EXCEPTION(
         debug::ParameterAccessRightException(name, "accessible"));
   return details::CastHelper<T, Real>::convert(param);
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_PARAMETER_REGISTRY_TMPL_HH__ */
diff --git a/src/mesh/element_type_map.hh b/src/mesh/element_type_map.hh
index cee03fd5a..6d84bb6ab 100644
--- a/src/mesh/element_type_map.hh
+++ b/src/mesh/element_type_map.hh
@@ -1,393 +1,415 @@
 /**
  * @file   element_type_map.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 31 2011
  * @date last modification: Fri Oct 02 2015
  *
  * @brief  storage class by element type
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_array.hh"
 #include "aka_memory.hh"
 #include "aka_named_argument.hh"
 #include "element.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_ELEMENT_TYPE_MAP_HH__
 #define __AKANTU_ELEMENT_TYPE_MAP_HH__
 
 namespace akantu {
 class FEEngine;
 } // namespace akantu
 
 namespace akantu {
 
+namespace {
+  DECLARE_NAMED_ARGUMENT(all_ghost_types);
+  DECLARE_NAMED_ARGUMENT(default_value);
+  DECLARE_NAMED_ARGUMENT(element_kind);
+  DECLARE_NAMED_ARGUMENT(ghost_type);
+  DECLARE_NAMED_ARGUMENT(nb_component);
+  DECLARE_NAMED_ARGUMENT(with_nb_element);
+  DECLARE_NAMED_ARGUMENT(with_nb_nodes_per_element);
+  DECLARE_NAMED_ARGUMENT(spatial_dimension);
+} // namespace
+
 template <class Stored, typename SupportType = ElementType>
 class ElementTypeMap;
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMapBase */
 /* -------------------------------------------------------------------------- */
 /// Common non templated base class for the ElementTypeMap class
 class ElementTypeMapBase {
 public:
-  virtual ~ElementTypeMapBase(){};
+  virtual ~ElementTypeMapBase() = default;
 };
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMap */
 /* -------------------------------------------------------------------------- */
 
 template <class Stored, typename SupportType>
 class ElementTypeMap : public ElementTypeMapBase {
 
 public:
   ElementTypeMap();
   ~ElementTypeMap();
 
   inline static std::string printType(const SupportType & type,
                                       const GhostType & ghost_type);
 
   /*! Tests whether a type is present in the object
    *  @param type the type to check for
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return true if the type is present. */
   inline bool exists(const SupportType & type,
                      const GhostType & ghost_type = _not_ghost) const;
 
   /*! get the stored data corresponding to a type
    *  @param type the type to check for
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return stored data corresponding to type. */
   inline const Stored &
   operator()(const SupportType & type,
              const GhostType & ghost_type = _not_ghost) const;
 
   /*! get the stored data corresponding to a type
    *  @param type the type to check for
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return stored data corresponding to type. */
   inline Stored & operator()(const SupportType & type,
                              const GhostType & ghost_type = _not_ghost);
 
   /*! insert data of a new type (not yet present) into the map. THIS METHOD IS
    *  NOT ARRAY SAFE, when using ElementTypeMapArray, use setArray instead
    *  @param data to insert
    *  @param type type of data (if this type is already present in the map,
    *         an exception is thrown).
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @return stored data corresponding to type. */
   inline Stored & operator()(const Stored & insert, const SupportType & type,
                              const GhostType & ghost_type = _not_ghost);
 
   /// print helper
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /* ------------------------------------------------------------------------ */
   /* Element type Iterator                                                    */
   /* ------------------------------------------------------------------------ */
   /*! iterator allows to iterate over type-data pairs of the map. The interface
    *  expects the SupportType to be ElementType. */
   typedef std::map<SupportType, Stored> DataMap;
   class type_iterator
       : private std::iterator<std::forward_iterator_tag, const SupportType> {
   public:
-    typedef const SupportType value_type;
-    typedef const SupportType * pointer;
-    typedef const SupportType & reference;
+    using value_type = const SupportType;
+    using pointer = const SupportType *;
+    using reference = const SupportType &;
 
   protected:
-    typedef typename ElementTypeMap<Stored>::DataMap::const_iterator
-        DataMapIterator;
+    using DataMapIterator =
+        typename ElementTypeMap<Stored>::DataMap::const_iterator;
 
   public:
     type_iterator(DataMapIterator & list_begin, DataMapIterator & list_end,
                   UInt dim, ElementKind ek);
 
     type_iterator(const type_iterator & it);
     type_iterator() {}
 
     inline reference operator*();
     inline reference operator*() const;
     inline type_iterator & operator++();
     type_iterator operator++(int);
     inline bool operator==(const type_iterator & other) const;
     inline bool operator!=(const type_iterator & other) const;
     type_iterator & operator=(const type_iterator & other);
 
   private:
     DataMapIterator list_begin;
     DataMapIterator list_end;
     UInt dim;
     ElementKind kind;
   };
 
   /// helper class to use in range for constructions
   class ElementTypesIteratorHelper {
   public:
     using Container = ElementTypeMap<Stored, SupportType>;
     using iterator = typename Container::type_iterator;
 
-    ElementTypesIteratorHelper(const Container & container,
-                               UInt dim = _all_dimensions,
-                               GhostType ghost_type = _not_ghost,
-                               ElementKind kind = _ek_regular)
+    ElementTypesIteratorHelper(const Container & container, UInt dim,
+                               GhostType ghost_type, ElementKind kind)
         : container(std::cref(container)), dim(dim), ghost_type(ghost_type),
           kind(kind) {}
 
+    template <typename... pack>
+    ElementTypesIteratorHelper(const Container & container, use_named_args_t,
+                               pack &&... _pack)
+        : ElementTypesIteratorHelper(
+            container, OPTIONAL_NAMED_ARG(spatial_dimension, _all_dimensions),
+            OPTIONAL_NAMED_ARG(ghost_type, _not_ghost),
+            OPTIONAL_NAMED_ARG(element_kind, _ek_regular)) {}
+
     ElementTypesIteratorHelper(const ElementTypesIteratorHelper &) = default;
     ElementTypesIteratorHelper &
     operator=(const ElementTypesIteratorHelper &) = default;
     ElementTypesIteratorHelper &
     operator=(ElementTypesIteratorHelper &&) = default;
 
     iterator begin() {
       return container.get().firstType(dim, ghost_type, kind);
     }
     iterator end() { return container.get().lastType(dim, ghost_type, kind); }
 
   private:
     std::reference_wrapper<const Container> container;
     UInt dim;
     GhostType ghost_type;
     ElementKind kind;
   };
 
   /// method to create the helper class to use in range for constructs
   ElementTypesIteratorHelper elementTypes(UInt dim = _all_dimensions,
                                           GhostType ghost_type = _not_ghost,
                                           ElementKind kind = _ek_regular) const;
 
+  template <typename P, typename T, typename... pack>
+  ElementTypesIteratorHelper
+  elementTypes(named_argument::param_t<P, T &&> && first,
+               pack &&... _pack) const;
+
   /*! Get an iterator to the beginning of a subset datamap. This method expects
    *  the SupportType to be ElementType.
    *  @param dim optional: iterate over data of dimension dim (e.g. when
    *         iterating over (surface) facets of a 3D mesh, dim would be 2).
    *         by default, all dimensions are considered.
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is iterated over.
    *  @param kind optional: the kind of element to search for (see
    *         aka_common.hh), by default all kinds are considered
    *  @return an iterator to the first stored data matching the filters
    *          or an iterator to the end of the map if none match*/
   inline type_iterator firstType(UInt dim = _all_dimensions,
                                  GhostType ghost_type = _not_ghost,
                                  ElementKind kind = _ek_not_defined) const;
   /*! Get an iterator to the end of a subset datamap. This method expects
    *  the SupportType to be ElementType.
    *  @param dim optional: iterate over data of dimension dim (e.g. when
    *         iterating over (surface) facets of a 3D mesh, dim would be 2).
    *         by default, all dimensions are considered.
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is iterated over.
    *  @param kind optional: the kind of element to search for (see
    *         aka_common.hh), by default all kinds are considered
    *  @return an iterator to the last stored data matching the filters
    *          or an iterator to the end of the map if none match */
   inline type_iterator lastType(UInt dim = _all_dimensions,
                                 GhostType ghost_type = _not_ghost,
                                 ElementKind kind = _ek_not_defined) const;
 
 protected:
   /*! Direct access to the underlying data map. for internal use by daughter
    *  classes only
    *  @param ghost_type whether to return the data map or the ghost_data map
    *  @return the raw map */
   inline DataMap & getData(GhostType ghost_type);
   /*! Direct access to the underlying data map. for internal use by daughter
    *  classes only
    *  @param ghost_type whether to return the data map or the ghost_data map
    *  @return the raw map */
   inline const DataMap & getData(GhostType ghost_type) const;
 
   /* ------------------------------------------------------------------------ */
 protected:
   DataMap data;
   DataMap ghost_data;
 };
 
 /* -------------------------------------------------------------------------- */
 /* Some typedefs                                                              */
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 class ElementTypeMapArray : public ElementTypeMap<Array<T> *, SupportType>,
                             public Memory {
 public:
   using type = T;
   using array_type = Array<T>;
 
 protected:
   using parent = ElementTypeMap<Array<T> *, SupportType>;
   using DataMap = typename parent::DataMap;
 
 public:
   using type_iterator = typename parent::type_iterator;
 
   /// standard assigment (copy) operator
   void operator=(const ElementTypeMapArray &) = delete;
   ElementTypeMapArray(const ElementTypeMapArray &) = delete;
 
   /*! Constructor
    *  @param id optional: identifier (string)
    *  @param parent_id optional: parent identifier. for organizational purposes
    *         only
    *  @param memory_id optional: choose a specific memory, defaults to memory 0
    */
   ElementTypeMapArray(const ID & id = "by_element_type_array",
                       const ID & parent_id = "no_parent",
                       const MemoryID & memory_id = 0)
       : parent(), Memory(parent_id + ":" + id, memory_id), name(id){};
 
   /*! allocate memory for a new array
    *  @param size number of tuples of the new array
    *  @param nb_component tuple size
    *  @param type the type under which the array is indexed in the map
    *  @param ghost_type whether to add the field to the data map or the
    *         ghost_data map
    *  @return a reference to the allocated array */
   inline Array<T> & alloc(UInt size, UInt nb_component,
                           const SupportType & type,
                           const GhostType & ghost_type,
                           const T & default_value = T());
 
   /*! allocate memory for a new array in both the data and the ghost_data map
    *  @param size number of tuples of the new array
    *  @param nb_component tuple size
    *  @param type the type under which the array is indexed in the map*/
   inline void alloc(UInt size, UInt nb_component, const SupportType & type,
                     const T & default_value = T());
 
   /* get a reference to the array of certain type
    * @param type data filed under type is returned
    * @param ghost_type optional: by default the non-ghost map is searched
    * @return a reference to the array */
   inline const Array<T> &
   operator()(const SupportType & type,
              const GhostType & ghost_type = _not_ghost) const;
 
   /// access the data of an element, this combine the map and array accessor
   inline const T & operator()(const Element & element) const;
 
   /// access the data of an element, this combine the map and array accessor
   inline T & operator()(const Element & element);
 
   /* get a reference to the array of certain type
    * @param type data filed under type is returned
    * @param ghost_type optional: by default the non-ghost map is searched
    * @return a const reference to the array */
   inline Array<T> & operator()(const SupportType & type,
                                const GhostType & ghost_type = _not_ghost);
 
   /*! insert data of a new type (not yet present) into the map.
    *  @param type type of data (if this type is already present in the map,
    *         an exception is thrown).
    *  @param ghost_type optional: by default, the data map for non-ghost
    *         elements is searched
    *  @param vect the vector to include into the map
    *  @return stored data corresponding to type. */
   inline void setArray(const SupportType & type, const GhostType & ghost_type,
                        const Array<T> & vect);
   /*! frees all memory related to the data*/
   inline void free();
 
   /*! set all values in the ElementTypeMap to zero*/
   inline void clear();
 
   /*! deletes and reorders entries in the stored arrays
    *  @param new_numbering a ElementTypeMapArray of new indices. UInt(-1)
    * indicates
    *         deleted entries. */
   inline void
   onElementsRemoved(const ElementTypeMapArray<UInt> & new_numbering);
 
   /// text output helper
   virtual void printself(std::ostream & stream, int indent = 0) const;
 
   /*! set the id
    *  @param id the new name
    */
   inline void setID(const ID & id) { this->id = id; }
 
   ElementTypeMap<UInt>
   getNbComponents(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
                   ElementKind kind = _ek_not_defined) const {
 
     ElementTypeMap<UInt> nb_components;
 
     for (auto & type : this->elementTypes(dim, ghost_type, kind)) {
       UInt nb_comp = (*this)(type, ghost_type).getNbComponent();
       nb_components(type, ghost_type) = nb_comp;
     }
 
     return nb_components;
   }
 
   /* ------------------------------------------------------------------------ */
   /* more evolved allocators                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// initialize the arrays in accordance to a functor
   template <class Func>
   void initialize(const Func & f, const T & default_value = T());
 
   /// initialize with sizes and number of components in accordance of a mesh
   /// content
   template <typename... pack>
   void initialize(const Mesh & mesh, pack &&... _pack);
 
   /// initialize with sizes and number of components in accordance of a fe
   /// engine content (aka integration points)
   template <typename... pack>
   void initialize(const FEEngine & fe_engine, pack &&... _pack);
 
   /* ------------------------------------------------------------------------ */
   /* Accesssors                                                               */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the name of the internal field
   AKANTU_GET_MACRO(Name, name, ID);
 
   /// name of the elment type map: e.g. connectivity, grad_u
   ID name;
 };
 
 /// to store data Array<Real> by element type
 using ElementTypeMapReal = ElementTypeMapArray<Real>;
 /// to store data Array<Int> by element type
 using ElementTypeMapInt = ElementTypeMapArray<Int>;
 /// to store data Array<UInt> by element type
 using ElementTypeMapUInt = ElementTypeMapArray<UInt, ElementType>;
 
 /// Map of data of type UInt stored in a mesh
 using UIntDataMap = std::map<std::string, Array<UInt> *>;
 using ElementTypeMapUIntDataMap = ElementTypeMap<UIntDataMap, ElementType>;
 
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_TYPE_MAP_HH__ */
diff --git a/src/mesh/element_type_map_tmpl.hh b/src/mesh/element_type_map_tmpl.hh
index e045aa0e3..18f8af79d 100644
--- a/src/mesh/element_type_map_tmpl.hh
+++ b/src/mesh/element_type_map_tmpl.hh
@@ -1,633 +1,631 @@
 /**
  * @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 {
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMap::printType(type, ghost_type)
                             << " in this ElementTypeMap<"
                             << debug::demangle(typeid(Stored).name())
                             << "> class");
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) {
   return this->getData(ghost_type)[type];
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline Stored & ElementTypeMap<Stored, SupportType>::
 operator()(const Stored & insert, const SupportType & type,
            const GhostType & ghost_type) {
   auto it = this->getData(ghost_type).find(type);
 
   if (it != this->getData(ghost_type).end()) {
     AKANTU_SILENT_EXCEPTION("Element of type "
                             << ElementTypeMap::printType(type, ghost_type)
                             << " already in this ElementTypeMap<"
                             << debug::demangle(typeid(Stored).name())
                             << "> class");
   } else {
     auto & data = this->getData(ghost_type);
     const auto & res =
         data.insert(std::pair<ElementType, Stored>(type, insert));
     it = res.first;
   }
 
   return it->second;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::DataMap &
 ElementTypeMap<Stored, SupportType>::getData(GhostType ghost_type) {
   if (ghost_type == _not_ghost)
     return data;
 
   return ghost_data;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline const typename ElementTypeMap<Stored, SupportType>::DataMap &
 ElementTypeMap<Stored, SupportType>::getData(GhostType ghost_type) const {
   if (ghost_type == _not_ghost)
     return data;
 
   return ghost_data;
 }
 
 /* -------------------------------------------------------------------------- */
 /// Works only if stored is a pointer to a class with a printself method
 template <class Stored, typename SupportType>
 void ElementTypeMap<Stored, SupportType>::printself(std::ostream & stream,
                                                     int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "ElementTypeMap<" << debug::demangle(typeid(Stored).name())
          << "> [" << std::endl;
   for (auto gt : ghost_types) {
     const DataMap & data = getData(gt);
     for (auto & pair : data) {
       stream << space << space << ElementTypeMap::printType(pair.first, gt)
              << std::endl;
     }
   }
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::ElementTypeMap() = default;
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 ElementTypeMap<Stored, SupportType>::~ElementTypeMap() = default;
 
 /* -------------------------------------------------------------------------- */
 /* ElementTypeMapArray                                                        */
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline Array<T> & ElementTypeMapArray<T, SupportType>::alloc(
     UInt size, UInt nb_component, const SupportType & type,
     const GhostType & ghost_type, const T & default_value) {
   std::string ghost_id = "";
   if (ghost_type == _ghost)
     ghost_id = ":ghost";
 
   Array<T> * tmp;
 
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end()) {
     std::stringstream sstr;
     sstr << this->id << ":" << type << ghost_id;
     tmp = &(Memory::alloc<T>(sstr.str(), size, nb_component, default_value));
     std::stringstream sstrg;
     sstrg << ghost_type;
     // tmp->setTag(sstrg.str());
     this->getData(ghost_type)[type] = tmp;
   } else {
     AKANTU_DEBUG_INFO(
         "The vector "
         << this->id << this->printType(type, ghost_type)
         << " already exists, it is resized instead of allocated.");
     tmp = it->second;
     it->second->resize(size);
   }
 
   return *tmp;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void
 ElementTypeMapArray<T, SupportType>::alloc(UInt size, UInt nb_component,
                                            const SupportType & type,
                                            const T & default_value) {
   this->alloc(size, nb_component, type, _not_ghost, default_value);
   this->alloc(size, nb_component, type, _ghost, default_value);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::free() {
   AKANTU_DEBUG_IN();
 
   for (auto && gt : ghost_types) {
     auto & data = this->getData(gt);
     for (auto & pair : data) {
       dealloc(pair.second->getID());
     }
     data.clear();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::clear() {
   for (auto gt : ghost_types) {
     auto & data = this->getData(gt);
     for (auto & vect : data) {
       vect.second->clear();
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline const Array<T> & ElementTypeMapArray<T, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) const {
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMapArray::printType(type, ghost_type)
                             << " in this const ElementTypeMapArray<"
                             << debug::demangle(typeid(T).name()) << "> class(\""
                             << this->id << "\")");
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline Array<T> & ElementTypeMapArray<T, SupportType>::
 operator()(const SupportType & type, const GhostType & ghost_type) {
   auto it = this->getData(ghost_type).find(type);
 
   if (it == this->getData(ghost_type).end())
     AKANTU_SILENT_EXCEPTION("No element of type "
                             << ElementTypeMapArray::printType(type, ghost_type)
                             << " in this ElementTypeMapArray<"
                             << debug::demangle(typeid(T).name())
                             << "> class (\"" << this->id << "\")");
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void
 ElementTypeMapArray<T, SupportType>::setArray(const SupportType & type,
                                               const GhostType & ghost_type,
                                               const Array<T> & vect) {
   auto it = this->getData(ghost_type).find(type);
 
   if (AKANTU_DEBUG_TEST(dblWarning) && it != this->getData(ghost_type).end() &&
       it->second != &vect) {
     AKANTU_DEBUG_WARNING(
         "The Array "
         << this->printType(type, ghost_type)
         << " is already registred, this call can lead to a memory leak.");
   }
 
   this->getData(ghost_type)[type] = &(const_cast<Array<T> &>(vect));
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 inline void ElementTypeMapArray<T, SupportType>::onElementsRemoved(
     const ElementTypeMapArray<UInt> & new_numbering) {
   for (auto gt : ghost_types) {
     for (auto & type :
          new_numbering.elementTypes(_all_dimensions, gt, _ek_not_defined)) {
       SupportType support_type = convertType<ElementType, SupportType>(type);
       if (this->exists(support_type, gt)) {
         const auto & renumbering = new_numbering(type, gt);
         if (renumbering.size() == 0)
           continue;
 
         auto & vect = this->operator()(support_type, gt);
         auto nb_component = vect.getNbComponent();
         Array<T> tmp(renumbering.size(), nb_component);
         UInt new_size = 0;
 
         for (UInt i = 0; i < vect.size(); ++i) {
           UInt new_i = renumbering(i);
           if (new_i != UInt(-1)) {
             memcpy(tmp.storage() + new_i * nb_component,
                    vect.storage() + i * nb_component, nb_component * sizeof(T));
             ++new_size;
           }
         }
         tmp.resize(new_size);
         vect.copy(tmp);
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 void ElementTypeMapArray<T, SupportType>::printself(std::ostream & stream,
                                                     int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "ElementTypeMapArray<" << debug::demangle(typeid(T).name())
          << "> [" << std::endl;
   for (UInt g = _not_ghost; g <= _ghost; ++g) {
     GhostType gt = (GhostType)g;
 
     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>
+template <typename P, typename T, typename... pack>
+typename ElementTypeMap<Stored, SupportType>::ElementTypesIteratorHelper
+ElementTypeMap<Stored, SupportType>::elementTypes(
+    named_argument::param_t<P, T &&> && first, pack &&... _pack) const {
+  return ElementTypesIteratorHelper(*this, use_named_args, first, _pack...);
+}
+
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator
 ElementTypeMap<Stored, SupportType>::firstType(UInt dim, GhostType ghost_type,
                                                ElementKind kind) const {
   typename DataMap::const_iterator b, e;
   b = getData(ghost_type).begin();
   e = getData(ghost_type).end();
 
   // loop until the first valid type
   while ((b != e) &&
          (((dim != _all_dimensions) &&
            (dim != Mesh::getSpatialDimension(b->first))) ||
           ((kind != _ek_not_defined) && (kind != Mesh::getKind(b->first)))))
     ++b;
 
   return typename ElementTypeMap<Stored, SupportType>::type_iterator(b, e, dim,
                                                                      kind);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Stored, typename SupportType>
 inline typename ElementTypeMap<Stored, SupportType>::type_iterator
 ElementTypeMap<Stored, SupportType>::lastType(UInt dim, GhostType ghost_type,
                                               ElementKind kind) const {
   typename DataMap::const_iterator e;
   e = getData(ghost_type).end();
   return typename ElementTypeMap<Stored, SupportType>::type_iterator(e, e, dim,
                                                                      kind);
 }
 
 /* -------------------------------------------------------------------------- */
 
 /// standard output stream operator
 template <class Stored, typename SupportType>
 inline std::ostream &
 operator<<(std::ostream & stream,
            const ElementTypeMap<Stored, SupportType> & _this) {
   _this.printself(stream);
   return stream;
 }
 
 /* -------------------------------------------------------------------------- */
 class ElementTypeMapArrayInializer {
 public:
   ElementTypeMapArrayInializer(UInt spatial_dimension = _all_dimensions,
                                UInt nb_component = 1,
                                const GhostType & ghost_type = _not_ghost,
                                const ElementKind & element_kind = _ek_regular)
       : spatial_dimension(spatial_dimension), nb_component(nb_component),
         ghost_type(ghost_type), element_kind(element_kind) {}
 
   const GhostType & ghostType() const { return ghost_type; }
 
 protected:
   UInt spatial_dimension;
   UInt nb_component;
   GhostType ghost_type;
   ElementKind element_kind;
 };
 
 /* -------------------------------------------------------------------------- */
 class MeshElementTypeMapArrayInializer : public ElementTypeMapArrayInializer {
 public:
   MeshElementTypeMapArrayInializer(
       const Mesh & mesh, UInt nb_component = 1,
       UInt spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_regular,
       bool with_nb_element = false, bool with_nb_nodes_per_element = false)
       : ElementTypeMapArrayInializer(spatial_dimension, nb_component,
                                      ghost_type, element_kind),
         mesh(mesh), with_nb_element(with_nb_element),
         with_nb_nodes_per_element(with_nb_nodes_per_element) {}
 
   decltype(auto) elementTypes() const {
     return mesh.elementTypes(this->spatial_dimension, this->ghost_type,
                              this->element_kind);
   }
 
   virtual UInt size(const ElementType & type) const {
     if (with_nb_element)
       return mesh.getNbElement(type, this->ghost_type);
 
     return 0;
   }
 
   UInt nbComponent(const ElementType & type) const {
     if (with_nb_nodes_per_element)
       return (this->nb_component * mesh.getNbNodesPerElement(type));
 
     return this->nb_component;
   }
 
 protected:
   const Mesh & mesh;
   bool with_nb_element;
   bool with_nb_nodes_per_element;
 };
 
 /* -------------------------------------------------------------------------- */
 class FEEngineElementTypeMapArrayInializer
     : public MeshElementTypeMapArrayInializer {
 public:
   FEEngineElementTypeMapArrayInializer(
       const FEEngine & fe_engine, UInt nb_component = 1,
       UInt spatial_dimension = _all_dimensions,
       const GhostType & ghost_type = _not_ghost,
       const ElementKind & element_kind = _ek_regular);
 
   UInt size(const ElementType & type) const override;
 
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<Real, ElementType>::ElementTypesIteratorHelper;
 
   ElementTypesIteratorHelper elementTypes() const;
 
 protected:
   const FEEngine & fe_engine;
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename T, typename SupportType>
 template <class Func>
 void ElementTypeMapArray<T, SupportType>::initialize(const Func & f,
                                                      const T & default_value) {
   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);
   }
 }
 
-namespace {
-  DECLARE_NAMED_ARGUMENT(all_ghost_types);
-  DECLARE_NAMED_ARGUMENT(default_value);
-  DECLARE_NAMED_ARGUMENT(element_kind);
-  DECLARE_NAMED_ARGUMENT(ghost_type);
-  DECLARE_NAMED_ARGUMENT(nb_component);
-  DECLARE_NAMED_ARGUMENT(with_nb_element);
-  DECLARE_NAMED_ARGUMENT(with_nb_nodes_per_element);
-  DECLARE_NAMED_ARGUMENT(spatial_dimension);
-} // namespace
-
 /* -------------------------------------------------------------------------- */
 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()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, typename SupportType>
 inline T & ElementTypeMapArray<T, SupportType>::
 operator()(const Element & element) {
   return this->operator()(element.type, element.ghost_type)(element.element);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T, typename SupportType>
 inline const T & ElementTypeMapArray<T, SupportType>::
 operator()(const Element & element) const {
   return this->operator()(element.type, element.ghost_type)(element.element);
 }
 
 } // namespace akantu
 
 #endif /* __AKANTU_ELEMENT_TYPE_MAP_TMPL_HH__ */
diff --git a/src/mesh/mesh.hh b/src/mesh/mesh.hh
index f595fe475..442960aec 100644
--- a/src/mesh/mesh.hh
+++ b/src/mesh/mesh.hh
@@ -1,612 +1,611 @@
 /**
  * @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().size() != 0)
     EventHandlerManager<MeshEventHandler>::sendEvent<Event>(event);
   }
 
   /// prepare the  event to remove the elements listed
   void eraseElements(const Array<Element> & elements);
 
   /* ------------------------------------------------------------------------ */
   template <typename T>
   inline void removeNodesFromArray(Array<T> & vect,
                                    const Array<UInt> & new_numbering);
 
   /// initialize normals
   void initNormals();
 
   /// init facets' mesh
   Mesh & initMeshFacets(const ID & id = "mesh_facets");
 
   /// define parent mesh
   void defineMeshParent(const Mesh & mesh);
 
   /// get global connectivity array
   void getGlobalConnectivity(ElementTypeMapArray<UInt> & global_connectivity,
                              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->size(), UInt);
 
   /// get the Array of global ids of the nodes (only used in parallel)
   AKANTU_GET_MACRO(GlobalNodesIds, *nodes_global_ids, const Array<UInt> &);
   AKANTU_GET_MACRO_NOT_CONST(GlobalNodesIds, *nodes_global_ids, Array<UInt> &);
 
   /// get the global id of a node
   inline UInt getNodeGlobalId(UInt local_id) const;
 
   /// get the global id of a node
   inline UInt getNodeLocalId(UInt global_id) const;
 
   /// get the global number of nodes
   inline UInt getNbGlobalNodes() const;
 
   /// get the nodes type Array
   AKANTU_GET_MACRO(NodesType, nodes_type, const Array<NodeType> &);
 
 protected:
   AKANTU_GET_MACRO_NOT_CONST(NodesType, nodes_type, Array<NodeType> &);
 
 public:
   inline NodeType getNodeType(UInt local_id) const;
 
   /// say if a node is a pure ghost node
   inline bool isPureGhostNode(UInt n) const;
 
   /// say if a node is pur local or master node
   inline bool isLocalOrMasterNode(UInt n) const;
 
   inline bool isLocalNode(UInt n) const;
   inline bool isMasterNode(UInt n) const;
   inline bool isSlaveNode(UInt n) const;
 
   AKANTU_GET_MACRO(LowerBounds, lower_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(UpperBounds, upper_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(LocalLowerBounds, local_lower_bounds, const Vector<Real> &);
   AKANTU_GET_MACRO(LocalUpperBounds, local_upper_bounds, const Vector<Real> &);
 
   /// get the connectivity Array for a given type
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Connectivity, connectivities, UInt);
   AKANTU_GET_MACRO(Connectivities, connectivities,
                    const ElementTypeMapArray<UInt> &);
 
   /// get the number of element of a type in the mesh
   inline UInt getNbElement(const ElementType & type,
                            const GhostType & ghost_type = _not_ghost) const;
 
   /// get the number of element for a given ghost_type and a given dimension
   inline UInt getNbElement(const UInt spatial_dimension = _all_dimensions,
                            const GhostType & ghost_type = _not_ghost,
                            const ElementKind & kind = _ek_not_defined) const;
 
   // /// get the connectivity list either for the elements or the ghost elements
   // inline const ConnectivityTypeList &
   // getConnectivityTypeList(const GhostType & ghost_type = _not_ghost) const;
 
   /// compute the barycenter of a given element
   inline void getBarycenter(UInt element, const ElementType & type,
                             Real * barycenter,
                             GhostType ghost_type = _not_ghost) const;
   inline void getBarycenter(const Element & element,
                             Vector<Real> & barycenter) const;
 
   /// get the element connected to a subelement
   const Array<std::vector<Element>> &
   getElementToSubelement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
   /// get the element connected to a subelement
   Array<std::vector<Element>> &
   getElementToSubelement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// get the subelement connected to an element
   const Array<Element> &
   getSubelementToElement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost) const;
   /// get the subelement connected to an element
   Array<Element> &
   getSubelementToElement(const ElementType & el_type,
                          const GhostType & ghost_type = _not_ghost);
 
   /// register a new ElementalTypeMap in the MeshData
   template <typename T>
   inline ElementTypeMapArray<T> & registerData(const std::string & data_name);
 
   template <typename T>
   inline bool hasData(const ID & data_name, const ElementType & el_type,
                       const GhostType & ghost_type = _not_ghost) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const Array<T> &
   getData(const ID & data_name, const ElementType & el_type,
           const GhostType & ghost_type = _not_ghost) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline Array<T> & getData(const ID & data_name, const ElementType & el_type,
                             const GhostType & ghost_type = _not_ghost);
 
   /// get a name field associated to the mesh
   template <typename T>
   inline const ElementTypeMapArray<T> & getData(const ID & data_name) const;
 
   /// get a name field associated to the mesh
   template <typename T>
   inline ElementTypeMapArray<T> & getData(const ID & data_name);
 
   template <typename T>
   ElementTypeMap<UInt> getNbDataPerElem(ElementTypeMapArray<T> & array,
                                         const ElementKind & element_kind);
 
   template <typename T>
   dumper::Field * createFieldFromAttachedData(const std::string & field_id,
                                               const std::string & group_name,
                                               const ElementKind & element_kind);
 
   /// templated getter returning the pointer to data in MeshData (modifiable)
   template <typename T>
   inline Array<T> &
   getDataPointer(const std::string & data_name, const ElementType & el_type,
                  const GhostType & ghost_type = _not_ghost,
                  UInt nb_component = 1, bool size_to_nb_element = true,
                  bool resize_with_parent = false);
 
   /// Facets mesh accessor
   inline const Mesh & getMeshFacets() const;
   inline Mesh & getMeshFacets();
 
   /// Parent mesh accessor
   inline const Mesh & getMeshParent() const;
 
   inline bool isMeshFacets() const { return this->is_mesh_facets; }
 
   /// defines is the mesh is distributed or not
   inline bool isDistributed() const { return this->is_distributed; }
 
 #ifndef SWIG
   /// return the dumper from a group and and a dumper name
   DumperIOHelper & getGroupDumper(const std::string & dumper_name,
                                   const std::string & group_name);
 #endif
   /* ------------------------------------------------------------------------ */
   /* Wrappers on ElementClass functions                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the number of nodes per element for a given element type
   static inline UInt getNbNodesPerElement(const ElementType & type);
 
   /// get the number of nodes per element for a given element type considered as
   /// a first order element
   static inline ElementType getP1ElementType(const ElementType & type);
 
   /// get the kind of the element type
   static inline ElementKind getKind(const ElementType & type);
 
   /// get spatial dimension of a type of element
   static inline UInt getSpatialDimension(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type);
 
   /// get number of facets of a given element type
   static inline UInt getNbFacetsPerElement(const ElementType & type, UInt t);
 
   /// get local connectivity of a facet for a given facet type
   static inline MatrixProxy<UInt>
   getFacetLocalConnectivity(const ElementType & type, UInt t = 0);
 
   /// get connectivity of facets for a given element
   inline Matrix<UInt> getFacetConnectivity(const Element & element,
                                            UInt t = 0) const;
 
   /// get the number of type of the surface element associated to a given
   /// element type
   static inline UInt getNbFacetTypes(const ElementType & type, UInt t = 0);
 
   /// get the type of the surface element associated to a given element
   static inline ElementType getFacetType(const ElementType & type, UInt t = 0);
 
   /// get all the type of the surface element associated to a given element
   static inline VectorProxy<ElementType>
   getAllFacetTypes(const ElementType & type);
 
   /// get the number of nodes in the given element list
   static inline UInt getNbNodesPerElementList(const Array<Element> & elements);
 
   /* ------------------------------------------------------------------------ */
   /* Element type Iterator                                                    */
   /* ------------------------------------------------------------------------ */
   using type_iterator = ElementTypeMapArray<UInt, ElementType>::type_iterator;
   using ElementTypesIteratorHelper =
       ElementTypeMapArray<UInt, ElementType>::ElementTypesIteratorHelper;
 
-  inline ElementTypesIteratorHelper
-  elementTypes(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost,
-               ElementKind kind = _ek_regular) const {
-    return connectivities.elementTypes(dim, ghost_type, kind);
+  template <typename... pack>
+  ElementTypesIteratorHelper elementTypes(pack &&... _pack) const {
+    return connectivities.elementTypes(_pack...);
   }
 
   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 the ghost element counter
   inline Array<UInt> &
   getGhostsCounters(const ElementType & type,
                     const GhostType & ghost_type = _ghost) {
     AKANTU_DEBUG_ASSERT(ghost_type != _not_ghost,
                         "No ghost counter for _not_ghost elements");
     return ghosts_counters(type, ghost_type);
   }
 
   /// get a pointer to the element_to_subelement Array for the given type and
   /// create it if necessary
   inline Array<std::vector<Element>> &
   getElementToSubelementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   /// get a pointer to the subelement_to_element Array for the given type and
   /// create it if necessary
   inline Array<Element> &
   getSubelementToElementPointer(const ElementType & type,
                                 const GhostType & ghost_type = _not_ghost);
 
   AKANTU_GET_MACRO_NOT_CONST(MeshData, mesh_data, MeshData &);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// array of the nodes coordinates
   std::shared_ptr<Array<Real>> nodes;
 
   /// global node ids
   std::unique_ptr<Array<UInt>> nodes_global_ids;
 
   /// node type,  -3 pure ghost, -2  master for the  node, -1 normal node,  i in
   /// [0-N] slave node and master is proc i
   Array<NodeType> nodes_type;
 
   /// global number of nodes;
   UInt nb_global_nodes{0};
 
   /// all class of elements present in this mesh (for heterogenous meshes)
   ElementTypeMapArray<UInt> connectivities;
 
   /// count the references on ghost elements
   ElementTypeMapArray<UInt> ghosts_counters;
 
   /// map to normals for all class of elements present in this mesh
   ElementTypeMapArray<Real> normals;
 
   /// list of all existing types in the mesh
   // ConnectivityTypeList type_set;
 
   /// the spatial dimension of this mesh
   UInt spatial_dimension{0};
 
   /// types offsets
   // Array<UInt> types_offsets;
 
   // /// list of all existing types in the mesh
   // ConnectivityTypeList ghost_type_set;
   // /// ghost types offsets
   // Array<UInt> ghost_types_offsets;
 
   /// min of coordinates
   Vector<Real> lower_bounds;
   /// max of coordinates
   Vector<Real> upper_bounds;
   /// size covered by the mesh on each direction
   Vector<Real> size;
 
   /// local min of coordinates
   Vector<Real> local_lower_bounds;
   /// local max of coordinates
   Vector<Real> local_upper_bounds;
 
   /// Extra data loaded from the mesh file
   MeshData mesh_data;
 
   /// facets' mesh
   std::unique_ptr<Mesh> mesh_facets;
 
   /// parent mesh (this is set for mesh_facets meshes)
   const Mesh * mesh_parent{nullptr};
 
   /// defines if current mesh is mesh_facets or not
   bool is_mesh_facets{false};
 
   /// defines if the mesh is centralized or distributed
   bool is_distributed{false};
 
   /// Communicator on which mesh is distributed
   const 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_iterators.hh b/src/mesh/mesh_iterators.hh
index c7afa11ac..e0b7cba39 100644
--- a/src/mesh/mesh_iterators.hh
+++ b/src/mesh/mesh_iterators.hh
@@ -1,251 +1,302 @@
 /**
 
  * @file   mesh_iterators.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  Wed Aug 09 2017
  *
  * @brief Set of helper classes to have fun with range based for
  *
  * @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_named_argument.hh"
+#include "aka_static_if.hh"
 #include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MESH_ITERATORS_HH__
 #define __AKANTU_MESH_ITERATORS_HH__
 
 namespace akantu {
 
 class MeshElementsByTypes {
   using elements_iterator = Array<Element>::scalar_iterator;
 
 public:
   explicit MeshElementsByTypes(const Array<Element> & elements) {
     this->elements.copy(elements);
     std::sort(this->elements.begin(), this->elements.end());
   }
 
   /* ------------------------------------------------------------------------ */
   class MeshElementsRange {
   public:
     MeshElementsRange() = default;
 
     MeshElementsRange(const elements_iterator & begin,
                       const elements_iterator & end)
         : type((*begin).type), ghost_type((*begin).ghost_type), begin(begin),
           end(end) {}
 
     AKANTU_GET_MACRO(Type, type, const ElementType &);
     AKANTU_GET_MACRO(GhostType, ghost_type, const GhostType &);
 
     const Array<UInt> & getElements() {
       elements.resize(end - begin);
       auto el_it = elements.begin();
       for (auto it = begin; it != end; ++it, ++el_it) {
         *el_it = it->element;
       }
 
       return elements;
     }
 
   private:
     ElementType type{_not_defined};
     GhostType ghost_type{_casper};
     elements_iterator begin;
     elements_iterator end;
     Array<UInt> elements;
   };
 
   /* ------------------------------------------------------------------------ */
   class iterator {
     struct element_comparator {
       bool operator()(const Element & lhs, const Element & rhs) const {
         bool res =
             ((lhs.kind < rhs.kind) ||
              ((lhs.kind == rhs.kind) && ((lhs.ghost_type < rhs.ghost_type) ||
                                          ((lhs.ghost_type == rhs.ghost_type) &&
                                           ((lhs.type < rhs.type))))));
         return res;
       }
     };
 
   public:
     iterator(const iterator &) = default;
     iterator(const elements_iterator & first, const elements_iterator & last)
         : range(std::equal_range(first, last, *first, element_comparator())),
           first(first), last(last) {}
 
     decltype(auto) operator*() const {
       return MeshElementsRange(range.first, range.second);
     }
 
     iterator operator++() {
       first = range.second;
       range = std::equal_range(first, last, *first, element_comparator());
       return *this;
     }
 
     bool operator==(const iterator & other) const {
       return (first == other.first and last == other.last);
     }
 
     bool operator!=(const iterator & other) const {
       return (not operator==(other));
     }
 
   private:
     std::pair<elements_iterator, elements_iterator> range;
     elements_iterator first;
     elements_iterator last;
   };
 
   iterator begin() { return iterator(elements.begin(), elements.end()); }
   iterator end() { return iterator(elements.end(), elements.end()); }
 
 private:
   Array<Element> elements;
 };
 
 /* -------------------------------------------------------------------------- */
 namespace mesh_iterators {
   namespace details {
     template <class internal_iterator> class delegated_iterator {
     public:
-      using value_type = std::remove_pointer_t<typename internal_iterator::value_type::second_type>;
-      using pointer = value_type*;
-      using reference = value_type&;
+      using value_type = std::remove_pointer_t<
+          typename internal_iterator::value_type::second_type>;
+      using pointer = value_type *;
+      using reference = value_type &;
       using iterator_category = std::input_iterator_tag;
 
       explicit delegated_iterator(internal_iterator it) : it(std::move(it)) {}
 
       decltype(auto) operator*() {
         return std::forward<decltype(*(it->second))>(*(it->second));
       }
 
       delegated_iterator operator++() {
         ++it;
         return *this;
       }
 
       bool operator==(const delegated_iterator & other) const {
         return other.it == it;
       }
 
       bool operator!=(const delegated_iterator & other) const {
         return other.it != it;
       }
 
     private:
       internal_iterator it;
     };
 
     template <class GroupManager> class ElementGroupsIterable {
     public:
       explicit ElementGroupsIterable(GroupManager && group_manager)
           : group_manager(std::forward<GroupManager>(group_manager)) {}
 
       size_t size() { return group_manager.getNbElementGroups(); }
       decltype(auto) begin() {
         return delegated_iterator<decltype(
             group_manager.element_group_begin())>(
             group_manager.element_group_begin());
       }
 
       decltype(auto) begin() const {
         return delegated_iterator<decltype(
             group_manager.element_group_begin())>(
             group_manager.element_group_begin());
       }
 
       decltype(auto) end() {
         return delegated_iterator<decltype(group_manager.element_group_end())>(
             group_manager.element_group_end());
       }
 
       decltype(auto) end() const {
         return delegated_iterator<decltype(group_manager.element_group_end())>(
             group_manager.element_group_end());
       }
 
     private:
       GroupManager && group_manager;
     };
 
     template <class GroupManager> class NodeGroupsIterable {
     public:
       explicit NodeGroupsIterable(GroupManager && group_manager)
           : group_manager(std::forward<GroupManager>(group_manager)) {}
 
       size_t size() { return group_manager.getNbNodeGroups(); }
       decltype(auto) begin() {
         return delegated_iterator<decltype(group_manager.node_group_begin())>(
             group_manager.node_group_begin());
       }
 
       decltype(auto) begin() const {
         return delegated_iterator<decltype(group_manager.node_group_begin())>(
             group_manager.node_group_begin());
       }
 
       decltype(auto) end() {
         return delegated_iterator<decltype(group_manager.node_group_end())>(
             group_manager.node_group_end());
       }
 
       decltype(auto) end() const {
         return delegated_iterator<decltype(group_manager.node_group_end())>(
             group_manager.node_group_end());
       }
 
     private:
       GroupManager && group_manager;
     };
   } // namespace details
 } // namespace mesh_iterators
 
 template <class GroupManager>
 decltype(auto) ElementGroupsIterable(GroupManager && group_manager) {
-  return mesh_iterators::details::ElementGroupsIterable<GroupManager>(group_manager);
+  return mesh_iterators::details::ElementGroupsIterable<GroupManager>(
+      group_manager);
 }
 
 template <class GroupManager>
 decltype(auto) NodeGroupsIterable(GroupManager && group_manager) {
-  return mesh_iterators::details::NodeGroupsIterable<GroupManager>(group_manager);
+  return mesh_iterators::details::NodeGroupsIterable<GroupManager>(
+      group_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Func>
-void for_each_elements(size_t nb_elements, const Array<UInt> & filter_elements, Func && function) {
-  if(filter_elements != empty_filter) {
+void for_each_elements(size_t nb_elements, const Array<UInt> & filter_elements,
+                       Func && function) {
+  if (filter_elements != empty_filter) {
     std::for_each(filter_elements.begin(), filter_elements.end(),
                   std::forward<Func>(function));
   } else {
     auto && range = arange(nb_elements);
-    std::for_each(range.begin(), range.end(),
-                  std::forward<Func>(function));
+    std::for_each(range.begin(), range.end(), std::forward<Func>(function));
   }
 }
 
+namespace {
+  DECLARE_NAMED_ARGUMENT(element_filter);
+}
+
+/* -------------------------------------------------------------------------- */
+template <class Func, typename... pack>
+void for_each_elements(const Mesh & mesh, Func && function, pack &&... _pack) {
+  auto && requested_ghost_type = OPTIONAL_NAMED_ARG(ghost_type, _casper);
+  auto && filter = OPTIONAL_NAMED_ARG(element_filter, nullptr);
+
+  bool all_ghost_types = requested_ghost_type == _casper;
+
+  auto && spatial_dimension =
+      OPTIONAL_NAMED_ARG(spatial_dimension, mesh.getSpatialDimension());
+  auto && element_kind = OPTIONAL_NAMED_ARG(element_kind, _ek_not_defined);
+
+  for (auto && ghost_type : ghost_types) {
+    if ((not(ghost_type == requested_ghost_type)) and (not all_ghost_types))
+      continue;
+
+    auto element_types =
+        mesh.elementTypes(spatial_dimension, ghost_type, element_kind);
+
+    static_if(not std::is_same<decltype(filter), std::nullptr_t>::value)
+        .then([&](auto && element_types) {
+          element_types =
+              filter->elementTypes(spatial_dimension, ghost_type, element_kind);
+        })(std::forward<decltype(element_types)>(element_types));
+
+    for (auto && type : element_types) {
+      const Array<UInt> * filter_array;
+
+      static_if(not std::is_same<decltype(filter), std::nullptr_t>::value)
+          .then([&](auto && array) { array = &((*filter)(type, ghost_type)); })
+          .else_([&](auto && array) { array = &empty_filter; })(
+              std::forward<const Array<UInt> *>(filter_array));
+
+      auto nb_elements = mesh.getNbElement(type, ghost_type);
+
+      for_each_elements(nb_elements, *filter_array, [&](auto && el) {
+        auto element = Element(type, el, ghost_type, mesh.getKind(type));
+        std::forward<Func>(function)(element);
+      });
+    }
+  }
+}
 } // namespace akantu
 
 #endif /* __AKANTU_MESH_ITERATORS_HH__ */
diff --git a/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc b/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
index 6170637e4..5796cfa6a 100644
--- a/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
+++ b/src/mesh_utils/mesh_partition/mesh_partition_scotch.cc
@@ -1,484 +1,481 @@
 /**
  * @file   mesh_partition_scotch.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Jan 22 2016
  *
  * @brief  implementation of the MeshPartitionScotch class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "mesh_partition_scotch.hh"
 #include "aka_common.hh"
 #include "aka_random_generator.hh"
 #include "aka_static_if.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include <cstdio>
 #include <fstream>
 /* -------------------------------------------------------------------------- */
 
 #if !defined(AKANTU_USE_PTSCOTCH)
 #ifndef AKANTU_SCOTCH_NO_EXTERN
 extern "C" {
 #endif // AKANTU_SCOTCH_NO_EXTERN
 #include <scotch.h>
 #ifndef AKANTU_SCOTCH_NO_EXTERN
 }
 #endif // AKANTU_SCOTCH_NO_EXTERN
 #else  // AKANTU_USE_PTSCOTCH
 #include <ptscotch.h>
 #endif // AKANTU_USE_PTSCOTCH
 
 namespace akantu {
 
 namespace {
   constexpr int scotch_version = int(SCOTCH_VERSION);
 }
 
 /* -------------------------------------------------------------------------- */
 MeshPartitionScotch::MeshPartitionScotch(const Mesh & mesh,
                                          UInt spatial_dimension, const ID & id,
                                          const MemoryID & memory_id)
     : MeshPartition(mesh, spatial_dimension, id, memory_id) {
   AKANTU_DEBUG_IN();
 
   // check if the akantu types and Scotch one are consistent
   static_assert(
       sizeof(Int) == sizeof(SCOTCH_Num),
       "The integer type of Akantu does not match the one from Scotch");
 
-  // static_if(scotch_version >= 6)
-  //   .then([](auto && y) {
-  //       SCOTCH_randomSeed(y);
-  //       })
-  //   .else_([](auto && y) {
-  srandom(RandomGenerator<UInt>::seed());//y);
-      // })
-    // (std::forward<UInt>(RandomGenerator<UInt>::seed()));
+  static_if(scotch_version >= 6)
+      .then([](auto && y) { SCOTCH_randomSeed(y); })
+      .else_([](auto && y) {
+        srandom(y);
+      })(std::forward<UInt>(RandomGenerator<UInt>::seed()));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 static SCOTCH_Mesh * createMesh(const Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = mesh.getSpatialDimension();
   UInt nb_nodes = mesh.getNbNodes();
 
   UInt total_nb_element = 0;
   UInt nb_edge = 0;
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension);
   Mesh::type_iterator end = mesh.lastType(spatial_dimension);
   for (; it != end; ++it) {
     ElementType type = *it;
 
     UInt nb_element = mesh.getNbElement(type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
     total_nb_element += nb_element;
     nb_edge += nb_element * nb_nodes_per_element;
   }
 
   SCOTCH_Num vnodbas = 0;
   SCOTCH_Num vnodnbr = nb_nodes;
 
   SCOTCH_Num velmbas = vnodnbr;
   SCOTCH_Num velmnbr = total_nb_element;
 
   SCOTCH_Num * verttab = new SCOTCH_Num[vnodnbr + velmnbr + 1];
   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.size() - 1; // number of vertexes
-  SCOTCH_Num * parttab;                     // array of partitions
-  SCOTCH_Num edgenbr = dxadj(vertnbr);      // twice  the number  of "edges"
+  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/model/boundary_condition_tmpl.hh b/src/model/boundary_condition_tmpl.hh
index a82cfdae7..dbf6f1e2d 100644
--- a/src/model/boundary_condition_tmpl.hh
+++ b/src/model/boundary_condition_tmpl.hh
@@ -1,268 +1,259 @@
 /**
  * @file   boundary_condition_tmpl.hh
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri May 03 2013
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  implementation of the applyBC
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
+#include "boundary_condition.hh"
 #include "element_group.hh"
 /* -------------------------------------------------------------------------- */
 
+#ifndef __AKANTU_BOUNDARY_CONDITION_TMPL_HH__
+#define __AKANTU_BOUNDARY_CONDITION_TMPL_HH__
+
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & dual) {
   this->model = &model;
   this->primal = &primal;
   this->dual = &dual;
   if (this->model->getSpatialDimension() > 1)
     this->model->initFEEngineBoundary();
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 void BoundaryCondition<ModelType>::initBC(ModelType & model,
                                           Array<Real> & primal,
                                           Array<Real> & primal_increment,
                                           Array<Real> & dual) {
   this->initBC(model, primal, dual);
   this->primal_increment = &primal_increment;
 }
+
 /* -------------------------------------------------------------------------- */
 /* Partial specialization for DIRICHLET functors */
 template <typename ModelType>
 template <typename FunctorType>
 struct BoundaryCondition<ModelType>::TemplateFunctionWrapper<
     FunctorType, BC::Functor::_dirichlet> {
   static inline void applyBC(const FunctorType & func,
                              const ElementGroup & group,
                              BoundaryCondition<ModelType> & bc_instance) {
-    ModelType & model = bc_instance.getModel();
-    Array<Real> & primal = bc_instance.getPrimal();
-    const Array<Real> & coords = model.getMesh().getNodes();
-    Array<bool> & boundary_flags = model.getBlockedDOFs();
+    auto & model = bc_instance.getModel();
+    auto & primal = bc_instance.getPrimal();
+
+    const auto & coords = model.getMesh().getNodes();
+    auto & boundary_flags = model.getBlockedDOFs();
     UInt dim = model.getMesh().getSpatialDimension();
 
-    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());
+    auto primal_iter = primal.begin(primal.getNbComponent());
+    auto coords_iter = coords.begin(dim);
+    auto flags_iter = boundary_flags.begin(boundary_flags.getNbComponent());
 
-    for (auto  n : group.getNodeGroup()) {
+    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();
+    auto & model = bc_instance.getModel();
+    auto & dual = bc_instance.getDual();
+    const auto & mesh = model.getMesh();
+    const auto & nodes_coords = mesh.getNodes();
+    const auto & fem_boundary = model.getFEEngineBoundary();
 
     UInt dim = model.getSpatialDimension();
     UInt nb_degree_of_freedom = dual.getNbComponent();
 
     IntegrationPoint quad_point;
     quad_point.ghost_type = ghost_type;
 
-    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();
+    for (auto && type : group.elementTypes(dim - 1, ghost_type)) {
+      const auto & element_ids = group.getElements(type, ghost_type);
 
       UInt nb_quad_points =
-          fem_boundary.getNbIntegrationPoints(*type_it, ghost_type);
+          fem_boundary.getNbIntegrationPoints(type, ghost_type);
       UInt nb_elements = element_ids.size();
-      UInt nb_nodes_per_element = mesh.getNbNodesPerElement(*type_it);
+      UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
       Array<Real> * dual_before_integ = new Array<Real>(
           nb_elements * nb_quad_points, nb_degree_of_freedom, 0.);
       Array<Real> * quad_coords =
           new Array<Real>(nb_elements * nb_quad_points, dim);
 
-      const Array<Real> & normals_on_quad =
-          fem_boundary.getNormalsOnIntegrationPoints(*type_it, ghost_type);
+      const auto & normals_on_quad =
+          fem_boundary.getNormalsOnIntegrationPoints(type, 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;
+          nodes_coords, *quad_coords, dim, type, ghost_type, element_ids);
+      auto normals_begin = normals_on_quad.begin(dim);
+      decltype(normals_begin) normals_iter;
+      auto quad_coords_iter = quad_coords->begin(dim);
+      auto dual_iter = dual_before_integ->begin(nb_degree_of_freedom);
+
+      quad_point.type = type;
+      for (auto el : element_ids) {
         quad_point.element = el;
         normals_iter = normals_begin + el * nb_quad_points;
-        for (UInt q(0); q < nb_quad_points; ++q) {
+        for (auto && q : arange(nb_quad_points)) {
           quad_point.num_point = q;
           func(quad_point, *dual_iter, *quad_coords_iter, *normals_iter);
           ++dual_iter;
           ++quad_coords_iter;
           ++normals_iter;
         }
       }
 
       delete quad_coords;
 
       /* -------------------------------------------------------------------- */
       // Initialization of iterators
-      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);
+      auto dual_iter_mat = dual_before_integ->begin(nb_degree_of_freedom, 1);
+      auto shapes_iter_begin = fem_boundary.getShapes(type, ghost_type)
+                                   .begin(1, nb_nodes_per_element);
 
       Array<Real> * dual_by_shapes =
           new Array<Real>(nb_elements * nb_quad_points,
                           nb_degree_of_freedom * nb_nodes_per_element);
 
-      Array<Real>::matrix_iterator dual_by_shapes_iter =
+      auto 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 (auto el : element_ids) {
+        auto shapes_iter = shapes_iter_begin + el * nb_quad_points;
 
         for (UInt q(0); q < nb_quad_points;
              ++q, ++dual_iter_mat, ++dual_by_shapes_iter, ++shapes_iter) {
           dual_by_shapes_iter->mul<false, false>(*dual_iter_mat, *shapes_iter);
         }
       }
 
       delete dual_before_integ;
 
       Array<Real> * dual_by_shapes_integ = new Array<Real>(
           nb_elements, nb_degree_of_freedom * nb_nodes_per_element);
       fem_boundary.integrate(*dual_by_shapes, *dual_by_shapes_integ,
-                             nb_degree_of_freedom * nb_nodes_per_element,
-                             *type_it, ghost_type, element_ids);
+                             nb_degree_of_freedom * nb_nodes_per_element, type,
+                             ghost_type, element_ids);
       delete dual_by_shapes;
 
       // assemble the result into force vector
       model.getDOFManager().assembleElementalArrayLocalArray(
-          *dual_by_shapes_integ, dual, *type_it, ghost_type, 1., element_ids);
+          *dual_by_shapes_integ, dual, type, ghost_type, 1., element_ids);
       delete dual_by_shapes_integ;
     }
   }
 };
 
 /* -------------------------------------------------------------------------- */
 template <typename ModelType>
 template <typename FunctorType>
 inline void BoundaryCondition<ModelType>::applyBC(const FunctorType & func) {
   GroupManager::const_element_group_iterator bit =
       model->getMesh().getGroupManager().element_group_begin();
   GroupManager::const_element_group_iterator bend =
       model->getMesh().getGroupManager().element_group_end();
   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
+#endif /* __AKANTU_BOUNDARY_CONDITION_TMPL_HH__ */
+
+} // namespace akantu
diff --git a/src/model/model.cc b/src/model/model.cc
index 4626eb683..3cc0b81d7 100644
--- a/src/model/model.cc
+++ b/src/model/model.cc
@@ -1,345 +1,352 @@
 /**
  * @file   model.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Oct 03 2011
  * @date last modification: Thu Nov 19 2015
  *
  * @brief  implementation of model common parts
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 #include "element_group.hh"
 #include "synchronizer_registry.hh"
 #include "data_accessor.hh"
 #include "static_communicator.hh"
 #include "element_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Model::Model(Mesh& mesh, UInt dim, const ID & id,
              const MemoryID & memory_id) :
   Memory(id, memory_id), ModelSolver(mesh, id, memory_id),
   mesh(mesh),
   spatial_dimension(dim == _all_dimensions ? mesh.getSpatialDimension() : dim),
   is_pbc_slave_node(0,1,"is_pbc_slave_node") ,
-  parser(&getStaticParser()) {
+  parser(getStaticParser()) {
   AKANTU_DEBUG_IN();
 
   this->mesh.registerEventHandler(*this, _ehp_model);
   
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
-Model::~Model() {
-  AKANTU_DEBUG_IN();
+Model::~Model() = default;
 
-  FEEngineMap::iterator it;
-  for (it = fems.begin(); it != fems.end(); ++it) {
-    if (it->second)
-      delete it->second;
-  }
+/* -------------------------------------------------------------------------- */
+//void Model::setParser(Parser & parser) { this->parser = &parser; }
 
-  for (it = fems_boundary.begin(); it != fems_boundary.end(); ++it) {
-    if (it->second)
-      delete it->second;
+/* -------------------------------------------------------------------------- */
+void Model::initFull(const ModelOptions & options) {
+  AKANTU_DEBUG_IN();
+
+  method = options.analysis_method;
+  if (!this->hasDefaultSolver()) {
+    this->initNewSolver(this->method);
   }
+  initModel();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
-void Model::setParser(Parser & parser) { this->parser = &parser; }
+void Model::initNewSolver(const AnalysisMethod & method) {
+  ID solver_name;
+  TimeStepSolverType tss_type;
+  std::tie(solver_name, tss_type) = this->getDefaultSolverID(method);
 
-/* -------------------------------------------------------------------------- */
-void Model::initFull(__attribute__((unused)) const ModelOptions & options) {
-  AKANTU_DEBUG_IN();
-
-  initModel();
+  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"]);
+  }
 
-  AKANTU_DEBUG_OUT();
+  this->method = method;
+  this->setDefaultSolver(solver_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::initPBC() {
   std::map<UInt, UInt>::iterator it = pbc_pair.begin();
   std::map<UInt, UInt>::iterator end = pbc_pair.end();
 
   is_pbc_slave_node.resize(mesh.getNbNodes());
 #ifndef AKANTU_NDEBUG
   Array<Real>::const_vector_iterator coord_it =
       mesh.getNodes().begin(this->spatial_dimension);
 #endif
 
   while (it != end) {
     UInt i1 = (*it).first;
 
     is_pbc_slave_node(i1) = true;
 
 #ifndef AKANTU_NDEBUG
     UInt i2 = (*it).second;
     UInt slave = mesh.isDistributed() ? mesh.getGlobalNodesIds()(i1) : i1;
     UInt master = mesh.isDistributed() ? mesh.getGlobalNodesIds()(i2) : i2;
 
     AKANTU_DEBUG_INFO("pairing " << slave << " (" << Vector<Real>(coord_it[i1])
                                  << ") with " << master << " ("
                                  << Vector<Real>(coord_it[i2]) << ")");
 #endif
     ++it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dumpGroup(const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dumpGroup(const std::string & group_name,
                       const std::string & dumper_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.dump(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dumpGroup() {
   GroupManager::element_group_iterator bit = mesh.element_group_begin();
   GroupManager::element_group_iterator bend = mesh.element_group_end();
   for (; bit != bend; ++bit) {
     bit->second->dump();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setGroupDirectory(const std::string & directory) {
   GroupManager::element_group_iterator bit = mesh.element_group_begin();
   GroupManager::element_group_iterator bend = mesh.element_group_end();
   for (; bit != bend; ++bit) {
     bit->second->setDirectory(directory);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setGroupDirectory(const std::string & directory,
                               const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setGroupBaseName(const std::string & basename,
                              const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.setBaseName(basename);
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Model::getGroupDumper(const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   return group.getDumper();
 }
 
 /* -------------------------------------------------------------------------- */
 // DUMPER stuff
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldToDumper(const std::string & field_id,
                                       dumper::Field * field,
                                       DumperIOHelper & dumper) {
 #ifdef AKANTU_USE_IOHELPER
   dumper.registerField(field_id, field);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpField(const std::string & field_id) {
 
   this->addDumpFieldToDumper(mesh.getDefaultDumperName(), field_id);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::addDumpFieldVector(const std::string & field_id) {
 
   this->addDumpFieldVectorToDumper(mesh.getDefaultDumperName(), field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpFieldTensor(const std::string & field_id) {
 
   this->addDumpFieldTensorToDumper(mesh.getDefaultDumperName(), field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setBaseName(const std::string & field_id) {
 
   mesh.setBaseName(field_id);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::setBaseNameToDumper(const std::string & dumper_name,
                                 const std::string & basename) {
   mesh.setBaseNameToDumper(dumper_name, basename);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::addDumpFieldToDumper(const std::string & dumper_name,
                                  const std::string & field_id) {
 
   this->addDumpGroupFieldToDumper(dumper_name, field_id, "all", _ek_regular,
                                   false);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupField(const std::string & field_id,
                               const std::string & group_name) {
 
   ElementGroup & group = mesh.getElementGroup(group_name);
   this->addDumpGroupFieldToDumper(group.getDefaultDumperName(), field_id,
                                   group_name, _ek_regular, false);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::removeDumpGroupField(const std::string & field_id,
                                  const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   this->removeDumpGroupFieldFromDumper(group.getDefaultDumperName(), field_id,
                                        group_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::removeDumpGroupFieldFromDumper(const std::string & dumper_name,
                                            const std::string & field_id,
                                            const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   group.removeDumpFieldFromDumper(dumper_name, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpFieldVectorToDumper(const std::string & dumper_name,
                                        const std::string & field_id) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, "all", _ek_regular, 3);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldVector(const std::string & field_id,
                                     const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   this->addDumpGroupFieldVectorToDumper(group.getDefaultDumperName(), field_id,
                                         group_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldVectorToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             const std::string & group_name) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, group_name,
                                   _ek_regular, true);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::addDumpFieldTensorToDumper(const std::string & dumper_name,
                                        const std::string & field_id) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, "all", _ek_regular,
                                   true);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldToDumper(const std::string & dumper_name,
                                       const std::string & field_id,
                                       const std::string & group_name,
                                       const ElementKind & element_kind,
                                       bool padding_flag) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, group_name,
                                   this->spatial_dimension, element_kind,
                                   padding_flag);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldToDumper(const std::string & dumper_name,
                                       const std::string & field_id,
                                       const std::string & group_name,
                                       UInt spatial_dimension,
                                       const ElementKind & element_kind,
                                       bool padding_flag) {
 
 #ifdef AKANTU_USE_IOHELPER
   dumper::Field * field = NULL;
 
   if (!field)
     field = this->createNodalFieldReal(field_id, group_name, padding_flag);
   if (!field)
     field = this->createNodalFieldUInt(field_id, group_name, padding_flag);
   if (!field)
     field = this->createNodalFieldBool(field_id, group_name, padding_flag);
   if (!field)
     field = this->createElementalField(field_id, group_name, padding_flag,
                                        spatial_dimension, element_kind);
   if (!field)
     field = this->mesh.createFieldFromAttachedData<UInt>(field_id, group_name,
                                                          element_kind);
   if (!field)
     field = this->mesh.createFieldFromAttachedData<Real>(field_id, group_name,
                                                          element_kind);
 
   if (!field)
     AKANTU_DEBUG_WARNING("No field could be found based on name: " << field_id);
   if (field) {
     DumperIOHelper & dumper = mesh.getGroupDumper(dumper_name, group_name);
     this->addDumpGroupFieldToDumper(field_id, field, dumper);
   }
 
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::dump() { mesh.dump(); }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setDirectory(const std::string & directory) {
   mesh.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setDirectoryToDumper(const std::string & dumper_name,
                                  const std::string & directory) {
   mesh.setDirectoryToDumper(dumper_name, directory);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Model::setTextModeToDumper() { mesh.setTextModeToDumper(); }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
diff --git a/src/model/model.hh b/src/model/model.hh
index 5f09fbed3..8036a5bef 100644
--- a/src/model/model.hh
+++ b/src/model/model.hh
@@ -1,319 +1,349 @@
 /**
  * @file   model.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Oct 16 2015
  *
  * @brief  Interface of a model
  *
  * @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_memory.hh"
 #include "fe_engine.hh"
 #include "mesh.hh"
-#include "mesh_partition.hh"
-#include "mesh_utils.hh"
 #include "model_solver.hh"
-#include "parser.hh"
+#include "aka_named_argument.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MODEL_HH__
 #define __AKANTU_MODEL_HH__
 
 namespace akantu {
 class SynchronizerRegistry;
-} // akantu
+class Parser;
+} // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
+namespace {
+  DECLARE_NAMED_ARGUMENT(analysis_method);
+}
+
 struct ModelOptions {
-  virtual ~ModelOptions() {}
+  explicit ModelOptions(AnalysisMethod analysis_method = _static)
+      : analysis_method(analysis_method) {}
+
+  template <typename... pack>
+  ModelOptions(use_named_args_t, pack &&... _pack)
+      : ModelOptions(OPTIONAL_NAMED_ARG(analysis_method, _static)) {}
+
+  virtual ~ModelOptions() = default;
+
+  AnalysisMethod analysis_method;
 };
 
 class DumperIOHelper;
 
 class Model : public Memory, public ModelSolver, public MeshEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Model(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
         const ID & id = "model", const MemoryID & memory_id = 0);
 
   virtual ~Model();
 
-  typedef std::map<std::string, FEEngine *> FEEngineMap;
+  typedef std::map<std::string, std::unique_ptr<FEEngine>> FEEngineMap;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void initFull(const ModelOptions & options);
 
+  template <typename P, typename T, typename... pack>
+  void initFull(named_argument::param_t<P, T &&> && first, pack &&... _pack) {
+    this->initFull(ModelOptions{use_named_args, first, _pack...});
+  }
+
+  /// initialize a new solver if needed
+  void initNewSolver(const AnalysisMethod & method);
+
+protected:
+  /// get some default values for derived classes
+  virtual std::tuple<ID, TimeStepSolverType> getDefaultSolverID(const AnalysisMethod & method) = 0;
+
   virtual void initModel() = 0;
 
   // /// change local equation number so that PBC is assembled properly
   // void changeLocalEquationNumberForPBC(std::map<UInt, UInt> & pbc_pair,
   //                                      UInt dimension);
   /// function to print the containt of the class
-  virtual void printself(__attribute__((unused)) std::ostream & stream,
-                         __attribute__((unused)) int indent = 0) const {};
+  virtual void printself(std::ostream &, int = 0) const {};
 
   // /// initialize the model for PBC
   // void setPBC(UInt x, UInt y, UInt z);
   // void setPBC(SurfacePairList & surface_pairs);
+public:
 
   virtual void initPBC();
 
   /// set the parser to use
-  void setParser(Parser & parser);
+  //void setParser(Parser & parser);
 
   /* ------------------------------------------------------------------------ */
   /* Access to the dumpable interface of the boundaries                       */
   /* ------------------------------------------------------------------------ */
   /// Dump the data for a given group
   void dumpGroup(const std::string & group_name);
   void dumpGroup(const std::string & group_name,
                  const std::string & dumper_name);
   /// Dump the data for all boundaries
   void dumpGroup();
   /// Set the directory for a given group
   void setGroupDirectory(const std::string & directory,
                          const std::string & group_name);
   /// Set the directory for all boundaries
   void setGroupDirectory(const std::string & directory);
   /// Set the base name for a given group
   void setGroupBaseName(const std::string & basename,
                         const std::string & group_name);
   /// Get the internal dumper of a given group
   DumperIOHelper & getGroupDumper(const std::string & group_name);
 
   /* ------------------------------------------------------------------------ */
   /* Function for non local capabilities                                      */
   /* ------------------------------------------------------------------------ */
   virtual void updateDataForNonLocalCriterion(__attribute__((unused))
                                               ElementTypeMapReal & criterion) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
 protected:
   template <typename T>
   void allocNodalField(Array<T> *& array, UInt nb_component, const ID & name);
 
-
   /* ------------------------------------------------------------------------ */
   /* Accessors */
   /* ------------------------------------------------------------------------ */
 public:
   /// get id of model
   AKANTU_GET_MACRO(ID, id, const ID)
 
   /// get the number of surfaces
   AKANTU_GET_MACRO(Mesh, mesh, Mesh &)
 
   /// synchronize the boundary in case of parallel run
   virtual void synchronizeBoundaries(){};
 
   /// return the fem object associated with a provided name
   inline FEEngine & getFEEngine(const ID & name = "") const;
 
   /// return the fem boundary object associated with a provided name
   virtual FEEngine & getFEEngineBoundary(const ID & name = "");
 
   /// register a fem object associated with name
   template <typename FEEngineClass>
   inline void registerFEEngineObject(const std::string & name, Mesh & mesh,
                                      UInt spatial_dimension);
   /// unregister a fem object associated with name
   inline void unRegisterFEEngineObject(const std::string & name);
 
   /// return the synchronizer registry
   SynchronizerRegistry & getSynchronizerRegistry();
 
   /// return the fem object associated with a provided name
   template <typename FEEngineClass>
   inline FEEngineClass & getFEEngineClass(std::string name = "") const;
 
   /// return the fem boundary object associated with a provided name
   template <typename FEEngineClass>
   inline FEEngineClass & getFEEngineClassBoundary(std::string name = "");
 
   /// get the pbc pairs
   std::map<UInt, UInt> & getPBCPairs() { return pbc_pair; };
 
   /// returns if node is slave in pbc
   inline bool isPBCSlaveNode(const UInt) const {
     throw;
     return false; /* TODO repair PBC*/
   }
 
   /// returns the array of pbc slave nodes (boolean information)
   AKANTU_GET_MACRO(IsPBCSlaveNode, is_pbc_slave_node, const Array<bool> &)
 
+  /// Get the type of analysis method used
+  AKANTU_GET_MACRO(AnalysisMethod, method, AnalysisMethod);
+
   /* ------------------------------------------------------------------------ */
   /* Pack and unpack helper functions                                         */
   /* ------------------------------------------------------------------------ */
 public:
   inline UInt getNbIntegrationPoints(const Array<Element> & elements,
                                      const ID & fem_id = ID()) const;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface (kept for convenience) and dumper relative functions  */
   /* ------------------------------------------------------------------------ */
-
   void setTextModeToDumper();
 
   virtual void addDumpGroupFieldToDumper(const std::string & field_id,
                                          dumper::Field * field,
                                          DumperIOHelper & dumper);
 
   virtual void addDumpField(const std::string & field_id);
 
   virtual void addDumpFieldVector(const std::string & field_id);
 
   virtual void addDumpFieldToDumper(const std::string & dumper_name,
                                     const std::string & field_id);
 
   virtual void addDumpFieldVectorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   virtual void addDumpFieldTensorToDumper(const std::string & dumper_name,
                                           const std::string & field_id);
 
   virtual void addDumpFieldTensor(const std::string & field_id);
 
   virtual void setBaseName(const std::string & basename);
 
   virtual void setBaseNameToDumper(const std::string & dumper_name,
                                    const std::string & basename);
 
   virtual void addDumpGroupField(const std::string & field_id,
                                  const std::string & group_name);
 
   virtual void addDumpGroupFieldToDumper(const std::string & dumper_name,
                                          const std::string & field_id,
                                          const std::string & group_name,
                                          const ElementKind & element_kind,
                                          bool padding_flag);
 
   virtual void addDumpGroupFieldToDumper(const std::string & dumper_name,
                                          const std::string & field_id,
                                          const std::string & group_name,
                                          UInt spatial_dimension,
                                          const ElementKind & element_kind,
                                          bool padding_flag);
 
   virtual void removeDumpGroupField(const std::string & field_id,
                                     const std::string & group_name);
   virtual void removeDumpGroupFieldFromDumper(const std::string & dumper_name,
                                               const std::string & field_id,
                                               const std::string & group_name);
 
   virtual void addDumpGroupFieldVector(const std::string & field_id,
                                        const std::string & group_name);
 
   virtual void addDumpGroupFieldVectorToDumper(const std::string & dumper_name,
                                                const std::string & field_id,
                                                const std::string & group_name);
 
   virtual dumper::Field *
   createNodalFieldReal(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag) {
     return NULL;
   }
 
   virtual dumper::Field *
   createNodalFieldUInt(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag) {
     return NULL;
   }
 
   virtual dumper::Field *
   createNodalFieldBool(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag) {
     return NULL;
   }
 
   virtual dumper::Field *
   createElementalField(__attribute__((unused)) const std::string & field_name,
                        __attribute__((unused)) const std::string & group_name,
                        __attribute__((unused)) bool padding_flag,
                        __attribute__((unused)) const UInt & spatial_dimension,
                        __attribute__((unused)) const ElementKind & kind) {
     return NULL;
   }
 
   void setDirectory(const std::string & directory);
   void setDirectoryToDumper(const std::string & dumper_name,
                             const std::string & directory);
 
   virtual void dump();
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
+  friend std::ostream & operator<<(std::ostream &, const Model &);
+
+  /// analysis method check the list in akantu::AnalysisMethod
+  AnalysisMethod method;
+
   /// Mesh
   Mesh & mesh;
 
   /// Spatial dimension of the problem
   UInt spatial_dimension;
 
   /// the main fem object present in all  models
   FEEngineMap fems;
 
   /// the fem object present in all  models for boundaries
   FEEngineMap fems_boundary;
 
   /// default fem object
   std::string default_fem;
 
   /// pbc pairs
   std::map<UInt, UInt> pbc_pair;
 
   /// flag per node to know is pbc slave
   Array<bool> is_pbc_slave_node;
 
   /// parser to the pointer to use
-  Parser * parser;
+  Parser & parser;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream, const Model & _this) {
   _this.printself(stream);
   return stream;
 }
 
-} // akantu
+} // namespace akantu
 
 #include "model_inline_impl.cc"
 
 #endif /* __AKANTU_MODEL_HH__ */
diff --git a/src/model/model_inline_impl.cc b/src/model/model_inline_impl.cc
index f7f42d346..9d5568242 100644
--- a/src/model/model_inline_impl.cc
+++ b/src/model/model_inline_impl.cc
@@ -1,222 +1,215 @@
 /**
  * @file   model_inline_impl.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Aug 25 2010
  * @date last modification: Wed Nov 11 2015
  *
  * @brief  inline implementation of the model class
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MODEL_INLINE_IMPL_CC__
 #define __AKANTU_MODEL_INLINE_IMPL_CC__
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename FEEngineClass>
 inline FEEngineClass & Model::getFEEngineClassBoundary(std::string name) {
   AKANTU_DEBUG_IN();
 
   if (name == "")
     name = default_fem;
 
   FEEngineMap::const_iterator it_boun = fems_boundary.find(name);
 
-  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(
+    fems_boundary[name] = std::make_unique<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;
+  return dynamic_cast<FEEngineClass &>(*fems_boundary[name]);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename FEEngineClass>
 inline FEEngineClass & Model::getFEEngineClass(std::string name) const {
   AKANTU_DEBUG_IN();
 
   if (name == "")
     name = default_fem;
 
   FEEngineMap::const_iterator it = fems.find(name);
   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);
+  fems[name] = std::make_unique<FEEngineClass>(mesh, spatial_dimension, sstr.str(), memory_id);
 }
 
 /* -------------------------------------------------------------------------- */
 inline FEEngine & Model::getFEEngine(const ID & name) const {
   AKANTU_DEBUG_IN();
   ID tmp_name = name;
   if (name == "")
     tmp_name = default_fem;
 
   FEEngineMap::const_iterator it = fems.find(tmp_name);
 
   AKANTU_DEBUG_ASSERT(it != fems.end(),
                       "The FEEngine " << tmp_name << " is not registered");
 
   AKANTU_DEBUG_OUT();
-  return *(it->second);
+  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.size() == 0)
 //     return false;
 //   else
 //     return is_pbc_slave_node(node);
 // }
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void Model::allocNodalField(Array<T> *& array, UInt nb_component, const ID & name) {
   if (array == nullptr) {
     UInt nb_nodes = mesh.getNbNodes();
     std::stringstream sstr_disp;
     sstr_disp << id << ":" << name;
 
     array =
         &(alloc<T>(sstr_disp.str(), nb_nodes, nb_component, T()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt Model::getNbIntegrationPoints(const Array<Element> & elements,
                                           const ID & fem_id) const {
   UInt nb_quad = 0;
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     nb_quad +=
         getFEEngine(fem_id).getNbIntegrationPoints(el.type, el.ghost_type);
   }
   return nb_quad;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // akantu
 
 #endif /* __AKANTU_MODEL_INLINE_IMPL_CC__ */
diff --git a/src/model/model_solver.cc b/src/model/model_solver.cc
index 91b8f39cf..fb4231877 100644
--- a/src/model/model_solver.cc
+++ b/src/model/model_solver.cc
@@ -1,673 +1,365 @@
 /**
  * @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);
+      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);
+  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);
+      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();
+    // std::string str = it->getOption();
     TimeStepSolverType tss_type =
-      it->getParameter("type", this->getDefaultSolverType());
+        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);
+        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);
+        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);
+        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();
+        tss_options.integration_scheme_type.begin();
     std::map<ID, IntegrationSchemeType>::const_iterator end =
-      tss_options.integration_scheme_type.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;
+    case _tsst_not_defined:
+      AKANTU_EXCEPTION(time_step_solver_type
+                       << " is not a valid time step solver type");
+      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.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-> 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->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.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
+} // namespace akantu
diff --git a/src/model/solid_mechanics/material_selector.hh b/src/model/solid_mechanics/material_selector.hh
index 54df2c595..d49b9e4f8 100644
--- a/src/model/solid_mechanics/material_selector.hh
+++ b/src/model/solid_mechanics/material_selector.hh
@@ -1,147 +1,142 @@
 /**
  * @file   material_selector.hh
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Dec 17 2015
  *
  * @brief  class describing how to choose a material for a given element
  *
  * @section LICENSE
  *
  * Copyright  (©)  2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "mesh.hh"
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_SELECTOR_HH__
 #define __AKANTU_MATERIAL_SELECTOR_HH__
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class SolidMechanicsModel;
 
 /**
  * main class to assign same or different materials for different
  * elements
  */
 class MaterialSelector {
 public:
   MaterialSelector() : fallback_value(0) {}
   virtual ~MaterialSelector() {}
   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)
+  explicit 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.size())
-        mat = mat_indexes(element.element);
-
-      debug::setDebugLevel(dbl);
-      return mat;
-    } catch (...) {
-      return MaterialSelector::operator()(element);
+    if (not material_index.exists(element.type, element.ghost_type))
+      return fallback_value;
+
+    const auto & mat_indexes = material_index(element.type, element.ghost_type);
+    if (element.element < mat_indexes.size()) {
+      auto && tmp_mat = mat_indexes(element.element);
+      if (tmp_mat != UInt(-1))
+        return tmp_mat;
     }
+
+    return fallback_value;
   }
 
 private:
   const ElementTypeMapArray<UInt> & material_index;
 };
 
 /* -------------------------------------------------------------------------- */
 /**
  * Use elemental data to assign materials
  */
 template <typename T>
 class ElementDataMaterialSelector : public MaterialSelector {
 public:
   ElementDataMaterialSelector(const ElementTypeMapArray<T> & element_data,
                               const SolidMechanicsModel & model,
                               UInt first_index = 1)
       : element_data(element_data), model(model), first_index(first_index) {}
 
   inline T elementData(const Element & element) {
     DebugLevel dbl = debug::getDebugLevel();
     debug::setDebugLevel(dblError);
     T data = element_data(element.type, element.ghost_type)(element.element);
     debug::setDebugLevel(dbl);
     return data;
   }
 
   inline UInt operator()(const Element & element) {
     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
+} // namespace akantu
 
 #endif /* __AKANTU_MATERIAL_SELECTOR_HH__ */
diff --git a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_bilinear.cc b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_bilinear.cc
index 4c7096a16..ff5213680 100644
--- a/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_bilinear.cc
+++ b/src/model/solid_mechanics/materials/material_cohesive/constitutive_laws/material_cohesive_bilinear.cc
@@ -1,218 +1,218 @@
 /**
  * @file   material_cohesive_bilinear.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Feb 22 2012
  * @date last modification: Thu Oct 15 2015
  *
  * @brief  Bilinear cohesive constitutive law
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "material_cohesive_bilinear.hh"
-#include "solid_mechanics_model_cohesive.hh"
+//#include "solid_mechanics_model_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 MaterialCohesiveBilinear<spatial_dimension>::MaterialCohesiveBilinear(
     SolidMechanicsModel & model, const ID & id)
     : MaterialCohesiveLinear<spatial_dimension>(model, id) {
   AKANTU_DEBUG_IN();
 
   this->registerParam("delta_0", delta_0, Real(0.),
                       _pat_parsable | _pat_readable,
                       "Elastic limit displacement");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::initMaterial() {
   AKANTU_DEBUG_IN();
 
   this->sigma_c_eff.setRandomDistribution(this->sigma_c.getRandomParameter());
   MaterialCohesiveLinear<spatial_dimension>::initMaterial();
 
   this->delta_max.setDefaultValue(delta_0);
   this->insertion_stress.setDefaultValue(0);
 
   this->delta_max.reset();
   this->insertion_stress.reset();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::onElementsAdded(
     const Array<Element> & element_list, const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   MaterialCohesiveLinear<spatial_dimension>::onElementsAdded(element_list,
                                                              event);
 
   bool scale_traction = false;
 
   // don't scale sigma_c if volume_s hasn't been specified by the user
   if (!Math::are_float_equal(this->volume_s, 0.))
     scale_traction = true;
 
   Array<Element>::const_scalar_iterator el_it = element_list.begin();
   Array<Element>::const_scalar_iterator el_end = element_list.end();
 
   for (; el_it != el_end; ++el_it) {
     // filter not ghost cohesive elements
     if (el_it->ghost_type != _not_ghost || el_it->kind != _ek_cohesive)
       continue;
 
     UInt index = el_it->element;
     ElementType type = el_it->type;
     UInt nb_element = this->model->getMesh().getNbElement(type);
-    UInt nb_quad_per_element = this->fem_cohesive->getNbIntegrationPoints(type);
+    UInt nb_quad_per_element = this->fem_cohesive.getNbIntegrationPoints(type);
 
     Array<Real>::vector_iterator sigma_c_begin =
         this->sigma_c_eff(type).begin_reinterpret(nb_quad_per_element,
                                                   nb_element);
     Vector<Real> sigma_c_vec = sigma_c_begin[index];
 
     Array<Real>::vector_iterator delta_c_begin =
         this->delta_c_eff(type).begin_reinterpret(nb_quad_per_element,
                                                   nb_element);
     Vector<Real> delta_c_vec = delta_c_begin[index];
 
     if (scale_traction)
       scaleTraction(*el_it, sigma_c_vec);
 
     /**
      * Recompute sigma_c as
      * @f$ {\sigma_c}_\textup{new} =
      * \frac{{\sigma_c}_\textup{old} \delta_c} {\delta_c - \delta_0} @f$
      */
 
     for (UInt q = 0; q < nb_quad_per_element; ++q) {
       delta_c_vec(q) = 2 * this->G_c / sigma_c_vec(q);
 
       if (delta_c_vec(q) - delta_0 < Math::getTolerance())
         AKANTU_DEBUG_ERROR("delta_0 = "
                            << delta_0 << " must be lower than delta_c = "
                            << delta_c_vec(q) << ", modify your material file");
 
       sigma_c_vec(q) *= delta_c_vec(q) / (delta_c_vec(q) - delta_0);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::scaleTraction(
     const Element & el, Vector<Real> & sigma_c_vec) {
   AKANTU_DEBUG_IN();
 
   Real base_sigma_c = this->sigma_c_eff;
 
   const Mesh & mesh_facets = this->model->getMeshFacets();
   const FEEngine & fe_engine = this->model->getFEEngine();
 
   Array<Element>::const_vector_iterator coh_element_to_facet_begin =
       mesh_facets.getSubelementToElement(el.type).begin(2);
   const Vector<Element> & coh_element_to_facet =
       coh_element_to_facet_begin[el.element];
 
   // compute bounding volume
   Real volume = 0;
 
   // loop over facets
   for (UInt f = 0; f < 2; ++f) {
     const Element & facet = coh_element_to_facet(f);
 
     const Array<std::vector<Element>> & facet_to_element =
         mesh_facets.getElementToSubelement(facet.type, facet.ghost_type);
 
     const std::vector<Element> & element_list = facet_to_element(facet.element);
 
     std::vector<Element>::const_iterator elem = element_list.begin();
     std::vector<Element>::const_iterator elem_end = element_list.end();
 
     // loop over elements connected to each facet
     for (; elem != elem_end; ++elem) {
       // skip cohesive elements and dummy elements
       if (*elem == ElementNull || elem->kind == _ek_cohesive)
         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_vec -= base_sigma_c;
   sigma_c_vec *= std::pow(this->volume_s / volume, 1. / this->m_s);
   sigma_c_vec += base_sigma_c;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <UInt spatial_dimension>
 void MaterialCohesiveBilinear<spatial_dimension>::computeTraction(
     const Array<Real> & normal, ElementType el_type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
   MaterialCohesiveLinear<spatial_dimension>::computeTraction(normal, el_type,
                                                              ghost_type);
 
   // adjust damage
   Array<Real>::scalar_iterator delta_c_it =
       this->delta_c_eff(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator delta_max_it =
       this->delta_max(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator damage_it =
       this->damage(el_type, ghost_type).begin();
 
   Array<Real>::scalar_iterator damage_end =
       this->damage(el_type, ghost_type).end();
 
   for (; damage_it != damage_end; ++damage_it, ++delta_max_it, ++delta_c_it) {
     *damage_it =
         std::max((*delta_max_it - delta_0) / (*delta_c_it - delta_0), Real(0.));
     *damage_it = std::min(*damage_it, Real(1.));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 INSTANTIATE_MATERIAL(cohesive_bilinear, MaterialCohesiveBilinear);
 
 } // namespace akantu
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 25b195500..868129ee7 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.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.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.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 & 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.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 & 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.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 7725cbd89..748481c51 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 & 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.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 611a8f00e..77b90ca8d 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 & 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.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 2dbdcc745..95f999360 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,582 @@
 /**
  * @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 "fe_engine_template.hh"
+#include "integrator_gauss.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"))),
+      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.size();
     if (nb_element == 0)
       continue;
 
-    const auto & shapes = fem_cohesive->getShapes(type, ghost_type);
+    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);
+        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);
+    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);
+        fem_cohesive.getNbIntegrationPoints(type, ghost_type);
     UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
-    const Array<Real> & shapes = fem_cohesive->getShapes(type, ghost_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.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);
+    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.size();
     if (nb_element == 0)
       continue;
 
     UInt nb_quadrature_points =
-        nb_element * fem_cohesive->getNbIntegrationPoints(type, ghost_type);
+        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();
 
+  auto & fem_cohesive =
+      this->model->getFEEngineClass<MyFEEngineCohesiveType>("CohesiveFEEngine");
+
   if (type == _cohesive_1d_2)
-    fem_cohesive->computeNormalsOnIntegrationPoints(position, normal, type,
-                                                    ghost_type);
+    fem_cohesive.computeNormalsOnIntegrationPoints(position, normal, type,
+                                                   ghost_type);
   else {
 #define COMPUTE_NORMAL(type)                                                   \
-  fem_cohesive->getShapeFunctions()                                            \
+  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();
 
+  auto & fem_cohesive =
+      this->model->getFEEngineClass<MyFEEngineCohesiveType>("CohesiveFEEngine");
+
 #define COMPUTE_OPENING(type)                                                  \
-  fem_cohesive->getShapeFunctions()                                            \
+  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));
+        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));
+    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_per_el = fem_cohesive.getNbIntegrationPoints(type, _not_ghost);
     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);
+    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.hh b/src/model/solid_mechanics/materials/material_cohesive/material_cohesive.hh
index 69a3cae41..52c228a0d 100644
--- a/src/model/solid_mechanics/materials/material_cohesive/material_cohesive.hh
+++ b/src/model/solid_mechanics/materials/material_cohesive/material_cohesive.hh
@@ -1,265 +1,261 @@
 /**
  * @file   material_cohesive.hh
  *
  * @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: Fri Jun 18 2010
  * @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.hh"
 /* -------------------------------------------------------------------------- */
-#include "cohesive_element_inserter.hh"
 #include "cohesive_internal_field.hh"
-#include "fe_engine_template.hh"
-#include "integrator_gauss.hh"
-#include "shape_lagrange.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MATERIAL_COHESIVE_HH__
 #define __AKANTU_MATERIAL_COHESIVE_HH__
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class SolidMechanicsModelCohesive;
 }
 
 namespace akantu {
 
 class MaterialCohesive : public Material {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   typedef FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive>
       MyFEEngineCohesiveType;
 
 public:
   MaterialCohesive(SolidMechanicsModel & model, const ID & id = "");
   virtual ~MaterialCohesive();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// initialize the material computed parameter
   virtual void initMaterial();
 
   /// compute tractions (including normals and openings)
   void computeTraction(GhostType ghost_type = _not_ghost);
 
   /// assemble residual
   void assembleInternalForces(GhostType ghost_type = _not_ghost);
 
   /// compute reversible and total energies by element
   void computeEnergies();
 
   /// check stress for cohesive elements' insertion, by default it
   /// also updates the cohesive elements' data
   virtual void checkInsertion(__attribute__((unused)) bool check_only = false) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// check delta_max for cohesive elements in case of no convergence
   /// in the solveStep (only for extrinsic-implicit)
   virtual void checkDeltaMax(__attribute__((unused))
                              GhostType ghost_type = _not_ghost) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// reset variables when convergence is reached (only for
   /// extrinsic-implicit)
   virtual void resetVariables(__attribute__((unused))
                               GhostType ghost_type = _not_ghost) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// interpolate   stress  on   given   positions  for   each  element   (empty
   /// implemantation to avoid the generic call to be done on cohesive elements)
   virtual void interpolateStress(__attribute__((unused)) const ElementType type,
                                  __attribute__((unused))
                                  Array<Real> & result){};
 
   /// compute the stresses
   virtual void computeAllStresses(__attribute__((unused))
                                   GhostType ghost_type = _not_ghost){};
 
   // add the facet to be handled by the material
   UInt addFacet(const Element & element);
 
 protected:
   virtual void
   computeTangentTraction(__attribute__((unused)) const ElementType & el_type,
                          __attribute__((unused)) Array<Real> & tangent_matrix,
                          __attribute__((unused)) const Array<Real> & normal,
                          __attribute__((unused))
                          GhostType ghost_type = _not_ghost) {
     AKANTU_DEBUG_TO_IMPLEMENT();
   }
 
   /// compute the normal
   void computeNormal(const Array<Real> & position, Array<Real> & normal,
                      ElementType type, GhostType ghost_type);
 
   /// compute the opening
   void computeOpening(const Array<Real> & displacement, Array<Real> & opening,
                       ElementType type, GhostType ghost_type);
 
   template <ElementType type>
   void computeNormal(const Array<Real> & position, Array<Real> & normal,
                      GhostType ghost_type);
 
   /// assemble stiffness
   void assembleStiffnessMatrix(GhostType ghost_type);
 
   /// constitutive law
   virtual void computeTraction(const Array<Real> & normal, ElementType el_type,
                                GhostType ghost_type = _not_ghost) = 0;
 
   /// parallelism functions
   inline UInt getNbDataForElements(const Array<Element> & elements,
                                    SynchronizationTag tag) const;
 
   inline void packElementData(CommunicationBuffer & buffer,
                               const Array<Element> & elements,
                               SynchronizationTag tag) const;
 
   inline void unpackElementData(CommunicationBuffer & buffer,
                                 const Array<Element> & elements,
                                 SynchronizationTag tag);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the opening
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Opening, opening, Real);
 
   /// get the traction
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Traction, tractions, Real);
 
   /// get damage
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Damage, damage, Real);
 
   /// get facet filter
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(FacetFilter, facet_filter, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(FacetFilter, facet_filter, UInt);
   AKANTU_GET_MACRO(FacetFilter, facet_filter,
                    const ElementTypeMapArray<UInt> &);
   // AKANTU_GET_MACRO(ElementFilter, element_filter, const
   // ElementTypeMapArray<UInt> &);
 
   /// compute reversible energy
   Real getReversibleEnergy();
 
   /// compute dissipated energy
   Real getDissipatedEnergy();
 
   /// compute contact energy
   Real getContactEnergy();
 
   /// get energy
   virtual Real getEnergy(std::string type);
 
   /// return the energy (identified by id) for the provided element
   virtual Real getEnergy(std::string energy_id, ElementType type, UInt index) {
     return Material::getEnergy(energy_id, type, index);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// list of facets assigned to this material
   ElementTypeMapArray<UInt> facet_filter;
 
   /// Link to the cohesive fem object in the model
-  MyFEEngineCohesiveType * fem_cohesive;
+  FEEngine & fem_cohesive;
 
 private:
   /// reversible energy by quadrature point
   CohesiveInternalField<Real> reversible_energy;
 
   /// total energy by quadrature point
   CohesiveInternalField<Real> total_energy;
 
 protected:
   /// opening in all elements and quadrature points
   CohesiveInternalField<Real> opening;
 
   /// opening in all elements and quadrature points (previous time step)
   CohesiveInternalField<Real> opening_old;
 
   /// traction in all elements and quadrature points
   CohesiveInternalField<Real> tractions;
 
   /// traction in all elements and quadrature points (previous time step)
   CohesiveInternalField<Real> tractions_old;
 
   /// traction due to contact
   CohesiveInternalField<Real> contact_tractions;
 
   /// normal openings for contact tractions
   CohesiveInternalField<Real> contact_opening;
 
   /// maximum displacement
   CohesiveInternalField<Real> delta_max;
 
   /// tell if the previous delta_max state is needed (in iterative schemes)
   bool use_previous_delta_max;
 
   /// tell if the previous opening state is needed (in iterative schemes)
   bool use_previous_opening;
 
   /// damage
   CohesiveInternalField<Real> damage;
 
   /// pointer to the solid mechanics model for cohesive elements
   SolidMechanicsModelCohesive * model;
 
   /// critical stress
   RandomInternalField<Real, FacetInternalField> sigma_c;
 
   /// critical displacement
   Real delta_c;
 
   /// array to temporarily store the normals
   Array<Real> normal;
 };
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 
 #include "material_cohesive_inline_impl.cc"
 
 } // namespace akantu
 
 #include "cohesive_internal_field_tmpl.hh"
 
 #endif /* __AKANTU_MATERIAL_COHESIVE_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model.cc b/src/model/solid_mechanics/solid_mechanics_model.cc
index a405ad107..d6b5dae4d 100644
--- a/src/model/solid_mechanics/solid_mechanics_model.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model.cc
@@ -1,1266 +1,1240 @@
 /**
  * @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),
       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);
 
 #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);
-
-  method = smm_options.analysis_method;
-
   material_index.initialize(mesh, _element_kind = _ek_not_defined,
                             _default_value = UInt(-1), _with_nb_element = true);
   material_local_numbering.initialize(mesh, _element_kind = _ek_not_defined,
                                       _with_nb_element = true);
 
-  if (!this->hasDefaultSolver())
-    this->initNewSolver(this->method);
+  Model::initFull(options);
 
   // initialize pbc
   if (this->pbc_pair.size() != 0)
     this->initPBC();
 
   // initialize the materials
-  if (this->parser->getLastParsedFile() != "") {
+  if (this->parser.getLastParsedFile() != "") {
     this->instantiateMaterials();
   }
 
   this->initMaterials();
 
   this->initBC(*this, *displacement, *displacement_increment, *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;
   }
+  default:
+    AKANTU_EXCEPTION(type << " is not a valid time step solver type");
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
-void SolidMechanicsModel::initNewSolver(const AnalysisMethod & method) {
-  ID solver_name;
-  TimeStepSolverType tss_type;
-
-  this->method = method;
-
-  switch (this->method) {
+std::tuple<ID, TimeStepSolverType>
+SolidMechanicsModel::getDefaultSolverID(const AnalysisMethod & method) {
+  switch (method) {
   case _explicit_lumped_mass: {
-    solver_name = "explicit_lumped";
-    tss_type = _tsst_dynamic_lumped;
-    break;
+    return std::make_tuple("explicit_lumped", _tsst_dynamic_lumped);
   }
   case _explicit_consistent_mass: {
-    solver_name = "explicit";
-    tss_type = _tsst_dynamic;
-    break;
+    return std::make_tuple("explicit", _tsst_dynamic);
   }
   case _static: {
-    solver_name = "static";
-    tss_type = _tsst_static;
-    break;
+    return std::make_tuple("static", _tsst_static);
   }
   case _implicit_dynamic: {
-    solver_name = "implicit";
-    tss_type = _tsst_dynamic;
-    break;
-  }
+    return std::make_tuple("implicit", _tsst_dynamic);
   }
-
-  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);
+  default:
+    return std::make_tuple("unknown", _tsst_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initSolver(TimeStepSolverType time_step_solver_type,
                                      NonLinearSolverType) {
-  DOFManager & dof_manager = this->getDOFManager();
+  auto & dof_manager = this->getDOFManager();
 
   /* ------------------------------------------------------------------------ */
   // for alloc type of solvers
   this->allocNodalField(this->displacement, spatial_dimension, "displacement");
   this->allocNodalField(this->previous_displacement, spatial_dimension,
                         "previous_displacement");
   this->allocNodalField(this->displacement_increment, spatial_dimension,
                         "displacement_increment");
   this->allocNodalField(this->internal_force, spatial_dimension,
                         "internal_force");
   this->allocNodalField(this->external_force, spatial_dimension,
                         "external_force");
   this->allocNodalField(this->blocked_dofs, spatial_dimension, "blocked_dofs");
   this->allocNodalField(this->current_position, spatial_dimension,
                         "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, spatial_dimension, "velocity");
     this->allocNodalField(this->acceleration, spatial_dimension,
                           "acceleration");
 
     if (!dof_manager.hasDOFsDerivatives("displacement", 1)) {
       dof_manager.registerDOFsDerivative("displacement", 1, *this->velocity);
       dof_manager.registerDOFsDerivative("displacement", 2,
                                          *this->acceleration);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 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);
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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::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();
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType SolidMechanicsModel::getMatrixType(const ID & matrix_id) {
   // \TODO check the materials to know what is the correct answer
   if (matrix_id == "C")
     return _mt_not_defined;
 
   return _symmetric;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleMatrix(const ID & matrix_id) {
   if (matrix_id == "K") {
     this->assembleStiffnessMatrix();
   } else if (matrix_id == "M") {
     this->assembleMass();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleLumpedMatrix(const ID & matrix_id) {
   if (matrix_id == "M") {
     this->assembleMassLumped();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::beforeSolveStep() {
   for (auto & material : materials)
     material->beforeSolveStep();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::afterSolveStep() {
   for (auto & material : materials)
     material->afterSolveStep();
 }
 
 /* -------------------------------------------------------------------------- */
 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);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Computation of the non local part */
   if (this->non_local_manager)
     this->non_local_manager->computeAllNonLocalStresses();
 
   // 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::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                                                                */
 /* -------------------------------------------------------------------------- */
 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 && ghost_type : ghost_types) {
     for (auto type :
-           mesh.elementTypes(spatial_dimension, ghost_type, _ek_not_defined)) {
+         mesh.elementTypes(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,
                                              UInt(-1));
       } else {
         this->material_index(type, ghost_type).resize(nb_element);
         this->material_local_numbering(type, ghost_type)
-          .resize(nb_element, UInt(-1));
+            .resize(nb_element, UInt(-1));
       }
     }
   }
 
   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(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     const RemovedElementsEvent & event) {
-  //this->getFEEngine().initShapeFunctions(_not_ghost);
-  //this->getFEEngine().initShapeFunctions(_ghost);
+  // 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,
                                        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);
   }
 
   need_to_reassemble_lumped_mass = true;
   need_to_reassemble_mass = true;
 
   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::initializeNonLocal() {
   this->non_local_manager->synchronize(*this, _gst_material_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::insertIntegrationPointsInNeighborhoods(
     const GhostType & ghost_type) {
   for (auto & mat : materials) {
     MaterialNonLocalInterface * mat_non_local;
     if ((mat_non_local =
              dynamic_cast<MaterialNonLocalInterface *>(mat.get())) == nullptr)
       continue;
 
     ElementTypeMapArray<Real> quadrature_points_coordinates(
         "quadrature_points_coordinates_tmp_nl", this->id, this->memory_id);
     quadrature_points_coordinates.initialize(this->getFEEngine(),
                                              _nb_component = 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);
     }
 
     mat_non_local->initMaterialNonLocal();
 
     mat_non_local->insertIntegrationPointsInNeighborhoods(
         ghost_type, quadrature_points_coordinates);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 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));
 }
 
 /* -------------------------------------------------------------------------- */
 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);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModel::getNbData(const Array<Element> & elements,
                                     const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes_per_element = 0;
 
   for (const Element & el : elements) {
     nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
   }
 
   switch (tag) {
   case _gst_material_id: {
     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;
 }
 
 /* -------------------------------------------------------------------------- */
 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();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::unpackData(CommunicationBuffer & buffer,
                                      const Array<Element> & elements,
                                      const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case _gst_material_id: {
     for (auto && element : elements) {
       UInt recv_mat_index;
       buffer >> recv_mat_index;
       UInt & mat_index = material_index(element);
       if (mat_index != UInt(-1))
         continue;
 
+      // add ghosts element to the correct material
       mat_index = recv_mat_index;
       UInt index = materials[mat_index]->addElement(element);
       material_local_numbering(element) = index;
-      std::cout << "Registering: " << element << " in material " << mat_index
-                << std::endl;
     }
     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();
 }
 
 /* -------------------------------------------------------------------------- */
 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.size();
 }
 
 /* -------------------------------------------------------------------------- */
 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();
 }
 
 /* -------------------------------------------------------------------------- */
 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
diff --git a/src/model/solid_mechanics/solid_mechanics_model.hh b/src/model/solid_mechanics/solid_mechanics_model.hh
index 3bea24f26..e31e45401 100644
--- a/src/model/solid_mechanics/solid_mechanics_model.hh
+++ b/src/model/solid_mechanics/solid_mechanics_model.hh
@@ -1,595 +1,578 @@
 /**
  * @file   solid_mechanics_model.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Jul 27 2010
  * @date last modification: Tue Jan 19 2016
  *
  * @brief  Model of Solid Mechanics
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "boundary_condition.hh"
 #include "data_accessor.hh"
 #include "fe_engine.hh"
 #include "model.hh"
 #include "non_local_manager.hh"
 #include "solid_mechanics_model_event_handler.hh"
 /* -------------------------------------------------------------------------- */
 //#include "integrator_gauss.hh"
 //#include "shape_lagrange.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_HH__
 #define __AKANTU_SOLID_MECHANICS_MODEL_HH__
 
 namespace akantu {
 class Material;
 class MaterialSelector;
 class DumperIOHelper;
 class NonLocalManager;
 template <ElementKind kind, class IntegrationOrderFunctor>
 class IntegratorGauss;
 template <ElementKind kind> class ShapeLagrange;
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
-namespace {
-  DECLARE_NAMED_ARGUMENT(analysis_method);
-}
-
 struct SolidMechanicsModelOptions : public ModelOptions {
   explicit SolidMechanicsModelOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass);
 
   template <typename... pack>
   SolidMechanicsModelOptions(use_named_args_t, pack &&... _pack);
-
-  AnalysisMethod analysis_method;
 };
 
 /* -------------------------------------------------------------------------- */
 class SolidMechanicsModel
     : public Model,
       public DataAccessor<Element>,
       public DataAccessor<UInt>,
       public BoundaryCondition<SolidMechanicsModel>,
       public NonLocalManagerCallback,
       public EventHandlerManager<SolidMechanicsModelEventHandler> {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   class NewMaterialElementsEvent : public NewElementsEvent {
   public:
     AKANTU_GET_MACRO_NOT_CONST(MaterialList, material, Array<UInt> &);
     AKANTU_GET_MACRO(MaterialList, material, const Array<UInt> &);
 
   protected:
     Array<UInt> material;
   };
 
   using MyFEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>;
 
 protected:
   using EventManager = EventHandlerManager<SolidMechanicsModelEventHandler>;
 
 public:
   SolidMechanicsModel(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
                       const ID & id = "solid_mechanics_model",
                       const MemoryID & memory_id = 0);
 
   virtual ~SolidMechanicsModel();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename P, typename T, typename... pack>
   void initFull(named_argument::param_t<P, T &&> && first, pack &&... _pack) {
     this->initFull(SolidMechanicsModelOptions{use_named_args, first, _pack...});
   }
 
   /// initialize completely the model
   void initFull(
       const ModelOptions & options = SolidMechanicsModelOptions()) override;
 
   /// initialize the fem object needed for boundary conditions
   void initFEEngineBoundary();
 
+protected:
   /// initialize all internal arrays for materials
   virtual void initMaterials();
 
   /// initialize the model
   void initModel() override;
 
-  /// initialize a new solver and sets it as the default one to use
-  void initNewSolver(const AnalysisMethod & method);
-
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
+  /// get some default values for derived classes
+  std::tuple<ID, TimeStepSolverType> getDefaultSolverID(const AnalysisMethod & method) override;
+
   /* ------------------------------------------------------------------------ */
   /* Solver interface                                                         */
   /* ------------------------------------------------------------------------ */
 public:
   /// assembles the stiffness matrix,
   virtual void assembleStiffnessMatrix();
   /// assembles the internal forces in the array internal_forces
   virtual void assembleInternalForces();
 
 protected:
   /// callback for the solver, this adds f_{ext} - f_{int} to the residual
   void assembleResidual() override;
 
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID & matrix_id) override;
 
   /// callback for the solver, this assembles different matrices
   void assembleMatrix(const ID & matrix_id) override;
 
   /// callback for the solver, this assembles the stiffness matrix
   void assembleLumpedMatrix(const ID & matrix_id) override;
 
   /// callback for the solver, this is called at beginning of solve
   void predictor() override;
   /// callback for the solver, this is called at end of solve
   void corrector() override;
 
   /// callback for the solver, this is called at beginning of solve
   void beforeSolveStep() override;
   /// callback for the solver, this is called at end of solve
   void afterSolveStep() override;
 
   /// Callback for the model to instantiate the matricees when needed
   void initSolver(TimeStepSolverType time_step_solver_type,
                   NonLinearSolverType non_linear_solver_type) override;
 
 protected:
   /* ------------------------------------------------------------------------ */
   TimeStepSolverType getDefaultSolverType() const override;
   /* ------------------------------------------------------------------------ */
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const override;
 
 public:
   bool isDefaultSolverExplicit() {
     return method == _explicit_lumped_mass ||
            method == _explicit_consistent_mass;
   }
 
 protected:
   /// update the current position vector
   void updateCurrentPosition();
 
   /* ------------------------------------------------------------------------ */
   /* Materials (solid_mechanics_model_material.cc)                            */
   /* ------------------------------------------------------------------------ */
 public:
   /// register an empty material of a given type
   Material & registerNewMaterial(const ID & mat_name, const ID & mat_type,
                                  const ID & opt_param);
 
   /// reassigns materials depending on the material selector
   virtual void reassignMaterial();
 
   /// apply a constant eigen_grad_u on all quadrature points of a given material
   virtual void applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                const ID & material_name,
                                const GhostType ghost_type = _not_ghost);
 
 protected:
   /// register a material in the dynamic database
   Material & registerNewMaterial(const ParserSection & mat_section);
 
   /// read the material files to instantiate all the materials
   void instantiateMaterials();
 
   /// set the element_id_by_material and add the elements to the good materials
   void
   assignMaterialToElements(const ElementTypeMapArray<UInt> * filter = NULL);
 
   /* ------------------------------------------------------------------------ */
   /* Mass (solid_mechanics_model_mass.cc)                                     */
   /* ------------------------------------------------------------------------ */
 public:
   /// assemble the lumped mass matrix
   void assembleMassLumped();
 
   /// assemble the mass matrix for consistent mass resolutions
   void assembleMass();
 
 protected:
   /// assemble the lumped mass matrix for local and ghost elements
   void assembleMassLumped(GhostType ghost_type);
 
   /// assemble the mass matrix for either _ghost or _not_ghost elements
   void assembleMass(GhostType ghost_type);
 
   /// fill a vector of rho
   void computeRho(Array<Real> & rho, ElementType type, GhostType ghost_type);
 
   /// compute the kinetic energy
   Real getKineticEnergy();
   Real getKineticEnergy(const ElementType & type, UInt index);
 
   /// compute the external work (for impose displacement, the velocity should be
   /// given too)
   Real getExternalWork();
 
   /* ------------------------------------------------------------------------ */
   /* NonLocalManager inherited members                                        */
   /* ------------------------------------------------------------------------ */
 protected:
   void initializeNonLocal() override;
 
   void updateDataForNonLocalCriterion(ElementTypeMapReal & criterion) override;
 
   void computeNonLocalStresses(const GhostType & ghost_type) override;
 
   void
   insertIntegrationPointsInNeighborhoods(const GhostType & ghost_type) override;
 
   /// update the values of the non local internal
   void updateLocalInternal(ElementTypeMapReal & internal_flat,
                            const GhostType & ghost_type,
                            const ElementKind & kind) override;
 
   /// copy the results of the averaging in the materials
   void updateNonLocalInternal(ElementTypeMapReal & internal_flat,
                               const GhostType & ghost_type,
                               const ElementKind & kind) override;
 
   /* ------------------------------------------------------------------------ */
   /* Data Accessor inherited members                                          */
   /* ------------------------------------------------------------------------ */
 public:
   UInt getNbData(const Array<Element> & elements,
                  const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<Element> & elements,
                 const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<Element> & elements,
                   const SynchronizationTag & tag) override;
 
   UInt getNbData(const Array<UInt> & dofs,
                  const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
                 const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
                   const SynchronizationTag & tag) override;
 
 protected:
   inline void splitElementByMaterial(const Array<Element> & elements,
                                      Array<Element> * elements_per_mat) const;
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler inherited members                                     */
   /* ------------------------------------------------------------------------ */
 protected:
   void onNodesAdded(const Array<UInt> & nodes_list,
                     const NewNodesEvent & event) override;
   void onNodesRemoved(const Array<UInt> & element_list,
                       const Array<UInt> & new_numbering,
                       const RemovedNodesEvent & event) override;
   void onElementsAdded(const Array<Element> & nodes_list,
                        const NewElementsEvent & event) override;
   void onElementsRemoved(const Array<Element> & element_list,
                          const ElementTypeMapArray<UInt> & new_numbering,
                          const RemovedElementsEvent & event) override;
 
   void onElementsChanged(const Array<Element> &, const Array<Element> &,
                          const ElementTypeMapArray<UInt> &,
                          const ChangedElementsEvent &) override{};
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface (kept for convenience) and dumper relative functions  */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void onDump();
 
   //! decide wether a field is a material internal or not
   bool isInternal(const std::string & field_name,
                   const ElementKind & element_kind);
 #ifndef SWIG
   //! give the amount of data per element
   virtual ElementTypeMap<UInt>
   getInternalDataPerElem(const std::string & field_name,
                          const ElementKind & kind);
 
   //! flatten a given material internal field
   ElementTypeMapArray<Real> &
   flattenInternal(const std::string & field_name, const ElementKind & kind,
                   const GhostType ghost_type = _not_ghost);
   //! flatten all the registered material internals
   void flattenAllRegisteredInternals(const ElementKind & kind);
 #endif
 
   dumper::Field * createNodalFieldReal(const std::string & field_name,
                                        const std::string & group_name,
                                        bool padding_flag) override;
 
   dumper::Field * createNodalFieldBool(const std::string & field_name,
                                        const std::string & group_name,
                                        bool padding_flag) override;
 
   dumper::Field * createElementalField(const std::string & field_name,
                                        const std::string & group_name,
                                        bool padding_flag,
                                        const UInt & spatial_dimension,
                                        const ElementKind & kind) override;
 
   virtual void dump(const std::string & dumper_name);
 
   virtual void dump(const std::string & dumper_name, UInt step);
 
   virtual void dump(const std::string & dumper_name, Real time, UInt step);
 
   void dump() override;
 
   virtual void dump(UInt step);
 
   virtual void dump(Real time, UInt step);
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// return the dimension of the system space
   AKANTU_GET_MACRO(SpatialDimension, Model::spatial_dimension, UInt);
 
   /// set the value of the time step
   void setTimeStep(Real time_step, const ID & solver_id = "") override;
 
   /// get the value of the conversion from forces/ mass to acceleration
   AKANTU_GET_MACRO(F_M2A, f_m2a, Real);
 
   /// set the value of the conversion from forces/ mass to acceleration
   AKANTU_SET_MACRO(F_M2A, f_m2a, Real);
 
   /// get the SolidMechanicsModel::displacement vector
   AKANTU_GET_MACRO(Displacement, *displacement, Array<Real> &);
 
   /// get the SolidMechanicsModel::previous_displacement vector
   AKANTU_GET_MACRO(PreviousDisplacement, *previous_displacement, Array<Real> &);
 
   /// get the SolidMechanicsModel::current_position vector \warn only consistent
   /// after a call to SolidMechanicsModel::updateCurrentPosition
   const Array<Real> & getCurrentPosition();
 
   /// get  the SolidMechanicsModel::increment  vector \warn  only  consistent if
   /// SolidMechanicsModel::setIncrementFlagOn has been called before
   AKANTU_GET_MACRO(Increment, *displacement_increment, Array<Real> &);
 
   /// get the lumped SolidMechanicsModel::mass vector
   AKANTU_GET_MACRO(Mass, *mass, Array<Real> &);
 
   /// get the SolidMechanicsModel::velocity vector
   AKANTU_GET_MACRO(Velocity, *velocity, Array<Real> &);
 
   /// get    the    SolidMechanicsModel::acceleration    vector,   updated    by
   /// SolidMechanicsModel::updateAcceleration
   AKANTU_GET_MACRO(Acceleration, *acceleration, Array<Real> &);
 
   /// get the SolidMechanicsModel::force vector (external forces)
   AKANTU_GET_MACRO(Force, *external_force, Array<Real> &);
 
   /// get the SolidMechanicsModel::internal_force vector (internal forces)
   AKANTU_GET_MACRO(InternalForce, *internal_force, Array<Real> &);
 
   /// get the SolidMechanicsModel::blocked_dofs vector
   AKANTU_GET_MACRO(BlockedDOFs, *blocked_dofs, Array<bool> &);
 
   /// get the value of the SolidMechanicsModel::increment_flag
   AKANTU_GET_MACRO(IncrementFlag, increment_flag, bool);
 
   /// get a particular material (by material index)
   inline Material & getMaterial(UInt mat_index);
 
   /// get a particular material (by material index)
   inline const Material & getMaterial(UInt mat_index) const;
 
   /// get a particular material (by material name)
   inline Material & getMaterial(const std::string & name);
 
   /// get a particular material (by material name)
   inline const Material & getMaterial(const std::string & name) const;
 
   /// get a particular material id from is name
   inline UInt getMaterialIndex(const std::string & name) const;
 
   /// give the number of materials
   inline UInt getNbMaterials() const { return materials.size(); }
 
   inline void setMaterialSelector(MaterialSelector & selector);
 
   /// give the material internal index from its id
   Int getInternalIndexFromID(const ID & id) const;
 
   /// compute the stable time step
   Real getStableTimeStep();
 
   /// get the energies
   Real getEnergy(const std::string & energy_id);
 
   /// compute the energy for energy
   Real getEnergy(const std::string & energy_id, const ElementType & type,
                  UInt index);
 
   /// get the FEEngine object to integrate or interpolate on the boundary
   FEEngine & getFEEngineBoundary(const ID & name = "") override;
 
   AKANTU_GET_MACRO(MaterialByElement, material_index,
                    const ElementTypeMapArray<UInt> &);
 
   /// vectors containing local material element index for each global element
   /// index
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(MaterialByElement, material_index,
                                          UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(MaterialByElement, material_index, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(MaterialLocalNumbering,
                                          material_local_numbering, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(MaterialLocalNumbering,
                                    material_local_numbering, UInt);
 
-  /// Get the type of analysis method used
-  AKANTU_GET_MACRO(AnalysisMethod, method, AnalysisMethod);
-
   /// Access the non_local_manager interface
   AKANTU_GET_MACRO(NonLocalManager, *non_local_manager, NonLocalManager &);
 
 protected:
   friend class Material;
 
 protected:
   /// compute the stable time step
   Real getStableTimeStep(const GhostType & ghost_type);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// conversion coefficient form force/mass to acceleration
   Real f_m2a;
 
   /// displacements array
   Array<Real> * displacement;
   UInt displacement_release{0};
 
   /// displacements array at the previous time step (used in finite deformation)
-  Array<Real> * previous_displacement;
+  Array<Real> * previous_displacement{nullptr};
 
   /// increment of displacement
-  Array<Real> * displacement_increment;
+  Array<Real> * displacement_increment{nullptr};
 
   /// lumped mass array
-  Array<Real> * mass;
+  Array<Real> * mass{nullptr};
+
   /// Check if materials need to recompute the mass array
   bool need_to_reassemble_lumped_mass{true};
   /// Check if materials need to recompute the mass matrix
   bool need_to_reassemble_mass{true};
 
   /// velocities array
-  Array<Real> * velocity;
+  Array<Real> * velocity{nullptr};
 
   /// accelerations array
-  Array<Real> * acceleration;
+  Array<Real> * acceleration{nullptr};
 
   /// accelerations array
   // Array<Real> * increment_acceleration;
 
   /// external forces array
-  Array<Real> * external_force;
+  Array<Real> * external_force{nullptr};
 
   /// internal forces array
-  Array<Real> * internal_force;
+  Array<Real> * internal_force{nullptr};
 
   /// array specifing if a degree of freedom is blocked or not
-  Array<bool> * blocked_dofs;
+  Array<bool> * blocked_dofs{nullptr};
 
   /// array of current position used during update residual
-  Array<Real> * current_position;
+  Array<Real> * current_position{nullptr};
   UInt current_position_release{0};
 
   /// Arrays containing the material index for each element
   ElementTypeMapArray<UInt> material_index;
 
   /// Arrays containing the position in the element filter of the material
   /// (material's local numbering)
   ElementTypeMapArray<UInt> material_local_numbering;
 
 #ifdef SWIGPYTHON
 public:
 #endif
   /// list of used materials
   std::vector<std::unique_ptr<Material>> materials;
 
   /// mapping between material name and material internal id
   std::map<std::string, UInt> materials_names_to_id;
 #ifdef SWIGPYTHON
 protected:
 #endif
 
   /// class defining of to choose a material
   MaterialSelector * material_selector;
 
   /// define if it is the default selector or not
   bool is_default_material_selector;
 
   /// flag defining if the increment must be computed or not
   bool increment_flag;
 
-  /// analysis method check the list in akantu::AnalysisMethod
-  AnalysisMethod method;
-
   /// tells if the material are instantiated
   bool are_materials_instantiated;
 
   typedef std::map<std::pair<std::string, ElementKind>,
                    ElementTypeMapArray<Real> *>
       flatten_internal_map;
 
   /// map a registered internals to be flattened for dump purposes
   flatten_internal_map registered_internals;
 
   /// non local manager
   std::unique_ptr<NonLocalManager> non_local_manager;
 };
 
 /* -------------------------------------------------------------------------- */
 namespace BC {
   namespace Neumann {
     typedef FromHigherDim FromStress;
     typedef FromSameDim FromTraction;
   } // namespace Neumann
 } // namespace BC
 
-/// standard output stream operator
-inline std::ostream & operator<<(std::ostream & stream,
-                                 const SolidMechanicsModel & _this) {
-  _this.printself(stream);
-  return stream;
-}
-
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* inline functions                                                           */
 /* -------------------------------------------------------------------------- */
 #include "material.hh"
 #include "parser.hh"
 
 #include "solid_mechanics_model_inline_impl.cc"
 #include "solid_mechanics_model_tmpl.hh"
 
 #include "material_selector_tmpl.hh"
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
index 079e7c104..019fd1a58 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,773 +1,777 @@
 /**
  * @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 "fe_engine_template.hh"
+#include "integrator_gauss.hh"
 #include "material_cohesive.hh"
+#include "parser.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 = nullptr;
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   facet_synchronizer = nullptr;
   facet_stress_synchronizer = nullptr;
   cohesive_element_synchronizer = nullptr;
   global_connectivity = nullptr;
 #endif
 
   delete material_selector;
   material_selector = new DefaultMaterialCohesiveSelector(*this);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("cohesive elements", id);
   this->mesh.addDumpMeshToDumper("cohesive elements", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_cohesive);
 #endif
 
   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);
+void SolidMechanicsModelCohesive::setTimeStep(Real time_step, const ID & solver_id) {
+  SolidMechanicsModel::setTimeStep(time_step, solver_id);
 
 #if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper("cohesive elements").setTimeStep(time_step);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initFull(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
   const SolidMechanicsModelCohesiveOptions & smmc_options =
       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 != nullptr)
       inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //      inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
     initAutomaticInsertion();
   } else {
     // TODO think of something a bit mor consistant than just coding the first
     // thing that comes in Fabian's head....
     typedef ParserSection::const_section_iterator const_section_iterator;
     std::pair<const_section_iterator, const_section_iterator> sub_sections =
-        this->parser->getSubSections(_st_mesh);
+        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 != nullptr)
     inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //    inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
   std::istringstream split(cohesive_surfaces);
   std::string physname;
   while (std::getline(split, physname, ',')) {
     AKANTU_DEBUG_INFO(
         "Pre-inserting cohesive elements along facets from physical surface: "
         << physname);
     insertElementsFromMeshData(physname);
   }
 
   synchronizeInsertionData();
 
   SolidMechanicsModel::initMaterials();
 
   if (is_default_material_selector)
     delete material_selector;
   material_selector = new MeshDataMaterialCohesiveSelector(*this);
 
   // UInt nb_new_elements =
   inserter->insertElements();
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::synchronizeInsertionData() {
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != nullptr) {
     facet_synchronizer->asynchronousSynchronize(*inserter, _gst_ce_groups);
     facet_synchronizer->waitEndSynchronize(*inserter, _gst_ce_groups);
   }
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initIntrinsicCohesiveMaterials(
     UInt cohesive_index) {
 
   AKANTU_DEBUG_IN();
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     Mesh::type_iterator first =
         mesh.firstType(Model::spatial_dimension, *gt, _ek_cohesive);
     Mesh::type_iterator last =
         mesh.lastType(Model::spatial_dimension, *gt, _ek_cohesive);
 
     for (; first != last; ++first) {
       Array<UInt> & mat_indexes = this->material_index(*first, *gt);
       Array<UInt> & mat_loc_num = this->material_local_numbering(*first, *gt);
       mat_indexes.set(cohesive_index);
       mat_loc_num.clear();
     }
   }
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_synchronizer != nullptr)
     inserter->initParallel(facet_synchronizer, cohesive_element_synchronizer);
 //    inserter->initParallel(facet_synchronizer, synch_parallel);
 #endif
 
   SolidMechanicsModel::initMaterials();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the model,basically it  pre-compute the shapes, shapes derivatives
  * and jacobian
  *
  */
 void SolidMechanicsModelCohesive::initModel() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel::initModel();
 
   registerFEEngineObject<MyFEEngineCohesiveType>("CohesiveFEEngine", mesh,
                                                  Model::spatial_dimension);
 
   /// add cohesive type connectivity
   ElementType type = _not_defined;
 
   for (auto && type_ghost : ghost_types) {
-    for (const auto & tmp_type : mesh.elementTypes(spatial_dimension, type_ghost)) {
-      const Array<UInt> & connectivity = mesh.getConnectivity(tmp_type, type_ghost);
+    for (const auto & tmp_type :
+         mesh.elementTypes(spatial_dimension, type_ghost)) {
+      const Array<UInt> & connectivity =
+          mesh.getConnectivity(tmp_type, type_ghost);
       if (connectivity.size() == 0)
         continue;
 
       type = tmp_type;
       ElementType type_facet = Mesh::getFacetType(type);
       ElementType type_cohesive = FEEngine::getCohesiveElementType(type_facet);
       mesh.addConnectivityType(type_cohesive, type_ghost);
     }
   }
 
   AKANTU_DEBUG_ASSERT(type != _not_defined, "No elements in the mesh");
 
   getFEEngine("CohesiveFEEngine").initShapeFunctions(_not_ghost);
   getFEEngine("CohesiveFEEngine").initShapeFunctions(_ghost);
 
   registerFEEngineObject<MyFEEngineFacetType>(
       "FacetsFEEngine", mesh.getMeshFacets(), Model::spatial_dimension - 1);
 
   if (is_extrinsic) {
     getFEEngine("FacetsFEEngine").initShapeFunctions(_not_ghost);
     getFEEngine("FacetsFEEngine").initShapeFunctions(_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::limitInsertion(BC::Axis axis,
                                                  Real first_limit,
                                                  Real second_limit) {
   AKANTU_DEBUG_IN();
   inserter->setLimit(axis, first_limit, second_limit);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::insertIntrinsicElements() {
   AKANTU_DEBUG_IN();
   // UInt nb_new_elements =
   inserter->insertIntrinsicElements();
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::insertElementsFromMeshData(
     std::string physname) {
   AKANTU_DEBUG_IN();
 
   UInt material_index = SolidMechanicsModel::getMaterialIndex(physname);
   inserter->insertIntrinsicElements(physname, material_index);
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_stress_synchronizer != nullptr) {
     DataAccessor * data_accessor = this;
     const ElementTypeMapArray<UInt> & rank_to_element =
         synch_parallel->getPrankToElement();
 
     facet_stress_synchronizer->updateFacetStressSynchronizer(
         *inserter, rank_to_element, *data_accessor);
   }
 #endif
 
   facet_stress.initialize(inserter->getMeshFacets(),
                           _nb_component = 2 * Model::spatial_dimension *
                                           Model::spatial_dimension,
                           _spatial_dimension = Model::spatial_dimension - 1);
 
   // inserter->getMeshFacets().initElementTypeMapArray(
   //     facet_stress, 2 * spatial_dimension * spatial_dimension,
   //     spatial_dimension - 1);
 
   resizeFacetStress();
 
   /// compute normals on facets
   computeNormals();
 
   initStressInterpolation();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::updateAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
   inserter->limitCheckFacets();
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
   if (facet_stress_synchronizer != nullptr) {
     DataAccessor * data_accessor = this;
     const ElementTypeMapArray<UInt> & rank_to_element =
         synch_parallel->getPrankToElement();
 
     facet_stress_synchronizer->updateFacetStressSynchronizer(
         *inserter, rank_to_element, *data_accessor);
   }
 #endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initStressInterpolation() {
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   /// compute quadrature points coordinates on facets
   Array<Real> & position = mesh.getNodes();
 
   ElementTypeMapArray<Real> quad_facets("quad_facets", id);
   quad_facets.initialize(mesh_facets, _nb_component = Model::spatial_dimension,
                          _spatial_dimension = Model::spatial_dimension - 1);
   // mesh_facets.initElementTypeMapArray(quad_facets, Model::spatial_dimension,
   //                                     Model::spatial_dimension - 1);
 
   getFEEngine("FacetsFEEngine")
       .interpolateOnIntegrationPoints(position, quad_facets);
 
   /// compute elements quadrature point positions and build
   /// element-facet quadrature points data structure
   ElementTypeMapArray<Real> elements_quad_facets("elements_quad_facets", id);
 
   elements_quad_facets.initialize(
       mesh, _nb_component = Model::spatial_dimension,
       _spatial_dimension = Model::spatial_dimension);
   // mesh.initElementTypeMapArray(elements_quad_facets,
   // Model::spatial_dimension,
   //                              Model::spatial_dimension);
 
   for (auto elem_gt : ghost_types) {
     for (auto & type : mesh.elementTypes(Model::spatial_dimension, elem_gt)) {
       UInt nb_element = mesh.getNbElement(type, elem_gt);
       if (nb_element == 0)
         continue;
 
       /// compute elements' quadrature points and list of facet
       /// quadrature points positions by element
       Array<Element> & facet_to_element =
           mesh_facets.getSubelementToElement(type, elem_gt);
       UInt nb_facet_per_elem = facet_to_element.getNbComponent();
 
       Array<Real> & el_q_facet = elements_quad_facets(type, elem_gt);
 
       ElementType facet_type = Mesh::getFacetType(type);
 
       UInt nb_quad_per_facet =
           getFEEngine("FacetsFEEngine").getNbIntegrationPoints(facet_type);
 
       el_q_facet.resize(nb_element * nb_facet_per_elem * nb_quad_per_facet);
 
       for (UInt el = 0; el < nb_element; ++el) {
         for (UInt f = 0; f < nb_facet_per_elem; ++f) {
           Element global_facet_elem = facet_to_element(el, f);
           UInt global_facet = global_facet_elem.element;
           GhostType facet_gt = global_facet_elem.ghost_type;
           const Array<Real> & quad_f = quad_facets(facet_type, facet_gt);
 
           for (UInt q = 0; q < nb_quad_per_facet; ++q) {
             for (UInt s = 0; s < Model::spatial_dimension; ++s) {
               el_q_facet(el * nb_facet_per_elem * nb_quad_per_facet +
                              f * nb_quad_per_facet + q,
                          s) = quad_f(global_facet * nb_quad_per_facet + q, s);
             }
           }
         }
       }
     }
   }
 
   /// loop over non cohesive materials
   for (UInt m = 0; m < materials.size(); ++m) {
     try {
       MaterialCohesive & mat __attribute__((unused)) =
           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 != nullptr)
     cohesive_element_synchronizer->computeAllBufferSizes(*this);
 #endif
 
   if (is_extrinsic)
     resizeFacetStress();
 
   ///  if (method != _explicit_lumped_mass) {
   ///    this->initSolver();
   ///  }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onNodesAdded(const Array<UInt> & new_nodes,
                                                const NewNodesEvent & event) {
   AKANTU_DEBUG_IN();
 
   // Array<UInt> nodes_list(nb_new_nodes);
 
   // for (UInt n = 0; n < nb_new_nodes; ++n)
   //   nodes_list(n) = doubled_nodes(n, 1);
   SolidMechanicsModel::onNodesAdded(new_nodes, event);
 
   UInt new_node, old_node;
 
   try {
     const auto & cohesive_event =
         dynamic_cast<const CohesiveNewNodesEvent &>(event);
     const auto & old_nodes = cohesive_event.getOldNodesList();
 
     auto copy = [this, &new_node, &old_node](auto & arr) {
       for (UInt s = 0; s < spatial_dimension; ++s) {
         arr(new_node, s) = arr(old_node, s);
       }
     };
 
     for (auto && pair : zip(new_nodes, old_nodes)) {
       std::tie(new_node, old_node) = pair;
 
       copy(*displacement);
       copy(*blocked_dofs);
 
       if (velocity)
         copy(*velocity);
 
       if (acceleration)
         copy(*acceleration);
 
       if (current_position)
         copy(*current_position);
 
       if (previous_displacement)
         copy(*previous_displacement);
     }
 
     // if (this->getDOFManager().hasMatrix("M")) {
     //   this->assembleMass(old_nodes);
     // }
 
     // if (this->getDOFManager().hasLumpedMatrix("M")) {
     //   this->assembleMassLumped(old_nodes);
     // }
 
   } catch (std::bad_cast &) {
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onEndSolveStep(const AnalysisMethod &) {
 
   AKANTU_DEBUG_IN();
 
   /*
    * This is required because the Cauchy stress is the stress measure that
    * is used to check the insertion of cohesive elements
    */
   for (auto & mat : materials) {
     if (mat->isFiniteDeformation())
       mat->computeAllCauchyStresses(_not_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::printself(std::ostream & stream,
                                             int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT)
     ;
 
   stream << space << "SolidMechanicsModelCohesive [" << std::endl;
 
   SolidMechanicsModel::printself(stream, indent + 1);
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::resizeFacetStress() {
   AKANTU_DEBUG_IN();
 
   Mesh & mesh_facets = inserter->getMeshFacets();
 
   for (auto && ghost_type : ghost_types) {
     for (const auto & type :
          mesh_facets.elementTypes(spatial_dimension - 1, ghost_type)) {
       UInt nb_facet = mesh_facets.getNbElement(type, ghost_type);
 
       UInt nb_quadrature_points = getFEEngine("FacetsFEEngine")
                                       .getNbIntegrationPoints(type, ghost_type);
 
       UInt new_size = nb_facet * nb_quadrature_points;
 
       facet_stress(type, ghost_type).resize(new_size);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::addDumpGroupFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const std::string & group_name, const ElementKind & element_kind,
     bool padding_flag) {
   AKANTU_DEBUG_IN();
 
   UInt spatial_dimension = Model::spatial_dimension;
   ElementKind _element_kind = element_kind;
   if (dumper_name == "cohesive elements") {
     _element_kind = _ek_cohesive;
   } else if (dumper_name == "facets") {
     spatial_dimension = Model::spatial_dimension - 1;
   }
   SolidMechanicsModel::addDumpGroupFieldToDumper(dumper_name, field_id,
                                                  group_name, spatial_dimension,
                                                  _element_kind, padding_flag);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 void SolidMechanicsModelCohesive::onDump() {
   this->flattenAllRegisteredInternals(_ek_cohesive);
   SolidMechanicsModel::onDump();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh
index 2b79a2475..dfbddcfd3 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh
+++ b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.hh
@@ -1,303 +1,297 @@
 /**
  * @file   solid_mechanics_model_cohesive.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Tue May 08 2012
  * @date last modification: Mon Dec 14 2015
  *
  * @brief  Solid mechanics model for cohesive elements
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
  * Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
  * Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as  published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_HH__
 #define __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_HH__
 
 #include "cohesive_element_inserter.hh"
 #include "material_selector_cohesive.hh"
 #include "solid_mechanics_model.hh"
 #include "solid_mechanics_model_event_handler.hh"
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
 #include "facet_stress_synchronizer.hh"
 #include "facet_synchronizer.hh"
 #endif
 
 #include "random_internal_field.hh" // included to have the specialization of
                                     // ParameterTyped::operator Real()
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 struct FacetsCohesiveIntegrationOrderFunctor {
   template <ElementType type, ElementType cohesive_type =
                                   CohesiveFacetProperty<type>::cohesive_type>
   struct _helper {
     static constexpr int get() {
       return ElementClassProperty<cohesive_type>::polynomial_degree;
     }
   };
 
   template <ElementType type> struct _helper<type, _not_defined> {
     static constexpr int get() {
       return ElementClassProperty<type>::polynomial_degree;
     }
   };
 
   template <ElementType type> static inline constexpr int getOrder() {
     return _helper<type>::get();
   }
 };
 
 namespace {
   DECLARE_NAMED_ARGUMENT(is_extrinsic);
 }
 /* -------------------------------------------------------------------------- */
 struct SolidMechanicsModelCohesiveOptions : public SolidMechanicsModelOptions {
   SolidMechanicsModelCohesiveOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass,
       bool extrinsic = false)
       : SolidMechanicsModelOptions(analysis_method), extrinsic(extrinsic) {}
 
   template <typename... pack>
   SolidMechanicsModelCohesiveOptions(use_named_args_t, pack &&... _pack)
       : SolidMechanicsModelCohesiveOptions(
             OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass),
             OPTIONAL_NAMED_ARG(is_extrinsic, false)) {}
 
   bool extrinsic{false};
 };
 
 /* -------------------------------------------------------------------------- */
 /* Solid Mechanics Model for Cohesive elements                                */
 /* -------------------------------------------------------------------------- */
 
 class SolidMechanicsModelCohesive : public SolidMechanicsModel,
                                     public SolidMechanicsModelEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   class NewCohesiveNodesEvent : public NewNodesEvent {
   public:
     AKANTU_GET_MACRO_NOT_CONST(OldNodesList, old_nodes, Array<UInt> &);
     AKANTU_GET_MACRO(OldNodesList, old_nodes, const Array<UInt> &);
 
   protected:
     Array<UInt> old_nodes;
   };
 
   typedef FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive>
       MyFEEngineCohesiveType;
   typedef FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular,
                            FacetsCohesiveIntegrationOrderFunctor>
       MyFEEngineFacetType;
 
   SolidMechanicsModelCohesive(Mesh & mesh,
                               UInt spatial_dimension = _all_dimensions,
                               const ID & id = "solid_mechanics_model_cohesive",
                               const MemoryID & memory_id = 0);
 
-  virtual ~SolidMechanicsModelCohesive();
+  ~SolidMechanicsModelCohesive() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   /// set the value of the time step
-  void setTimeStep(Real time_step);
+  void setTimeStep(Real time_step, const ID & solver_id = "") override;
 
   /// assemble the residual for the explicit scheme
-  virtual void assembleInternalForces();
-
-  /// function to print the contain of the class
-  virtual void printself(std::ostream & stream, int indent = 0) const;
+  void assembleInternalForces() override;
 
   /// function to perform a stress check on each facet and insert
   /// cohesive elements if needed (returns the number of new cohesive
   /// elements)
   UInt checkCohesiveStress();
 
   /// interpolate stress on facets
   void interpolateStress();
 
   /// initialize the cohesive model
-  void
-  initFull(const ModelOptions & options = SolidMechanicsModelCohesiveOptions());
+  void initFull(const ModelOptions & options =
+                    SolidMechanicsModelCohesiveOptions()) override;
 
   template <typename P, typename T, typename... pack>
   void initFull(named_argument::param_t<P, T &&> && first, pack &&... _pack) {
     this->initFull(
         SolidMechanicsModelCohesiveOptions{use_named_args, first, _pack...});
   }
 
-  /// initialize the model
-  void initModel();
-
-  /// initialize cohesive material
-  void initMaterials();
-
-  /// init facet filters for cohesive materials
-  void initFacetFilter();
 
   /// limit the cohesive element insertion to a given area
   void limitInsertion(BC::Axis axis, Real first_limit, Real second_limit);
 
   /// update automatic insertion after a change in the element inserter
   void updateAutomaticInsertion();
 
   /// insert intrinsic cohesive elements
   void insertIntrinsicElements();
 
-  // synchronize facets physical data before insertion along physical surfaces
-  void synchronizeInsertionData();
-
   // template <SolveConvergenceMethod cmethod, SolveConvergenceCriteria
   // criteria> bool solveStepCohesive(Real tolerance, Real & error, UInt
   // max_iteration = 100,
   //                        bool load_reduction = false,
   //                        Real tol_increase_factor = 1.0,
   //                        bool do_not_factorize = false);
 
+protected:
   /// initialize stress interpolation
   void initStressInterpolation();
 
+    /// initialize the model
+  void initModel() override;
+
+  /// initialize cohesive material
+  void initMaterials() override;
+
+  /// init facet filters for cohesive materials
+  void initFacetFilter();
+
+  // synchronize facets physical data before insertion along physical surfaces
+  void synchronizeInsertionData();
+
+  /// function to print the contain of the class
+  void printself(std::ostream & stream, int indent = 0) const override;
+
 private:
   /// initialize cohesive material with intrinsic insertion (by default)
   void initIntrinsicCohesiveMaterials(UInt cohesive_index);
 
   ///  initialize cohesive material with intrinsic insertion (if physical
   ///  surfaces are precised)
   void initIntrinsicCohesiveMaterials(std::string cohesive_surfaces);
 
   /// insert cohesive elements along a given physical surface of the mesh
   void insertElementsFromMeshData(std::string physical_name);
 
   /// initialize completely the model for extrinsic elements
   void initAutomaticInsertion();
 
   /// compute facets' normals
   void computeNormals();
 
   /// resize facet stress
   void resizeFacetStress();
 
   /// init facets_check array
   void initFacetsCheck();
 
   /* ------------------------------------------------------------------------ */
   /* Mesh Event Handler inherited members                                     */
   /* ------------------------------------------------------------------------ */
 
 protected:
-  virtual void onNodesAdded(const Array<UInt> & nodes_list,
-                            const NewNodesEvent & event);
-  virtual void onElementsAdded(const Array<Element> & nodes_list,
-                               const NewElementsEvent & event);
+  void onNodesAdded(const Array<UInt> & nodes_list,
+                    const NewNodesEvent & event) override;
+  void onElementsAdded(const Array<Element> & nodes_list,
+                       const NewElementsEvent & event) override;
 
   /* ------------------------------------------------------------------------ */
   /* SolidMechanicsModelEventHandler inherited members                        */
   /* ------------------------------------------------------------------------ */
 public:
-  virtual void onEndSolveStep(const AnalysisMethod & method);
+  void onEndSolveStep(const AnalysisMethod & method) override;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
-  virtual void onDump();
+  void onDump() override;
 
-  virtual void addDumpGroupFieldToDumper(const std::string & dumper_name,
-                                         const std::string & field_id,
-                                         const std::string & group_name,
-                                         const ElementKind & element_kind,
-                                         bool padding_flag);
+  void addDumpGroupFieldToDumper(const std::string & dumper_name,
+                                 const std::string & field_id,
+                                 const std::string & group_name,
+                                 const ElementKind & element_kind,
+                                 bool padding_flag) override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get facet mesh
   AKANTU_GET_MACRO(MeshFacets, mesh.getMeshFacets(), const Mesh &);
 
   /// get stress on facets vector
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(StressOnFacets, facet_stress, Real);
 
   /// get facet material
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE(FacetMaterial, facet_material, UInt);
 
   /// get facet material
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(FacetMaterial, facet_material, UInt);
 
   /// get facet material
   AKANTU_GET_MACRO(FacetMaterial, facet_material,
                    const ElementTypeMapArray<UInt> &);
 
   /// @todo THIS HAS TO BE CHANGED
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Tangents, tangents, Real);
 
   /// get element inserter
   AKANTU_GET_MACRO_NOT_CONST(ElementInserter, *inserter,
                              CohesiveElementInserter &);
 
   /// get is_extrinsic boolean
   AKANTU_GET_MACRO(IsExtrinsic, is_extrinsic, bool);
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// @todo store tangents when normals are computed:
   ElementTypeMapArray<Real> tangents;
 
   /// stress on facets on the two sides by quadrature point
   ElementTypeMapArray<Real> facet_stress;
 
   /// material to use if a cohesive element is created on a facet
   ElementTypeMapArray<UInt> facet_material;
 
   bool is_extrinsic;
 
   /// cohesive element inserter
   CohesiveElementInserter * inserter;
 
 #if defined(AKANTU_PARALLEL_COHESIVE_ELEMENT)
 #include "solid_mechanics_model_cohesive_parallel.hh"
 #endif
 };
 
-/* -------------------------------------------------------------------------- */
-/// standard output stream operator
-inline std::ostream & operator<<(std::ostream & stream,
-                                 const SolidMechanicsModelCohesive & _this) {
-  _this.printself(stream);
-  return stream;
-}
-
 } // namespace akantu
 
 #include "solid_mechanics_model_cohesive_inline_impl.cc"
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_COHESIVE_HH__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc b/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
index 1e9873c88..9d436f00f 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_inline_impl.cc
@@ -1,124 +1,124 @@
 /**
  * @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) {}
+    : ModelOptions(analysis_method) {}
 
 /* -------------------------------------------------------------------------- */
 template <typename... pack>
 SolidMechanicsModelOptions::SolidMechanicsModelOptions(use_named_args_t,
                                                        pack &&... _pack)
     : SolidMechanicsModelOptions(
           OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass)) {}
 
 /* -------------------------------------------------------------------------- */
 inline Material & SolidMechanicsModel::getMaterial(UInt mat_index) {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(mat_index < materials.size(),
                       "The model " << id << " has no material no "
                                    << mat_index);
   AKANTU_DEBUG_OUT();
   return *materials[mat_index];
 }
 
 /* -------------------------------------------------------------------------- */
 inline const Material & SolidMechanicsModel::getMaterial(UInt mat_index) const {
   AKANTU_DEBUG_IN();
   AKANTU_DEBUG_ASSERT(mat_index < materials.size(),
                       "The model " << id << " has no material no "
                                    << mat_index);
   AKANTU_DEBUG_OUT();
   return *materials[mat_index];
 }
 
 /* -------------------------------------------------------------------------- */
 inline Material & SolidMechanicsModel::getMaterial(const std::string & name) {
   AKANTU_DEBUG_IN();
   std::map<std::string, UInt>::const_iterator it =
       materials_names_to_id.find(name);
   AKANTU_DEBUG_ASSERT(it != materials_names_to_id.end(),
                       "The model " << id << " has no material named " << name);
   AKANTU_DEBUG_OUT();
   return *materials[it->second];
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt
 SolidMechanicsModel::getMaterialIndex(const std::string & name) const {
   AKANTU_DEBUG_IN();
   std::map<std::string, UInt>::const_iterator it =
       materials_names_to_id.find(name);
   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;
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
 
 #endif /* __AKANTU_SOLID_MECHANICS_MODEL_INLINE_IMPL_CC__ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model_material.cc b/src/model/solid_mechanics/solid_mechanics_model_material.cc
index 8ed83cee0..9d4f6dbb0 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_material.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_material.cc
@@ -1,316 +1,262 @@
 /**
  * @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 "mesh_iterators.hh"
 #include "non_local_manager.hh"
-#endif
+#include "solid_mechanics_model.hh"
 /* -------------------------------------------------------------------------- */
 
 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, 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);
+      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);
   }
 
 #ifdef AKANTU_DAMAGE_NON_LOCAL
   for (auto & material : materials) {
     if (dynamic_cast<MaterialNonLocalInterface *>(material.get()) == nullptr)
       continue;
 
     this->non_local_manager = std::make_unique<NonLocalManager>(
         *this, *this, id + ":non_local_manager", memory_id);
     break;
   }
 #endif
 
   are_materials_instantiated = true;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assignMaterialToElements(
     const ElementTypeMapArray<UInt> * filter) {
 
-  Element element;
-  element.ghost_type = _not_ghost;
-
-  auto element_types =
-      mesh.elementTypes(spatial_dimension, _not_ghost, _ek_not_defined);
-  if (filter != nullptr) {
-    element_types =
-        filter->elementTypes(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 = nullptr;
-    if (filter != nullptr) {
-      filter_array = &((*filter)(type, _not_ghost));
-      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 != nullptr)
-        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;
-    }
-  }
+  for_each_elements(mesh,
+                    [&](auto && element) {
+                      UInt mat_index = (*material_selector)(element);
+                      AKANTU_DEBUG_ASSERT(
+                          mat_index < materials.size(),
+                          "The material selector returned an index that does not exists");
+                      material_index(element) = mat_index;
+                    },
+                    _element_filter = filter,
+                    _ghost_type = _not_ghost);
 
   if (non_local_manager)
     non_local_manager->synchronize(*this, _gst_material_id);
 
-  /// fill the element filters of the materials using the element_material
-  /// arrays
-  auto ghost_type = _not_ghost;
-  if (filter != nullptr) {
-    element_types =
-        filter->elementTypes(spatial_dimension, ghost_type, _ek_not_defined);
-  } else {
-    element_types =
-        mesh.elementTypes(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 = nullptr;
-    if (filter != nullptr) {
-      filter_array = &((*filter)(type, ghost_type));
-      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 != nullptr)
-        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;
-    }
-  }
+  for_each_elements(mesh,
+                    [&](auto && element) {
+                      auto mat_index = material_index(element);
+                      auto index = materials[mat_index]->addElement(element);
+                      material_local_numbering(element) = index;
+                    },
+                    _element_filter = filter,
+                    _ghost_type = _not_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initMaterials() {
   AKANTU_DEBUG_ASSERT(materials.size() != 0, "No material to initialize !");
 
   if (!are_materials_instantiated)
     instantiateMaterials();
 
   this->assignMaterialToElements();
   // synchronize the element material arrays
   this->synchronize(_gst_material_id);
 
   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;
   }
 
   if (this->non_local_manager) {
     this->non_local_manager->initialize();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 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(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() ==
                           spatial_dimension * 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/time_step_solvers/time_step_solver_default.cc b/src/model/time_step_solvers/time_step_solver_default.cc
index 2fb87bb46..dcf576d46 100644
--- a/src/model/time_step_solvers/time_step_solver_default.cc
+++ b/src/model/time_step_solvers/time_step_solver_default.cc
@@ -1,280 +1,282 @@
 /**
  * @file   time_step_solver_default.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date   Wed Sep 16 10:20:55 2015
  *
  * @brief  Default implementation of the time step solver
  *
  * @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 "time_step_solver_default.hh"
 #include "dof_manager_default.hh"
 #include "integration_scheme_1st_order.hh"
 #include "integration_scheme_2nd_order.hh"
 #include "mesh.hh"
 #include "non_linear_solver.hh"
 #include "pseudo_time.hh"
 #include "sparse_matrix_aij.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverDefault::TimeStepSolverDefault(
     DOFManagerDefault & dof_manager, const TimeStepSolverType & type,
     NonLinearSolver & non_linear_solver, const ID & id, UInt memory_id)
     : TimeStepSolver(dof_manager, type, non_linear_solver, id, memory_id),
       dof_manager(dof_manager), is_mass_lumped(false) {
   switch (type) {
   case _tsst_dynamic:
     break;
   case _tsst_dynamic_lumped:
     this->is_mass_lumped = true;
     break;
   case _tsst_static:
     /// initialize a static time solver for callback dofs
     break;
+  default:
+    AKANTU_DEBUG_TO_IMPLEMENT();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::setIntegrationScheme(
     const ID & dof_id, const IntegrationSchemeType & type,
     IntegrationScheme::SolutionType solution_type) {
   if (this->integration_schemes.find(dof_id) !=
       this->integration_schemes.end()) {
     AKANTU_EXCEPTION("Their DOFs "
                      << dof_id
                      << "  have already an integration scheme associated");
   }
 
   std::unique_ptr<IntegrationScheme> integration_scheme;
   if (this->is_mass_lumped) {
     switch (type) {
     case _ist_forward_euler: {
       integration_scheme = std::make_unique<ForwardEuler>(dof_manager, dof_id);
       break;
     }
     case _ist_central_difference: {
       integration_scheme =
           std::make_unique<CentralDifference>(dof_manager, dof_id);
       break;
     }
     default:
       AKANTU_EXCEPTION(
           "This integration scheme cannot be used in lumped dynamic");
     }
   } else {
     switch (type) {
     case _ist_pseudo_time: {
       integration_scheme = std::make_unique<PseudoTime>(dof_manager, dof_id);
       break;
     }
     case _ist_forward_euler: {
       integration_scheme = std::make_unique<ForwardEuler>(dof_manager, dof_id);
       break;
     }
     case _ist_trapezoidal_rule_1: {
       integration_scheme =
           std::make_unique<TrapezoidalRule1>(dof_manager, dof_id);
       break;
     }
     case _ist_backward_euler: {
       integration_scheme = std::make_unique<BackwardEuler>(dof_manager, dof_id);
       break;
     }
     case _ist_central_difference: {
       integration_scheme =
           std::make_unique<CentralDifference>(dof_manager, dof_id);
       break;
     }
     case _ist_fox_goodwin: {
       integration_scheme = std::make_unique<FoxGoodwin>(dof_manager, dof_id);
       break;
     }
     case _ist_trapezoidal_rule_2: {
       integration_scheme =
           std::make_unique<TrapezoidalRule2>(dof_manager, dof_id);
       break;
     }
     case _ist_linear_acceleration: {
       integration_scheme =
           std::make_unique<LinearAceleration>(dof_manager, dof_id);
       break;
     }
     case _ist_generalized_trapezoidal: {
       integration_scheme =
           std::make_unique<GeneralizedTrapezoidal>(dof_manager, dof_id);
       break;
     }
     case _ist_newmark_beta:
       integration_scheme = std::make_unique<NewmarkBeta>(dof_manager, dof_id);
       break;
     }
   }
 
   AKANTU_DEBUG_ASSERT(integration_scheme,
                       "No integration scheme was found for the provided types");
 
   auto && matrices_names = integration_scheme->getNeededMatrixList();
   for (auto && name : matrices_names) {
     needed_matrices.insert({name, _mt_not_defined});
   }
 
   this->integration_schemes[dof_id] = std::move(integration_scheme);
   this->solution_types[dof_id] = solution_type;
 
   this->integration_schemes_owner.insert(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 bool TimeStepSolverDefault::hasIntegrationScheme(const ID & dof_id) const {
   return this->integration_schemes.find(dof_id) !=
          this->integration_schemes.end();
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverDefault::~TimeStepSolverDefault() = default;
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::solveStep(SolverCallback & solver_callback) {
   this->solver_callback = &solver_callback;
 
   this->solver_callback->beforeSolveStep();
   this->non_linear_solver.solve(*this);
   this->solver_callback->afterSolveStep();
 
   this->solver_callback = NULL;
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::predictor() {
   AKANTU_DEBUG_IN();
 
   TimeStepSolver::predictor();
 
   for (auto & pair : this->integration_schemes) {
     auto & dof_id = pair.first;
     auto & integration_scheme = pair.second;
 
     if (this->dof_manager.hasPreviousDOFs(dof_id)) {
       this->dof_manager.savePreviousDOFs(dof_id);
     }
 
     /// integrator predictor
     integration_scheme->predictor(this->time_step);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::corrector() {
   AKANTU_DEBUG_IN();
 
   TimeStepSolver::corrector();
 
   for (auto & pair : this->integration_schemes) {
     auto & dof_id = pair.first;
     auto & integration_scheme = pair.second;
 
     const auto & solution_type = this->solution_types[dof_id];
     integration_scheme->corrector(solution_type, this->time_step);
 
     /// computing the increment of dof if needed
     if (this->dof_manager.hasDOFsIncrement(dof_id)) {
       if (!this->dof_manager.hasPreviousDOFs(dof_id)) {
         AKANTU_DEBUG_WARNING("In order to compute the increment of "
                              << dof_id << " a 'previous' has to be registered");
         continue;
       }
 
       Array<Real> & increment = this->dof_manager.getDOFsIncrement(dof_id);
       Array<Real> & previous = this->dof_manager.getPreviousDOFs(dof_id);
 
       UInt dof_array_comp = this->dof_manager.getDOFs(dof_id).getNbComponent();
 
       auto prev_dof_it = previous.begin(dof_array_comp);
       auto incr_it = increment.begin(dof_array_comp);
       auto incr_end = increment.end(dof_array_comp);
 
       increment.copy(this->dof_manager.getDOFs(dof_id));
       for (; incr_it != incr_end; ++incr_it, ++prev_dof_it) {
         *incr_it -= *prev_dof_it;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::assembleMatrix(const ID & matrix_id) {
   AKANTU_DEBUG_IN();
 
   TimeStepSolver::assembleMatrix(matrix_id);
 
   if (matrix_id != "J")
     return;
 
   for (auto & pair : this->integration_schemes) {
     auto & dof_id = pair.first;
     auto & integration_scheme = pair.second;
 
     const auto & solution_type = this->solution_types[dof_id];
 
     integration_scheme->assembleJacobian(solution_type, this->time_step);
   }
 
   this->dof_manager.applyBoundary("J");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void TimeStepSolverDefault::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   if (this->needed_matrices.find("M") != needed_matrices.end()) {
     if (this->is_mass_lumped) {
       this->assembleLumpedMatrix("M");
     } else {
       this->assembleMatrix("M");
     }
   }
 
   TimeStepSolver::assembleResidual();
 
   for (auto & pair : this->integration_schemes) {
     auto & integration_scheme = pair.second;
 
     integration_scheme->assembleResidual(this->is_mass_lumped);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu