diff --git a/.editorconfig b/.editorconfig
index ea74e14a8..8a9c9f15b 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,23 +1,18 @@
 # EditorConfig is awesome: https://EditorConfig.org
 
 # top-most EditorConfig file
 root = true
 
 [*]
 end_of_line = lf
 insert_final_newline = true
 max_line_length = 80
-
-
-[*.{py,cc,hh,cmake,tcc}]
-charset = utf-8
-indent_style = space
-indent_size = 4
-
-[CMakeLists.txt]
 charset = utf-8
 indent_style = space
 indent_size = 2
 
+[*.py]
+indent_size = 4
+
 [*.tcc]
 file_type_emacs = c++
diff --git a/.gitignore b/.gitignore
index 7dd72dc48..d3ad89d2c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,26 +1,27 @@
 build*
 .dir-locals.el
 TAGS
 third-party/*/
 !third-party/cmake/*
 !third-party/akantu-iterators
 !third-party/iohelper
 *~
 release
 .*.swp
 *.tar.gz
 *.tgz
 *.tbz
 *.tar.bz2
 .idea
 __pycache__
 .mailmap
 paraview/*
 *.vtu
 *.pvd
 *.pvtu
 *.vtk
 compile_commands.json
 .clangd
 .iwyu.imp
 .cache
+setup.cfg
diff --git a/.gitlab-ci.d/code-quality.yaml b/.gitlab-ci.d/code-quality.yaml
new file mode 100644
index 000000000..5b5836d84
--- /dev/null
+++ b/.gitlab-ci.d/code-quality.yaml
@@ -0,0 +1,63 @@
+.code_quality_common:
+  stage: code_quality
+  allow_failure: true
+  rules:
+    - if: '$CODE_QUALITY_DISABLED'
+      when: never
+    - if: '$CI_COMMIT_TAG || $CI_COMMIT_BRANCH'
+
+.code_quality_gitlab_template:
+  extends:
+    - .code_quality_common
+  image: docker:19.03.12
+  allow_failure: true
+  services:
+    - docker:19.03.12-dind
+  variables:
+    DOCKER_DRIVER: overlay2
+    DOCKER_TLS_CERTDIR: ""
+    CODE_QUALITY_IMAGE: "registry.gitlab.com/gitlab-org/ci-cd/codequality:0.85.24"
+  needs: []
+  script:
+    - export SOURCE_CODE=$PWD
+    - |
+      if ! docker info &>/dev/null; then
+        if [ -z "$DOCKER_HOST" -a "$KUBERNETES_PORT" ]; then
+          export DOCKER_HOST='tcp://localhost:2375'
+        fi
+      fi
+    - | # this is required to avoid undesirable reset of Docker image ENV variables being set on build stage
+      function propagate_env_vars() {
+        CURRENT_ENV=$(printenv)
+
+        for VAR_NAME; do
+          echo $CURRENT_ENV | grep "${VAR_NAME}=" > /dev/null && echo "--env $VAR_NAME "
+        done
+      }
+    - docker pull --quiet "$CODE_QUALITY_IMAGE"
+    - |
+      docker run --rm \
+        $(propagate_env_vars \
+          SOURCE_CODE \
+          TIMEOUT_SECONDS \
+          CODECLIMATE_DEBUG \
+          CODECLIMATE_DEV \
+          REPORT_STDOUT \
+          REPORT_FORMAT \
+          ENGINE_MEMORY_LIMIT_BYTES \
+          CODECLIMATE_PREFIX \
+        ) \
+        --volume "$PWD":/code \
+        --volume /var/run/docker.sock:/var/run/docker.sock \
+        "$CODE_QUALITY_IMAGE" /code
+
+.clang_tools:
+  extends:
+    - .code_quality_common
+    - .debian_testing_clang
+  before_script:
+    - if [ 'x${CI_MERGE_REQUEST_ID}' != 'x' ]; then
+    -   git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
+    -   git diff --name-only $CI_COMMIT_SHA $CI_MERGE_REQUEST_TARGET_BRANCH_NAME > file_list
+    -   FILE_LIST_ARG='-f file_list'
+    - fi
diff --git a/.gitlab-ci.d/images.yaml b/.gitlab-ci.d/images.yaml
new file mode 100644
index 000000000..6d5d70dbf
--- /dev/null
+++ b/.gitlab-ci.d/images.yaml
@@ -0,0 +1,109 @@
+.docker_build:
+  image: "docker:19.03.11"
+  stage: .pre
+  services:
+    - docker:19.03.11-dind
+  variables:
+    # Use TLS https://docs.gitlab.com/ee/ci/docker/using_docker_build.html#tls-enabled
+    DOCKER_HOST: tcp://docker:2376
+    DOCKER_TLS_CERTDIR: "/certs"
+  before_script:
+    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+  script:
+    - cd test/ci/${IMAGE_NAME}/
+    - docker build -t registry.gitlab.com/akantu/akantu/${IMAGE_NAME} .
+    - docker push registry.gitlab.com/akantu/akantu/${IMAGE_NAME}
+  rules:
+    - changes:
+        - test/ci/${IMAGE_NAME}/*
+
+# ------------------------------------------------------------------------------
+.cache_build:
+  variables:
+    CCACHE_BASEDIR: ${CI_PROJECT_DIR}/
+    CCACHE_DIR: ${CI_PROJECT_DIR}/.ccache
+    CCACHE_MAXSIZE: 1Gi
+  cache:
+    key: ${output}_${BUILD_TYPE}
+    policy: pull-push
+    paths:
+      - .ccache/
+      - third-party/google-test
+      - third-party/pybind11
+  before_script:
+    - ccache --zero-stats || true
+  after_script:
+    - ccache --show-stats || true
+
+# ------------------------------------------------------------------------------
+.image_debian_testing:
+  image: registry.gitlab.com/akantu/akantu/debian:testing
+
+.image_ubuntu_lts:
+  image: registry.gitlab.com/akantu/akantu/ubuntu:lts
+
+.image_manylinux:
+  image: registry.gitlab.com/akantu/akantu/manylinux:2010_x86_64
+
+# ------------------------------------------------------------------------------
+.compiler_gcc:
+  variables:
+    CC: /usr/lib/ccache/gcc
+    CXX: /usr/lib/ccache/g++
+    FC: gfortran
+    GCOV_EXECUTABLE: gcov
+
+.compiler_clang:
+  variables:
+    CC: /usr/lib/ccache/clang
+    CXX: /usr/lib/ccache/clang++
+    FC: gfortran
+    GCOV_EXECUTABLE: llvm-cov gcov
+
+.build_coverage:
+  variables:
+    TEST_EXAMPLES: "FALSE"
+    BUILD_TYPE: "Coverage"
+
+.build_release:
+  variables:
+    TEST_EXAMPLES: "TRUE"
+    BUILD_TYPE: "Release"
+
+.build_valgrind:
+  variables:
+    TEST_EXAMPLES: "FALSE"
+    BUILD_TYPE: "Valgrind"
+
+# ------------------------------------------------------------------------------
+.debian_testing_gcc:
+  variables:
+    output: debian_testing_gcc
+  extends:
+    - .compiler_gcc
+    - .image_debian_testing
+    - .cache_build
+
+.debian_testing_clang:
+  variables:
+    output: debian_testing_clang
+  extends:
+    - .compiler_clang
+    - .image_debian_testing
+    - .cache_build
+
+.ubuntu_lts_gcc:
+  variables:
+    output: ubuntu_lts_gcc
+  extends:
+    - .compiler_gcc
+    - .image_ubuntu_lts
+    - .cache_build
+
+.manylinux_2010_x64_gcc:
+  variables:
+    output: manylinux_2010_x64_gcc
+  extends:
+    - .compiler_gcc
+    - .image_manylinux
+    - .cache_build
diff --git a/.gitlab-ci.d/templates.yaml b/.gitlab-ci.d/templates.yaml
new file mode 100644
index 000000000..e507a182c
--- /dev/null
+++ b/.gitlab-ci.d/templates.yaml
@@ -0,0 +1,133 @@
+# Configuration template
+.configure:
+  stage: configure
+  except:
+    - tags
+  variables:
+    BLA_VENDOR: "Generic"
+    CMAKE_GENERATOR: "Unix Makefiles"
+  #    CMAKE_GENERATOR: 'Ninja'
+  script:
+    # Create the build folder
+    - cmake -E make_directory build
+    - cd build
+
+    # Configure the project
+    - cmake -DAKANTU_COHESIVE_ELEMENT:BOOL=TRUE
+            -DAKANTU_IMPLICIT:BOOL=TRUE
+            -DAKANTU_PARALLEL:BOOL=TRUE
+            -DAKANTU_STRUCTURAL_MECHANICS:BOOL=TRUE
+            -DAKANTU_HEAT_TRANSFER:BOOL=TRUE
+            -DAKANTU_DAMAGE_NON_LOCAL:BOOL=TRUE
+            -DAKANTU_PHASE_FIELD:BOOL=TRUE
+            -DAKANTU_PYTHON_INTERFACE:BOOL=TRUE
+            -DAKANTU_CONTACT_MECHANICS:BOOL=TRUE
+            -DAKANTU_EXAMPLES:BOOL=TRUE
+            -DAKANTU_BUILD_ALL_EXAMPLES:BOOL=TRUE
+            -DAKANTU_TESTS:BOOL=TRUE
+            -DAKANTU_RUN_IN_DOCKER:BOOL=TRUE
+            -DAKANTU_TEST_EXAMPLES:BOOL=${TEST_EXAMPLES}
+            -DCMAKE_BUILD_TYPE:STRING=${BUILD_TYPE}
+            -G "${CMAKE_GENERATOR}" ..
+
+    # Copie the compile commands for the code quality
+    - if [ -e compile_commands.json ]; then
+    -   cp compile_commands.json ..
+    - fi
+  artifacts:
+    when: on_success
+    paths:
+      - build
+      - compile_commands.json
+    expire_in: 10h
+
+# Build the libraries
+.build_libs:
+  stage: build_libs
+  script:
+    - cmake --build build --target akantu -j1
+             > >(tee -a build-${output}-out.log)
+            2> >(tee -a build-${output}-err.log >&2)
+    - cmake --build build --target py11_akantu -j1
+             > >(tee -a build-${output}-out.log)
+            2> >(tee -a build-${output}-err.log >&2)
+  artifacts:
+    when: on_success
+    paths:
+      - build/
+      - build-${output}-err.log
+      - compile_commands.json
+    expire_in: 10h
+
+# build the tests
+.build_tests:
+  stage: build_tests
+  script:
+    - cmake --build build -j1
+             > >(tee -a build-${output}-out.log)
+            2> >(tee -a build-${output}-err.log >&2)
+  artifacts:
+    when: on_success
+    paths:
+      - build/
+      - build-${output}-err.log
+      - compile_commands.json
+    exclude:
+      - build/**/*.o
+    expire_in: 10h
+
+# Build all
+.build_all:
+  stage: build_libs
+  script:
+    - cmake --build build/src
+             > >(tee -a build-${output}-out.log)
+            2> >(tee -a build-${output}-err.log >&2)
+    - cmake --build build/python
+             > >(tee -a build-${output}-out.log)
+            2> >(tee -a build-${output}-err.log >&2)
+    - cmake --build build/test/
+             > >(tee -a build-${output}-out.log)
+            2> >(tee -a build-${output}-err.log >&2)
+    - cmake --build build/examples
+             > >(tee -a build-${output}-out.log)
+            2> >(tee -a build-${output}-err.log >&2)
+  artifacts:
+    when: on_success
+    paths:
+      - build/
+      - build-${output}-err.log
+      - compile_commands.json
+    exclude:
+      - build/**/*.o
+    expire_in: 10h
+
+# Run the tests
+.tests:
+  stage: test
+  script:
+    - cd build
+    - ctest -T test --output-on-failure --no-compress-output --timeout 1800
+  after_script:
+    - cd build
+    - tag=$(head -n 1 < Testing/TAG)
+    - if [ -e Testing/${tag}/Test.xml ]; then
+    -   xsltproc -o ./juint.xml ${CI_PROJECT_DIR}/test/ci/ctest2junit.xsl Testing/${tag}/Test.xml;
+    - fi
+    - if [ ${CMAKE_BUILD_TYPE} = "Coverage" ]; then
+    -   gcovr --xml
+              --gcov-executable "${GCOV_EXECUTABLE}"
+              --output coverage.xml
+              --object-directory ${CI_PROJECT_DIR}/build
+              --root ${CI_PROJECT_DIR}  -s || true
+    - fi
+  artifacts:
+    when: always
+    paths:
+      - build/juint.xml
+      - build/coverage.xml
+    reports:
+      junit:
+        - build/juint.xml
+      cobertura:
+        - build/coverage.xml
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 4dfb06087..cb7d307e1 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,450 +1,375 @@
 stages:
   - configure
-  - build
+  - build_libs
+  - build_tests
   - test
+  - code_quality
   - deploy
 
-.docker_build:
-  image: 'docker:19.03.11'
-  stage: .pre
-  services:
-    - docker:19.03.11-dind
-  variables:
-    # Use TLS https://docs.gitlab.com/ee/ci/docker/using_docker_build.html#tls-enabled
-    DOCKER_HOST: tcp://docker:2376
-    DOCKER_TLS_CERTDIR: "/certs"
-  before_script:
-    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
-  script:
-    - cd test/ci/${IMAGE_NAME}/
-    - docker build -t registry.gitlab.com/akantu/akantu/${IMAGE_NAME} .
-    - docker push registry.gitlab.com/akantu/akantu/${IMAGE_NAME}
+include:
+  local: '.gitlab-ci.d/*.yaml'
 
+#-------------------------------------------------------------------------------
+# Rebuilding the docker images if needed
+#-------------------------------------------------------------------------------
 docker build:debian-testing:
   variables:
     IMAGE_NAME: debian:testing
   extends: .docker_build
-  rules:
-    - changes:
-        - test/ci/debian:testing/Dockerfile
 
 docker build:ubuntu-lts:
   variables:
     IMAGE_NAME: ubuntu:lts
   extends: .docker_build
-  rules:
-    - changes:
-        - test/ci/ubuntu:lts/Dockerfile
-
-.configure:
-  stage: configure
-  except:
-    - tags
-  variables:
-    BLA_VENDOR: 'Generic'
-  script:
-    - cmake -E make_directory build
-    - cd build
-    - cmake -DAKANTU_COHESIVE_ELEMENT:BOOL=TRUE
-            -DAKANTU_IMPLICIT:BOOL=TRUE
-            -DAKANTU_PARALLEL:BOOL=TRUE
-            -DAKANTU_STRUCTURAL_MECHANICS:BOOL=TRUE
-            -DAKANTU_HEAT_TRANSFER:BOOL=TRUE
-            -DAKANTU_DAMAGE_NON_LOCAL:BOOL=TRUE
-            -DAKANTU_PHASE_FIELD:BOOL=TRUE
-            -DAKANTU_PYTHON_INTERFACE:BOOL=TRUE
-            -DAKANTU_CONTACT_MECHANICS:BOOL=TRUE
-            -DAKANTU_EXAMPLES:BOOL=TRUE
-            -DAKANTU_BUILD_ALL_EXAMPLES:BOOL=TRUE
-            -DAKANTU_TESTS:BOOL=TRUE
-            -DAKANTU_RUN_IN_DOCKER:BOOL=TRUE
-            -DAKANTU_TEST_EXAMPLES:BOOL=${TEST_EXAMPLES}
-            -DCMAKE_BUILD_TYPE:STRING=${BUILD_TYPE} ..
-    
-    - if [ -e compile_commands.json ]; then
-    -   cp compile_commands.json ..
-    - fi
-  artifacts:
-    when: on_success
-    paths:
-      - build
-      - compile_commands.json
-    expire_in: 10h
-
-.build:
-  stage: build
-  script:
-    - cmake --build build/src > >(tee -a build-${output}-out.log) 2> >(tee -a build-${output}-err.log >&2)
-    - cmake --build build/python > >(tee -a build-${output}-out.log) 2> >(tee -a build-${output}-err.log >&2)
-    - cmake --build build/test/ > >(tee -a build-${output}-out.log) 2> >(tee -a build-${output}-err.log >&2)
-    - cmake --build build/examples > >(tee -a build-${output}-out.log) 2> >(tee -a build-${output}-err.log >&2)
-  artifacts:
-    when: on_success
-    paths:
-      - build/
-      - build-${output}-err.log
-      - compile_commands.json
-    exclude:
-      - build/**/*.o
-    expire_in: 10h
-
-.tests:
-  stage: test
-  script:
-    - cd build
-    - ctest -T test --output-on-failure --no-compress-output --timeout 1800
-  after_script:
-    - cd build
-    - tag=$(head -n 1 < Testing/TAG)
-    - if [ -e Testing/${tag}/Test.xml ]; then
-    -   xsltproc -o ./juint.xml ${CI_PROJECT_DIR}/test/ci/ctest2junit.xsl Testing/${tag}/Test.xml;
-    - fi
-    - if [ "${BUILD_TYPE}" = "Coverage" ]; then
-    -   gcovr --xml
-              --gcov-executable "${GCOV_EXECUTABLE}"
-              --output coverage.xml
-              --object-directory ${CI_PROJECT_DIR}/build
-              --root ${CI_PROJECT_DIR}  -s || true
-    - fi
-  artifacts:
-    when: always
-    paths:
-      - build/juint.xml
-      - build/coverage.xml
-    reports:
-      junit:
-        - build/juint.xml
-      cobertura:
-        - build/coverage.xml
 
-# ------------------------------------------------------------------------------
-.cache_build:
-  variables:
-    CCACHE_BASEDIR: ${CI_PROJECT_DIR}/
-    CCACHE_DIR: ${CI_PROJECT_DIR}/.ccache
-    #CCACHE_NOHASHDIR: 1
-    #CCACHE_COMPILERCHECK: content
-  cache:
-    key: ${output}_${BUILD_TYPE}
-    policy: pull-push
-    paths:
-      - .ccache/
-      - third-party/google-test
-      - third-party/pybind11
-  before_script:
-    - ccache --zero-stats || true
-  after_script:
-    - ccache --show-stats || true
-
-# ------------------------------------------------------------------------------
-.image_debian_testing:
-  image: registry.gitlab.com/akantu/akantu/debian:testing
-
-.image_ubuntu_lts:
-  image: registry.gitlab.com/akantu/akantu/ubuntu:lts
-
-# ------------------------------------------------------------------------------
-.compiler_gcc:
+docker build:manylinux:
   variables:
-    CC: /usr/lib/ccache/gcc
-    CXX: /usr/lib/ccache/g++
-    FC: gfortran
-    GCOV_EXECUTABLE: gcov
-
-.compiler_clang:
-  variables:
-    CC: /usr/lib/ccache/clang
-    CXX: /usr/lib/ccache/clang++
-    FC: gfortran
-    GCOV_EXECUTABLE: llvm-cov gcov
-
-.build_coverage:
-  variables:
-    TEST_EXAMPLES: 'FALSE'
-    BUILD_TYPE: 'Coverage'
-
-.build_release:
-  variables:
-    TEST_EXAMPLES: 'TRUE'
-    BUILD_TYPE: 'Release'
-
-.build_valgrind:
-  variables:
-    TEST_EXAMPLES: 'FALSE'
-    BUILD_TYPE: 'Valgrind'
-
-# ------------------------------------------------------------------------------
-.debian_testing_gcc:
-  variables:
-    output: debian_testing_gcc
-  extends:
-    - .compiler_gcc
-    - .image_debian_testing
-    - .cache_build
-
-.debian_testing_clang:
-  variables:
-    output: debian_testing_clang
-  extends:
-    - .compiler_clang
-    - .image_debian_testing
-    - .cache_build
-
-.ubuntu_lts_gcc:
-  variables:
-    output: ubuntu_lts_gcc
-  extends:
-    - .compiler_gcc
-    - .image_ubuntu_lts
-    - .cache_build
+    IMAGE_NAME: manylinux:2010_x86_64
+  extends: .docker_build
 
 # ------------------------------------------------------------------------------
+# Debian testing compiled with GCC
 # ------------------------------------------------------------------------------
 configure:debian_testing_gcc:
   extends:
     - .debian_testing_gcc
     - .build_coverage
     - .configure
 
 build:debian_testing_gcc:
   extends:
     - .debian_testing_gcc
     - .build_coverage
-    - .build
+    - .build_all
   needs:
     - job: configure:debian_testing_gcc
 
+#build_libs:debian_testing_gcc:
+#  extends:
+#    - .debian_testing_gcc
+#    - .build_coverage
+#    - .build_libs
+#  needs:
+#    - job: configure:debian_testing_gcc
+
+#build_tests:debian_testing_gcc:
+#  extends:
+#    - .debian_testing_gcc
+#    - .build_coverage
+#    - .build_tests
+#  needs:
+#    - job: build_libs:debian_testing_gcc
+
 test:debian_testing_gcc:
   extends:
     - .debian_testing_gcc
     - .build_coverage
     - .tests
-  coverage: '/^lines: (\d+\.\d+\%)/'
   needs:
     - job: build:debian_testing_gcc
 
 # ------------------------------------------------------------------------------
-configure:debian_testing_gcc_valgrind:
-  extends:
-    - .debian_testing_gcc
-    - .build_valgrind
-    - .configure
-
-build:debian_testing_gcc_valgrind:
-  extends:
-    - .debian_testing_gcc
-    - .build_valgrind
-    - .build
-  needs:
-    - job: configure:debian_testing_gcc_valgrind
-
-test:debian_testing_gcc_valgrind:
-  extends:
-    - .debian_testing_gcc
-    - .build_valgrind
-    - .tests
-  needs:
-    - job: build:debian_testing_gcc_valgrind
-
+# Debian testing compiled with Clang
 # ------------------------------------------------------------------------------
 configure:debian_testing_clang:
   extends:
     - .debian_testing_clang
     - .build_coverage
     - .configure
 
 build:debian_testing_clang:
   extends:
     - .debian_testing_clang
     - .build_coverage
-    - .build
+    - .build_all
   needs:
     - job: configure:debian_testing_clang
 
+#build_libs:debian_testing_clang:
+#  extends:
+#    - .debian_testing_clang
+#    - .build_coverage
+#    - .build_libs
+#  needs:
+#    - job: configure:debian_testing_clang
+
+#build_tests:debian_testing_clang:
+#  extends:
+#    - .debian_testing_clang
+#    - .build_coverage
+#    - .build_tests
+#  needs:
+#    - job: build_libs:debian_testing_clang
+
 test:debian_testing_clang:
   extends:
     - .debian_testing_clang
     - .build_coverage
     - .tests
   coverage: '/^lines: (\d+\.\d+\%)/'
   needs:
     - job: build:debian_testing_clang
 
+# ------------------------------------------------------------------------------
+# Ubuntu LTS compiled with GCC
 # ------------------------------------------------------------------------------
 configure:ubuntu_lts_gcc:
   extends:
     - .ubuntu_lts_gcc
     - .build_release
     - .configure
 
 build:ubuntu_lts_gcc:
   extends:
     - .ubuntu_lts_gcc
     - .build_release
-    - .build
+    - .build_all
   needs:
     - job: configure:ubuntu_lts_gcc
 
 test:ubuntu_lts_gcc:
   extends:
     - .ubuntu_lts_gcc
     - .build_release
     - .tests
   needs:
     - job: build:ubuntu_lts_gcc
 
 # ------------------------------------------------------------------------------
-cq:code_quality:
-  stage: test
-  image: docker:19.03.12
-  allow_failure: true
-  services:
-    - docker:19.03.12-dind
-  variables:
-    DOCKER_DRIVER: overlay2
-    DOCKER_TLS_CERTDIR: ""
-    CODE_QUALITY_IMAGE: "registry.gitlab.com/gitlab-org/ci-cd/codequality:0.85.24"
-  needs: []
+# Debian testing compiled with GCC tested with valgrind
+# ------------------------------------------------------------------------------
+configure:ubuntu_lts_gcc_valgrind:
+  extends:
+    - .ubuntu_lts_gcc
+    - .build_valgrind
+    - .configure
+
+build:ubuntu_lts_gcc_valgrind:
+  extends:
+    - .ubuntu_lts_gcc
+    - .build_valgrind
+    - .build_all
+  needs:
+    - job: configure:ubuntu_lts_gcc_valgrind
+
+test:ubuntu_lts_gcc_valgrind:
+  extends:
+    - .ubuntu_lts_gcc
+    - .build_valgrind
+    - .tests
+  needs:
+    - job: build:ubuntu_lts_gcc_valgrind
+
+# ------------------------------------------------------------------------------
+# Manylinux to build python packages
+# ------------------------------------------------------------------------------
+configure:python_package:
+  stage: configure
+  extends:
+    - .manylinux_2010_x64_gcc
+    - .build_release
   script:
-    - export SOURCE_CODE=$PWD
-    - |
-      if ! docker info &>/dev/null; then
-        if [ -z "$DOCKER_HOST" -a "$KUBERNETES_PORT" ]; then
-          export DOCKER_HOST='tcp://localhost:2375'
-        fi
-      fi
-    - | # this is required to avoid undesirable reset of Docker image ENV variables being set on build stage
-      function propagate_env_vars() {
-        CURRENT_ENV=$(printenv)
-
-        for VAR_NAME; do
-          echo $CURRENT_ENV | grep "${VAR_NAME}=" > /dev/null && echo "--env $VAR_NAME "
-        done
-      }
-    - docker pull --quiet "$CODE_QUALITY_IMAGE"
-    - |
-      docker run --rm \
-        $(propagate_env_vars \
-          SOURCE_CODE \
-          TIMEOUT_SECONDS \
-          CODECLIMATE_DEBUG \
-          CODECLIMATE_DEV \
-          REPORT_STDOUT \
-          REPORT_FORMAT \
-          ENGINE_MEMORY_LIMIT_BYTES \
-          CODECLIMATE_PREFIX \
-        ) \
-        --volume "$PWD":/code \
-        --volume /var/run/docker.sock:/var/run/docker.sock \
-        "$CODE_QUALITY_IMAGE" /code
+    # create the build folder
+    - cmake -E make_directory build
+    - cd build
+
+    # Variables for cmake
+    - export CMAKE_PREFIX_PATH=/softs/view
+    - export BOOST_ROOT=/softs/view
+
+    # Configure in sequential and without tests or examples
+    - cmake -DAKANTU_COHESIVE_ELEMENT:BOOL=TRUE
+            -DAKANTU_IMPLICIT:BOOL=TRUE
+            -DAKANTU_PARALLEL:BOOL=FALSE
+            -DAKANTU_STRUCTURAL_MECHANICS:BOOL=TRUE
+            -DAKANTU_HEAT_TRANSFER:BOOL=TRUE
+            -DAKANTU_DAMAGE_NON_LOCAL:BOOL=TRUE
+            -DAKANTU_PHASE_FIELD:BOOL=TRUE
+            -DAKANTU_PYTHON_INTERFACE:BOOL=FALSE
+            -DAKANTU_CONTACT_MECHANICS:BOOL=TRUE
+            -DAKANTU_EXAMPLES:BOOL=FALSE
+            -DAKANTU_TESTS:BOOL=FALSE
+            -DMUMPS_DETECT_DEBUG:BOOL=TRUE
+            -DCMAKE_INSTALL_PREFIX:PATH=${CI_PROJECT_DIR}/install
+            -DCMAKE_BUILD_TYPE:STRING=${BUILD_TYPE} ..
   artifacts:
+    when: on_success
     paths:
-      - gl-code-quality-report.json
-    expire_in: 1 week
+      - build/
+    expire_in: 10h
+
+build_akantu:python_package:
+  extends:
+    - .build_libs
+    - .build_release
+    - .manylinux_2010_x64_gcc
+  script:
+  stage: build_libs
+  script:
+    - cmake --build build --target akantu -j1
+    - cmake --install build
+  artifacts:
+    when: on_success
+    paths:
+      - install/
+    expire_in: 10h
   needs:
-    - job: build:debian_testing_clang
-  rules:
-    - if: '$CODE_QUALITY_DISABLED'
-      when: never
-    - if: '$CI_COMMIT_TAG || $CI_COMMIT_BRANCH'
+    - job: configure:python_package
+
+build_pip:python_package:
+  stage: build_tests
+  extends:
+    - .build_release
+    - .manylinux_2010_x64_gcc
+  script:
+    - export CI_AKANTU_INSTALL_PREFIX=${CI_PROJECT_DIR}/install
+    - export CMAKE_PREFIX_PATH=/softs/view:${CI_AKANTU_INSTALL_PREFIX}
+    - test/ci/make-wheels.sh
+  needs:
+    - job: build_akantu:python_package
+  artifacts:
+    when: on_success
+    paths:
+      - wheelhouse
+    expire_in: 10h
 
-.clang_tools:
+test:python_package:
   stage: test
+  image: python:3.8
+  needs:
+    - job: build_pip:python_package
+  script:
+    - pip install akantu -f wheelhouse
+    - python -c "import akantu"
+    - cd examples/python/dynamics/
+    - apt update && apt install -y gmsh
+    - gmsh -2 bar.geo
+    - python ./dynamics.py
+
+package:python_gitlab:
+  stage: deploy
+  image: python:latest
+  script:
+    - pip install twine
+    - TWINE_PASSWORD=${CI_JOB_TOKEN} TWINE_USERNAME=gitlab-ci-token
+          python3 -m twine upload
+            --repository-url https://gitlab.com/api/v4/projects/${CI_PROJECT_ID}/packages/pypi
+            wheelhouse/*
+  needs:
+    - job: build_pip:python_package
+  only:
+    - master
+
+package:python_pypi:
+  stage: deploy
+  image: python:latest
+  script:
+    - pip install twine
+    - TWINE_PASSWORD=${PYPI_TOKEN} TWINE_USERNAME=__token__
+          python3 -m twine upload --verbose wheelhouse/*
+  needs:
+    - job: build_pip:python_package
+  only:
+    - tags
+
+# ------------------------------------------------------------------------------
+# Code Quality
+# ------------------------------------------------------------------------------
+cq:code_quality:
   extends:
-    - .debian_testing_clang
-  before_script:
-    - if [ 'x${CI_MERGE_REQUEST_ID}' != 'x' ]; then
-    -   git fetch origin $CI_MERGE_REQUEST_TARGET_BRANCH_NAME
-    -   git diff --name-only $CI_COMMIT_SHA $CI_MERGE_REQUEST_TARGET_BRANCH_NAME > file_list
-    -   FILE_LIST_ARG='-f file_list'
-    - fi
+    - .code_quality_gitlab_template
   needs:
     - job: build:debian_testing_clang
-  allow_failure: true
-  rules:
-    - if: '$CODE_QUALITY_DISABLED'
-      when: never
-    - if: '$CI_COMMIT_TAG || $CI_COMMIT_BRANCH'
+  artifacts:
+    paths:
+      - gl-code-quality-report.json
 
 cq:clang_tidy:
   extends:
     - .clang_tools
   script:
     - test/ci/scripts/cq
             -x third-party
             -x extra-packages
             -x pybind11
             -x test
             ${FILE_LIST_ARG}
             clang-tidy
             -p ${CI_PROJECT_DIR}/build > gl-clang-tidy-report.json
+  needs:
+    - job: build:debian_testing_clang
   artifacts:
     paths:
       - gl-clang-tidy-report.json
 
 cq:clang_format:
   extends:
     - .clang_tools
   script:
     - test/ci/scripts/cq
             -x third-party
             -x extra-packages
             clang-format
             -p ${CI_PROJECT_DIR}/build > gl-clang-format-report.json
+  needs:
+    - job: build:debian_testing_clang
   artifacts:
     paths:
       - gl-clang-format-report.json
 
 cq:compilation_warnings:
-  stage: test
+  stage: code_quality
   image: python:latest
   script:
     - pip install warning-parser termcolor Click
     - ls build-*-err.log
     - test/ci/scripts/cq
             -x third-party
             -x extra-packages
             warnings
             build-*-err.log > gl-warnings-report.json
   needs:
     - job: build:debian_testing_clang
     - job: build:debian_testing_gcc
     - job: build:ubuntu_lts_gcc
   artifacts:
     paths:
       - gl-warnings-report.json
 
 cq:merge_code_quality:
   stage: deploy
   extends:
     - .debian_testing_clang
   script:
     - jq -Ms '[.[][]]' gl-*-report.json | tee gl-codequality.json | jq -C
   needs:
     - job: cq:code_quality
     - job: cq:clang_tidy
     - job: cq:clang_format
     - job: cq:compilation_warnings
   artifacts:
     paths:
       - gl-codequality.json
   artifacts:
     reports:
       codequality: [gl-codequality.json]
+
+# ------------------------------------------------------------------------------
+# Deploy pages
 # ------------------------------------------------------------------------------
 pages:
   stage: deploy
   extends:
     - .debian_testing_gcc
   script:
     - cd build
     - cmake -DAKANTU_DOCUMENTATION=ON ..
     - cmake --build . -t sphinx-doc
     - mv doc/dev-doc/html ../public
   needs:
     - job: build:debian_testing_gcc
   artifacts:
     paths:
       - public
   only:
     - master
diff --git a/.pypirc b/.pypirc
new file mode 100644
index 000000000..c4a4eb29a
--- /dev/null
+++ b/.pypirc
@@ -0,0 +1,13 @@
+[distutils]
+index-servers =
+    gitlab
+    pypi
+
+[gitlab]
+repository = https://gitlab.com/api/v4/projects/${env.CI_PROJECT_ID}/packages/pypi
+username = gitlab-ci-token
+password = ${env.CI_JOB_TOKEN}
+
+[pypi]
+username = __token__
+password = ${env.pypi_token}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 41770fc4f..7ca64da1a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,202 +1,219 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Jun 14 2010
 # @date last modification: Sat Mar 13 2021
 #
 # @brief  main configuration file
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # 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
 #-------------------------------------------------------------------------------
 #                      _               _
 #                     | |             | |
 #                 __ _| | ____ _ _ __ | |_ _   _
 #                / _` | |/ / _` | '_ \| __| | | |
 #               | (_| |   < (_| | | | | |_| |_| |
 #                \__,_|_|\_\__,_|_| |_|\__|\__,_|
 #
 #===============================================================================
 
 
 #===============================================================================
 # CMake Project
 #===============================================================================
 cmake_minimum_required(VERSION 3.5.1)
 
 # add this options before PROJECT keyword
 set(CMAKE_DISABLE_SOURCE_CHANGES ON)
 set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
 
 if(CMAKE_VERSION VERSION_GREATER 3.12)
   cmake_policy(SET CMP0074 NEW)
 endif()
 
 set(AKANTU_COPYRIGHT "2010-2021, EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)")
 set(AKANTU_MAINTAINER "Nicolas Richart")
 set(AKANTU_HOMEPAGE_URL "https://akantu.ch")
 
 if(CMAKE_VERSION VERSION_GREATER 3.12)
   project(Akantu
     HOMEPAGE_URL "https://akantu.ch")
 else()
   project(Akantu)
 endif()
   
 enable_language(CXX)
 
 #===============================================================================
 # Misc. config for cmake
 #===============================================================================
 set(AKANTU_CMAKE_DIR "${PROJECT_SOURCE_DIR}/cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/Modules")
 
-set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries.")
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL
   "Enable/Disable output of compile commands during generation" FORCE)
 
 mark_as_advanced(BUILD_SHARED_LIBS)
 
 if(NOT AKANTU_TARGETS_EXPORT)
   set(AKANTU_TARGETS_EXPORT AkantuTargets)
 endif()
 
 include(CMakeVersionGenerator)
 include(CMakePackagesSystem)
 include(CMakeFlagsHandling)
 
 include(AkantuPackagesSystem)
 include(AkantuMacros)
 include(AkantuCleaning)
 
 #cmake_activate_debug_message()
 
 include(GNUInstallDirs)
 set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
 # add the automatically determined parts of the RPATH
 # which point to directories outside the build tree to the install RPATH
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 
 #===============================================================================
 # Version Number
 #===============================================================================
 # AKANTU version number.
 define_project_version()
+if(NOT AKANTU_BYPASS_AKANTU_TARGET)
+  configure_file("cmake/akantu_version.py.in"
+    "${PROJECT_BINARY_DIR}/akantu_version.py"
+    @ONLY)
+endif()
 
 #===============================================================================
 # Options
 #===============================================================================
 option(AKANTU_EXAMPLES "Activate examples" OFF)
 option(AKANTU_TESTS "Activate tests" OFF)
+option(AKANTU_SHARED "Build Akantu as a shared library" ON)
+option(AKANTU_POSITION_INDEPENDENT "Build with -fPIC when static" ON)
 
 option(AKANTU_RUN_IN_DOCKER "Set the approriate flage tu run in docker" OFF)
 set(AKANTU_PREFERRED_PYTHON_VERSION 3
   CACHE STRING "Preferred version for python related things")
-mark_as_advanced(AKANTU_PREFERRED_PYTHON_VERSION AKANTU_RUN_IN_DOCKER)
+mark_as_advanced(
+  AKANTU_PREFERRED_PYTHON_VERSION
+  AKANTU_RUN_IN_DOCKER
+  AKANTU_POSITION_INDEPENDENT
+  AKANTU_SHARED
+  )
+
+if (AKANTU_SHARED)
+  set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries.")
+else()
+  set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build shared libraries.")
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
 
 include(AkantuExtraCompilationProfiles)
 #===============================================================================
 # Dependencies
 #===============================================================================
 declare_akantu_types()
 
 package_list_packages(${PROJECT_SOURCE_DIR}/packages
   EXTRA_PACKAGES_FOLDER ${PROJECT_SOURCE_DIR}/extra_packages
   NO_AUTO_COMPILE_FLAGS)
 
-## meta option \todo better way to do it when multiple package give enable the
-## same feature
-if(AKANTU_SCOTCH)
-  set(AKANTU_PARTITIONER ON)
-else()
-  set(AKANTU_PARTITIONER OFF)
-endif()
-
-if(AKANTU_MUMPS)
-  set(AKANTU_SOLVER ON)
-else()
-  set(AKANTU_SOLVER OFF)
-endif()
-
 #===============================================================================
 # Akantu library
 #===============================================================================
-add_subdirectory(src)
+if (NOT AKANTU_BYPASS_AKANTU_TARGET)
+  add_subdirectory(src)
+else()
+  find_package(Akantu REQUIRED)
+  if (Akantu_FOUND)
+    get_target_property(_lib akantu INTERFACE_LINK_LIBRARIES)
+    message(STATUS "Found Akantu: ${_lib} (found version ${AKANTU_VERSION})")
+  endif()
+endif()
 
 #===============================================================================
 # Documentation
 #===============================================================================
 if(AKANTU_DOCUMENTATION OR AKANTU_DOCUMENTATION_MANUAL)
   add_subdirectory(doc)
 else()
   set(AKANTU_DOC_EXCLUDE_FILES "${PROJECT_SOURCE_DIR}/doc/manual" CACHE INTERNAL "")
 endif()
 
 #===============================================================================
 # Python interface
 #===============================================================================
 package_is_activated(python_interface _python_act)
 if(_python_act)
+  include(AkantuNeedPybind11)
   if(IS_ABSOLUTE "${CMAKE_INSTALL_PREFIX}")
     set(AKANTU_PYTHON_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
   else()
     set(AKANTU_PYTHON_INSTALL_PREFIX "${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_PREFIX}")
   endif()
   add_subdirectory(python)
 endif()
 
 #===============================================================================
 # Examples and tests
 #===============================================================================
 include(AkantuTestsMacros)
 include(AkantuExampleMacros)
 
 if(AKANTU_TESTS)
+  include(AkantuNeedPybind11)
   option(AKANTU_BUILD_ALL_TESTS "Build all tests" ON)
   find_package(GMSH REQUIRED)
 endif()
 
 # tests
 add_test_tree(test)
 
 if(AKANTU_EXAMPLES)
   if(AKANTU_TESTS)
     option(AKANTU_TEST_EXAMPLES "Run the examples" ON)
   endif()
   find_package(GMSH REQUIRED)
   add_subdirectory(examples)
 endif()
 
 #===============================================================================
 # Install and Packaging
 #===============================================================================
-include(AkantuInstall)
+if (NOT AKANTU_BYPASS_AKANTU_TARGET)
+  include(AkantuInstall)
 
-option(AKANTU_DISABLE_CPACK
-  "This option commands the generation of extra info for the \"make package\" target" ON)
-mark_as_advanced(AKANTU_DISABLE_CPACK)
-if(NOT AKANTU_DISABLE_CPACK)
-  include(AkantuCPack)
+  option(AKANTU_DISABLE_CPACK
+    "This option commands the generation of extra info for the \"make package\" target" ON)
+  mark_as_advanced(AKANTU_DISABLE_CPACK)
+  if(NOT AKANTU_DISABLE_CPACK)
+    include(AkantuCPack)
+  endif()
 endif()
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 000000000..62a73ee6e
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,11 @@
+graft src
+graft examples
+graft test
+graft cmake
+graft doc
+graft third-party/akantu_iterators
+graft third-party/iohelper
+graft third-party/cmake
+recursive-include python *.txt *.cc *.hh
+
+include CMakeLists.txt COPYING COPYING.lesser versioneer.py README.md
diff --git a/README b/README
deleted file mode 100644
index 11931061e..000000000
--- a/README
+++ /dev/null
@@ -1,26 +0,0 @@
-==================================================
-               _               _
-              | |             | |
-          __ _| | ____ _ _ __ | |_ _   _
-         / _` | |/ / _` | '_ \| __| | | |
-        | (_| |   < (_| | | | | |_| |_| |
-         \__,_|_|\_\__,_|_| |_|\__|\__,_|
-
-==================================================
-__________
-COMPILATION
-
-There are two ways to compile Akantu.
-
-1. You can compile it directly using cmake
-
- > mkdir build
- > cd build
- > ccmake ..
- > make
-
-________
-CONTACTS
-
- If you need some help to use Akantu you can contact use akantu@akantu.ch
-
diff --git a/README.md b/README.md
new file mode 100644
index 000000000..8c78c41fc
--- /dev/null
+++ b/README.md
@@ -0,0 +1,93 @@
+# `Akantu`: Swiss-Made Open-Source Finite-Element Library
+
+`Akantu` means a little element in Kinyarwanda, a Bantu language. From now on it
+is also an open- source object-oriented library which has the ambi- tion to be
+generic and efficient.
+
+# Building `Akantu`
+
+## Dependencies
+
+In order to compile `Akantu`  any compiler supporting fully C++14 should work.
+In addition some libraries are required:
+
+ - CMake (>= 3.5.1)
+ - Boost (preprocessor and Spirit)
+ - zlib
+ - blas/lapack
+
+For the python interface:
+
+ - Python (>=3 is recommended)
+ - pybind11 (if not present the build system will try to download it)
+
+To run parallel simulations:
+
+ - MPI
+ - Scotch
+
+To use the static or implicit dynamic solvers at least one of the following libraries is needed:
+
+ - MUMPS (since this is usually compiled in static you also need MUMPS dependencies)
+ - PETSc
+
+To compile the tests and examples:
+
+ - Gmsh
+ - google-test (if not present the build system will try to download it)
+
+### On `.deb` based systems
+
+``` sh
+> sudo apt install cmake libboost-dev libzlib-dev liblapack3 gmsh
+# For parallel
+> sudo apt install mpi-default-dev libmumps-dev 
+# For sequential
+> sudo apt install libmumps-seq-dev 
+```
+
+## Configuring and compilation
+
+
+`Akantu` is a [CMake](https://cmake.org/) project, so to configure it, you can follow the usual way:
+
+``` sh
+  > cd akantu
+  > mkdir build
+  > cd build
+  > ccmake ..
+  [ Set the options that you need ]
+  > make
+  > make install
+```
+
+## Using the python interface
+
+
+You can install ``Akantu`` using pip:
+
+``` sh
+  > pip install akantu
+```
+
+You can then import the package in a python script as:
+
+``` python
+  import akantu
+```
+
+The python API is similar to the C++ one. If you
+encounter any problem with the python interface, you are welcome to do a merge
+request or post an issue on [GitLab](https://gitlab.com/akantu/akantu/-/issues).
+  
+# Tutorials with the python interface
+
+To help getting started, multiple tutorials using the python interface are
+available as notebooks with pre-installed version of `Akantu` on Binder. The
+following tutorials are currently available:
+
+[Plate whith a hole loaded](https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.com%2Fakantu%2Ftutorials.git/HEAD?filepath=plate-hole/plate-hole.ipynb)
+
+[Loaded cohesive crack](https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.com%2Fakantu%2Ftutorials.git/HEAD?filepath=cohesive-fracture/cohesive-fracture.ipynb)
+
+[Making your constitutive law in python](https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.com%2Fakantu%2Ftutorials.git/HEAD?filepath=constitutive-laws/python_constitutive_law.ipynb)
diff --git a/VERSION b/VERSION
index fd2a01863..fcdb2e109 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-3.1.0
+4.0.0
diff --git a/cmake/AkantuConfig.cmake.in b/cmake/AkantuConfig.cmake.in
index 866b1567f..99d9212f5 100644
--- a/cmake/AkantuConfig.cmake.in
+++ b/cmake/AkantuConfig.cmake.in
@@ -1,68 +1,69 @@
 #===============================================================================
 # @file   AkantuConfig.cmake.in
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Thu Dec 01 2011
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  CMake file for the library
 #
 # @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/>.
 #
 #===============================================================================
+set(AKANTU_VERSION @AKANTU_SEMVER@)
+
 @PACKAGE_INIT@
 
 # Compute paths
 get_filename_component(AKANTU_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
 
 set(AKANTU_USE_FILE "${AKANTU_CMAKE_DIR}/AkantuUse.cmake")
 include(${AKANTU_USE_FILE})
 
 if(EXISTS "${AKANTU_CMAKE_DIR}/CMakeCache.txt")
   # In build tree
   include("${AKANTU_CMAKE_DIR}/AkantuBuildTreeSettings.cmake")
   include(AkantuSimulationMacros)
 else()
   # In install tree
   set(AKANTU_INCLUDE_DIRS "@CMAKE_INSTALL_PREFIX@/include/akantu")
   set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${AKANTU_CMAKE_DIR}")
   include(AkantuSimulationMacros)
 endif()
 
+# Akantu exported targets
 include("${AKANTU_CMAKE_DIR}/AkantuTargets.cmake")
 
 # Dependencies
 include("${AKANTU_CMAKE_DIR}/AkantuConfigInclude.cmake")
 
 set(AKANTU_BUILD_TYPE @CMAKE_BUILD_TYPE@)
 
 # find_akantu_dependencies()
 set(AKANTU_LIBRARY akantu)
 
 set(_akantu_libraries ${AKANTU_LIBRARIES})
 list(APPEND _akantu_libraries ${AKANTU_LIBRARY} ${AKANTU_EXTRA_LIBRARIES})
 list(APPEND AKANTU_INCLUDE_DIRS ${AKANTU_EXTRA_INCLUDE_DIR})
 
 set(AKANTU_LIBRARIES ${_akantu_libraries} CACHE INTERNAL "List of akantu necessary libraries" FORCE)
 
-# set(AKANTU_VERSION @AKANTU_VERSION@)
-# set_and_check(AKANTU_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
 check_required_components(Akantu)
diff --git a/cmake/AkantuExtraCompilationProfiles.cmake b/cmake/AkantuExtraCompilationProfiles.cmake
index 80d648a6b..d25cb5976 100644
--- a/cmake/AkantuExtraCompilationProfiles.cmake
+++ b/cmake/AkantuExtraCompilationProfiles.cmake
@@ -1,119 +1,119 @@
 #===============================================================================
 # @file   AkantuExtraCompilationProfiles.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Dec 02 2016
 # @date last modification: Wed Feb 03 2021
 #
 # @brief  Compilation profiles
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 option (FORCE_COLORED_OUTPUT "Always produce ANSI-colored output (GNU/Clang only)." FALSE)
 mark_as_advanced(FORCE_COLORED_OUTPUT)
 if(FORCE_COLORED_OUTPUT)
   if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     add_flags(cxx "-fcolor-diagnostics")
   else()
     add_flags(cxx "-fdiagnostics-color=always")
   endif()
 endif()
 
 
 
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -DAKANTU_NDEBUG"
   CACHE STRING "Flags used by the compiler during release builds" FORCE)
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_INIT} -ggdb3"
     CACHE STRING "Flags used by the compiler during debug builds" FORCE)
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT} -ggdb3"
     CACHE STRING "Flags used by the compiler during debug builds" FORCE)
 endif()
 
 function(declare_compilation_profile name)
   include(CMakeParseArguments)
 
   cmake_parse_arguments(_args
     "" "COMPILER;LINKER;DOC" "" ${ARGN})
 
   string(TOUPPER "${name}" _u_name)
 
   if(NOT _args_DOC)
     string(TOLOWER "${name}" _args_DOC)
   endif()
 
   if(NOT _args_COMPILER)
     message(FATAL_ERROR "declare_compilation_profile: you should at least give COMPILER flags")
   endif()
 
   if(NOT _args_LINKER)
     set(_args_LINKER ${_args_COMPILER})
   endif()
 
   foreach(_flag CXX C Fortran SHARED_LINKER EXE_LINKER)
     set(_stage "compiler")
     set(_flags ${_args_COMPILER})
     if(_stage MATCHES ".*LINKER")
       set(_stage "linker")
       set(_flags ${_args_LINKER})
     endif()
     set(CMAKE_${_flag}_FLAGS_${_u_name} ${_flags}
       CACHE STRING "Flags used by the ${_stage} during coverage builds" FORCE)
     mark_as_advanced(CMAKE_${_flag}_FLAGS_${_u_name})
   endforeach()
 endfunction()
 
 
 # Profiling
 declare_compilation_profile(PROFILING
   COMPILER "-g -ggdb3 -pg -DNDEBUG -DAKANTU_NDEBUG -O3")
 
 # Valgrind
 declare_compilation_profile(VALGRIND
-  COMPILER "-g -ggdb3 -DNDEBUG -DAKANTU_NDEBUG -O3")
+  COMPILER "-g -ggdb3 -O3")
 
 # Coverage
 declare_compilation_profile(COVERAGE
   COMPILER "-g -ggdb3 -DNDEBUG -DAKANTU_NDEBUG -O2 --coverage")
 
 # Sanitize the code
 if ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "5.2") OR
     CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 
   if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     set(_blacklist " -fsanitize-blacklist=${PROJECT_SOURCE_DIR}/cmake/sanitize-blacklist.txt")
   endif()
 
   declare_compilation_profile(SANITIZE
     COMPILER "-g -ggdb3 -O2 -fsanitize=address -fsanitize=leak -fsanitize=undefined -fno-omit-frame-pointer${_blacklist}")
 endif()
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   declare_compilation_profile(SANITIZEMEMORY
     COMPILER "-g -ggdb3 -O2 -fPIE -fsanitize=memory -fsanitize-memory-track-origins -fsanitize-recover=all -fno-omit-frame-pointer -fsanitize-blacklist=${PROJECT_SOURCE_DIR}/cmake/sanitize-blacklist.txt"
     DOC "\"sanitize memory\"")
 endif()
 
 if (CMAKE_BUILD_TYPE MATCHES "[Vv][Aa][Ll][Gg][Rr][Ii][Nn][Dd]")
   find_program(VALGRIND_EXECUTABLE valgrind)
 endif()
diff --git a/cmake/AkantuInstall.cmake b/cmake/AkantuInstall.cmake
index afd8e5159..796331f6f 100644
--- a/cmake/AkantuInstall.cmake
+++ b/cmake/AkantuInstall.cmake
@@ -1,164 +1,164 @@
 #===============================================================================
 # @file   AkantuInstall.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Wed Oct 17 2012
 # @date last modification: Fri Jan 15 2021
 #
 # @brief  Create the files that allows users to link with Akantu in an other
 # cmake project
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 #===============================================================================
 # Config gen for external packages
 #===============================================================================
 configure_file(cmake/AkantuBuildTreeSettings.cmake.in
   "${PROJECT_BINARY_DIR}/AkantuBuildTreeSettings.cmake" @ONLY)
 
 file(WRITE "${PROJECT_BINARY_DIR}/AkantuConfigInclude.cmake" "
 #===============================================================================
 # @file   AkantuConfigInclude.cmake
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 # @date   Fri Jun 11 09:46:59 2010
 #
 # @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/>.
 #
 # @section DESCRIPTION
 #
 #===============================================================================
 
 ")
 
 package_get_all_packages(_package_list)
 
 foreach(_pkg_name ${_package_list})
   #  package_pkg_name(${_option} _pkg_name)
   _package_is_activated(${_pkg_name} _acctivated)
   _package_get_real_name(${_pkg_name} _real_name)
 
   string(TOUPPER ${_real_name} _real_pkg_name)
 
   file(APPEND "${PROJECT_BINARY_DIR}/AkantuConfigInclude.cmake" "
 set(AKANTU_HAS_${_real_pkg_name} ${_acctivated})")
 
   _package_get_libraries(${_pkg_name} _libs)
   if(_libs)
     file(APPEND "${PROJECT_BINARY_DIR}/AkantuConfigInclude.cmake" "
 set(AKANTU_${_real_pkg_name}_LIBRARIES ${_libs})")
   endif()
 
   _package_get_include_dir(${_pkg_name} _incs)
   if(_incs)
     file(APPEND "${PROJECT_BINARY_DIR}/AkantuConfigInclude.cmake" "
 set(AKANTU_${_real_pkg_name}_INCLUDE_DIR ${_incs})
 ")
   endif()
 
   _package_get_compile_flags(${_pkg_name} CXX _compile_flags)
   if(_compile_flags)
     file(APPEND "${PROJECT_BINARY_DIR}/AkantuConfigInclude.cmake" "
 set(AKANTU_${_real_pkg_name}_COMPILE_CXX_FLAGS ${_compile_flags})
 ")
   endif()
 endforeach()
 
 file(APPEND "${PROJECT_BINARY_DIR}/AkantuConfigInclude.cmake" "
 set(AKANTU_EXTRA_CXX_FLAGS \"${AKANTU_EXTRA_CXX_FLAGS}\")
 ")
 
 
 # Create the AkantuConfig.cmake and AkantuConfigVersion files
 get_filename_component(CONF_REL_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}" ABSOLUTE)
 configure_file(cmake/AkantuConfig.cmake.in "${PROJECT_BINARY_DIR}/AkantuConfig.cmake" @ONLY)
-configure_file(cmake/AkantuConfigVersion.cmake.in "${PROJECT_BINARY_DIR}/AkantuConfigVersion.cmake" @ONLY)
+#configure_file(cmake/AkantuConfigVersion.cmake.in "${PROJECT_BINARY_DIR}/AkantuConfigVersion.cmake" @ONLY)
 configure_file(cmake/AkantuUse.cmake "${PROJECT_BINARY_DIR}/AkantuUse.cmake" COPYONLY)
 
 package_is_activated(pybind11 _is_pybind11_activated)
 package_is_activated(swig _is_swig_activated)
 
 configure_file(cmake/akantu_environement.sh.in
   ${PROJECT_BINARY_DIR}/akantu_environement.sh  @ONLY)
 configure_file(cmake/akantu_environement.csh.in
   ${PROJECT_BINARY_DIR}/akantu_environement.csh @ONLY)
 
 include(GNUInstallDirs)
-package_is_activated(python_interface _is_acticated)
-if(_is_acticated)
+package_is_activated(python_interface _is_activated)
+if(_is_activated)
   find_package(PythonInterp ${AKANTU_PREFERRED_PYTHON_VERSION})
   configure_file(cmake/akantu_install_environement.sh.in
     ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/akantu_environement.sh  @ONLY)
   configure_file(cmake/akantu_install_environement.csh.in
     ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/akantu_environement.csh @ONLY)
 
   install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/akantu_environement.sh
     ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/akantu_environement.csh
     DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/akantu${AKANTU_VERSION})
 endif()
 
 include(CMakePackageConfigHelpers)
 
 configure_package_config_file(cmake/AkantuConfig.cmake.in
   "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
-  INSTALL_DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/${PROJECT_NAME}
+  INSTALL_DESTINATION lib/cmake/${PROJECT_NAME}
   )
 
 write_basic_package_version_file(${PROJECT_BINARY_DIR}/AkantuConfigVersion.cmake
   VERSION ${AKANTU_VERSION}
   COMPATIBILITY SameMajorVersion)
 
 # Install the export set for use with the install-tree
 install(FILES
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindScaLAPACK.cmake
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindMETIS.cmake
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindParMETIS.cmake
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindPETSc.cmake
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindMumps.cmake
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindScotch.cmake
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindGMSH.cmake
   ${PROJECT_BINARY_DIR}/AkantuConfig.cmake
   ${PROJECT_BINARY_DIR}/AkantuConfigInclude.cmake
   ${PROJECT_BINARY_DIR}/AkantuConfigVersion.cmake
   ${PROJECT_SOURCE_DIR}/cmake/AkantuUse.cmake
   ${PROJECT_SOURCE_DIR}/cmake/AkantuSimulationMacros.cmake
   ${PROJECT_SOURCE_DIR}/cmake/Modules/FindGMSH.cmake
-  DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/${PROJECT_NAME}
+  DESTINATION lib/cmake/${PROJECT_NAME}
   COMPONENT dev)
diff --git a/cmake/AkantuNeedPybind11.cmake b/cmake/AkantuNeedPybind11.cmake
new file mode 100644
index 000000000..e23bb6d94
--- /dev/null
+++ b/cmake/AkantuNeedPybind11.cmake
@@ -0,0 +1,16 @@
+if(DEFINED AKANTU_NEED_PYBIND11_LOADED)
+  return()
+endif()
+set(AKANTU_NEED_PYBIND11_LOADED TRUE)
+
+
+set(PYBIND11_PYTHON_VERSION ${AKANTU_PREFERRED_PYTHON_VERSION} CACHE INTERNAL "")
+
+find_package(pybind11 QUIET)
+
+if (NOT pybind11_FOUND)
+  set(PYBIND11_VERSION "v2.4.2")
+  set(PYBIND11_GIT "https://github.com/pybind/pybind11.git")
+
+  include(${PROJECT_SOURCE_DIR}/third-party/cmake/pybind11.cmake)
+endif()
diff --git a/cmake/AkantuTestsMacros.cmake b/cmake/AkantuTestsMacros.cmake
index 319e10f97..19e4134c9 100644
--- a/cmake/AkantuTestsMacros.cmake
+++ b/cmake/AkantuTestsMacros.cmake
@@ -1,657 +1,656 @@
 #===============================================================================
 # @file   AkantuTestsMacros.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Sep 03 2010
 # @date last modification: Tue Jun 30 2020
 #
 # @brief  macros for tests
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # 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:
 AkantuTestsMacros
 -----------------
 
 This modules provides the functions to helper to declare tests and folders
 containing tests in akantu
 
 .. command:: add_test_tree
 
 add_test_tree(<test_direcotry>)
 
 ``<test_directory>`` is the entry direcroty of the full structure of
 subfolders containing tests
 
 .. command:: add_akantu_test
 
 add_akantu_test(<dir> <desc>)
 
 This function add a subdirectory ``<dir>`` of tests that will be conditionnaly
 activable and will be visible only if the parent folder as been activated An
 option ``AKANTU_BUILD_TEST_<dir>`` will appear in ccmake with the description
 ``<desc>``. The compilation of all tests can be forced with the option
 ``AKANTU_BUILD_ALL_TESTS``
 
 .. command:: register_test
 
 register_test(<test_name>
   SOURCES <sources>...
   PACKAGE <akantu_packages>...
   SCRIPT <scirpt>
   [FILES_TO_COPY <filenames>...]
   [DEPENDS <targets>...]
   [DIRECTORIES_TO_CREATE <directories>...]
   [COMPILE_OPTIONS <flags>...]
   [EXTRA_FILES <filnames>...]
   [LINK_LIBRARIES <libraries>...]
   [INCLUDE_DIRECTORIES <include>...]
   [UNSABLE]
   [PARALLEL]
   [PARALLEL_LEVEL <procs>...]
   )
 
 This function defines a test ``<test_name>_run`` this test could be of
 different nature depending on the context. If Just sources are provided the
 test consist of running the executable generated. If a file ``<test_name>.sh``
 is present the test will execute the script. And if a ``<test_name>.verified``
 exists the output of the test will be compared to this reference file
 
 The options are:
 
 ``SOURCES <sources>...``
 The list of source files to compile to generate the executable of the test
 
 ``PACKAGE <akantu_packages>...``
 The list of package to which this test belongs. The test will be activable
 only of all the packages listed are activated
 
 ``SCRIPT <script>``
 The script to execute instead of the executable
 
 ``FILES_TO_COPY <filenames>...``
 List of files to copy from the source directory to the build directory
 
 ``DEPENDS <targets>...``
 List of targets the test depends on, for example if a mesh as to be generated
 
 ``DIRECTORIES_TO_CREATE <directories>...``
 Obsolete. This specifies a list of directories that have to be created in
 the build folder
 
 ``COMPILE_OPTIONS <flags>...``
 List of extra compilations options to pass to the compiler
 
 ``EXTRA_FILES <filnames>...``
 Files to consider when generating a package_source
 
 ``UNSABLE``
 If this option is specified the test can be unacitivated by the glocal option
 ``AKANTU_BUILD_UNSTABLE_TESTS``, this is mainly intendeed to remove test
 under developement from the continious integration
 
 ``PARALLEL``
 This specifies that this test should be run in parallel. It will generate a
 series of test for different number of processors. This automaticaly adds a
 dependency to the package ``AKANTU_PARALLEL``
 
 ``PARALLEL_LEVEL``
 This defines the different processor numbers to use, if not defined the
 macro tries to determine it in a "clever" way
 
 ]=======================================================================]
 
 set(AKANTU_DRIVER_SCRIPT ${AKANTU_CMAKE_DIR}/akantu_test_driver.sh)
 
 # ==============================================================================
 macro(add_test_tree dir)
   if(AKANTU_TESTS)
     enable_testing()
     include(CTest)
     mark_as_advanced(BUILD_TESTING)
 
     set(_akantu_current_parent_test ${dir} CACHE INTERNAL "Current test folder" FORCE)
     set(_akantu_${dir}_tests_count 0 CACHE INTERNAL "" FORCE)
 
     string(TOUPPER ${dir} _u_dir)
     set(AKANTU_BUILD_${_u_dir} ON CACHE INTERNAL "${desc}" FORCE)
 
     package_get_all_test_folders(_test_dirs)
 
     foreach(_dir ${_test_dirs})
       add_subdirectory(${_dir})
     endforeach()
   endif()
 endmacro()
 
 
 set(_test_flags
   UNSTABLE
   PARALLEL
   PYTHON
   GTEST
   HEADER_ONLY
   )
 
 set(_test_one_variables
   POSTPROCESS
   SCRIPT
   )
 
 set(_test_multi_variables
   SOURCES
   FILES_TO_COPY
   DEPENDS
   DIRECTORIES_TO_CREATE
   COMPILE_OPTIONS
   EXTRA_FILES
   LINK_LIBRARIES
   INCLUDE_DIRECTORIES
   PACKAGE
   PARALLEL_LEVEL
   )
 
 
 # ==============================================================================
 function(add_akantu_test dir desc)
   if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${dir})
     return()
   endif()
 
   set(_my_parent_dir ${_akantu_current_parent_test})
 
   # initialize variables
   set(_akantu_current_parent_test ${dir} CACHE INTERNAL "Current test folder" FORCE)
   set(_akantu_${dir}_tests_count 0 CACHE INTERNAL "" FORCE)
 
   # set the option for this directory
   string(TOUPPER ${dir} _u_dir)
   option(AKANTU_BUILD_${_u_dir} "${desc}")
   mark_as_advanced(AKANTU_BUILD_${_u_dir})
 
   # add the sub-directory
   add_subdirectory(${dir})
 
   # if no test can be activated make the option disappear
   set(_force_deactivate_count FALSE)
   if(${_akantu_${dir}_tests_count} EQUAL 0)
     set(_force_deactivate_count TRUE)
   endif()
 
   # if parent off make the option disappear
   set(_force_deactivate_parent FALSE)
   string(TOUPPER ${_my_parent_dir} _u_parent_dir)
   if(NOT AKANTU_BUILD_${_u_parent_dir})
     set(_force_deactivate_parent TRUE)
   endif()
 
   if(_force_deactivate_parent OR _force_deactivate_count OR AKANTU_BUILD_ALL_TESTS)
     if(NOT DEFINED _AKANTU_BUILD_${_u_dir}_SAVE)
       set(_AKANTU_BUILD_${_u_dir}_SAVE ${AKANTU_BUILD_${_u_dir}} CACHE INTERNAL "" FORCE)
     endif()
     unset(AKANTU_BUILD_${_u_dir} CACHE)
     if(AKANTU_BUILD_ALL_TESTS AND NOT _force_deactivate_count)
       set(AKANTU_BUILD_${_u_dir} ON CACHE INTERNAL "${desc}" FORCE)
     else()
       set(AKANTU_BUILD_${_u_dir} OFF CACHE INTERNAL "${desc}" FORCE)
     endif()
   else()
     if(DEFINED _AKANTU_BUILD_${_u_dir}_SAVE)
       unset(AKANTU_BUILD_${_u_dir} CACHE)
       set(AKANTU_BUILD_${_u_dir} ${_AKANTU_BUILD_${_u_dir}_SAVE} CACHE BOOL "${desc}")
       unset(_AKANTU_BUILD_${_u_dir}_SAVE CACHE)
     endif()
   endif()
 
   # adding up to the parent count
   math(EXPR _tmp_parent_count "${_akantu_${dir}_tests_count} + ${_akantu_${_my_parent_dir}_tests_count}")
   set(_akantu_${_my_parent_dir}_tests_count ${_tmp_parent_count} CACHE INTERNAL "" FORCE)
 
   # restoring the parent current dir
   set(_akantu_current_parent_test ${_my_parent_dir} CACHE INTERNAL "Current test folder" FORCE)
 endfunction()
 
 function(is_test_active is_active)
   cmake_parse_arguments(_register_test
     "${_test_flags}"
     "${_test_one_variables}"
     "${_test_multi_variables}"
     ${ARGN}
     )
 
   if(NOT _register_test_PACKAGE)
     message(FATAL_ERROR "No reference package was defined for the test"
       " ${test_name} in folder ${CMAKE_CURRENT_SOURCE_DIR}")
   endif()
 
   if(_register_test_PYTHON)
     list(APPEND _register_test_PACKAGE python_interface)
   endif()
 
   set(_test_act TRUE)
   # Activate the test anly if all packages associated to the test are activated
   foreach(_package ${_register_test_PACKAGE})
     package_is_activated(${_package} _act)
     if(NOT _act)
       set(_test_act FALSE)
     endif()
   endforeach()
 
   # check if the test is marked unstable and if the unstable test should be run
   if(_register_test_UNSTABLE AND NOT AKANTU_BUILD_UNSTABLE_TESTS)
     set(_test_act FALSE)
   endif()
 
   if(_test_act)
     # todo this should be checked for the build package_sources since the file will not be listed.
     math(EXPR _tmp_parent_count "${_akantu_${_akantu_current_parent_test}_tests_count} + 1")
     set(_akantu_${_akantu_current_parent_test}_tests_count ${_tmp_parent_count} CACHE INTERNAL "" FORCE)
   endif()
 
   string(TOUPPER ${_akantu_current_parent_test} _u_parent)
   if(NOT (AKANTU_BUILD_${_u_parent} OR AKANTU_BUILD_ALL_TESTS))
     set(_test_act FALSE)
   endif()
 
   set(${is_active} ${_test_act} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 function(register_gtest_sources)
   cmake_parse_arguments(_register_test
     "${_test_flags}"
     "${_test_one_variables}"
     "${_test_multi_variables}"
     ${ARGN}
     )
 
   is_test_active(_is_active ${ARGN})
   register_test_files_to_package(${ARGN})
 
   if(NOT _is_active)
     return()
   endif()
 
   if(_register_test_PACKAGE)
     set(_list ${_gtest_PACKAGE})
     list(APPEND _list ${_register_test_PACKAGE})
     list(REMOVE_DUPLICATES _list)
     set(_gtest_PACKAGE ${_list} PARENT_SCOPE)
   endif()
 
   foreach (_var ${_test_flags})
     if(_var STREQUAL "HEADER_ONLY")
       if(NOT DEFINED_register_test_${_var})
         set(_gtest_${_var} OFF PARENT_SCOPE)
       elseif(NOT DEFINED _gtest_${_var})
         set(_gtest_${_var} ON PARENT_SCOPE)
       endif()
       continue()
     endif()
 
     if(_register_test_${_var})
       set(_gtest_${_var} ON PARENT_SCOPE)
     else()
       if(_gtest_${_var})
         message("Another gtest file required ${_var} to be ON it will be globally set for this folder...")
       endif()
     endif()
   endforeach()
 
   if(_register_test_UNPARSED_ARGUMENTS)
     list(APPEND _register_test_SOURCES ${_register_test_UNPARSED_ARGUMENTS})
   endif()
 
   foreach (_var ${_test_multi_variables})
     if(_register_test_${_var})
       set(_list ${_gtest_${_var}})
       list(APPEND _list ${_register_test_${_var}})
       list(REMOVE_DUPLICATES _list)
       set(_gtest_${_var} ${_list} PARENT_SCOPE)
     endif()
   endforeach()
 endfunction()
 
 # ==============================================================================
 function(akantu_pybind11_add_module target)
-  package_is_activated(pybind11 _pybind11_act)
-  if(_pybind11_act)
+  if(pybind11_FOUND)
     package_get_all_external_informations(
       INTERFACE_INCLUDE AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR
       )
 
     pybind11_add_module(${target} ${ARGN})
     target_link_libraries(${target} PRIVATE akantu)
     target_include_directories(${target} SYSTEM PRIVATE ${PYBIND11_INCLUDE_DIR} ${PROJECT_SOURCE_DIR}/python)
     set_property(TARGET ${target} PROPERTY DEBUG_POSTFIX "")
   endif()
 endfunction()
 
 # ==============================================================================
 function(register_gtest_test test_name)
   if(NOT _gtest_PACKAGE)
     return()
   endif()
 
   set(_argn ${test_name}_gtest)
 
   set(_link_libraries GTest::GTest GTest::Main)
 
   list(FIND _gtest_PACKAGE python_interface _pos)
   package_is_activated(python_interface _python_interface_act)
 
   if(_python_interface_act AND (NOT _pos EQUAL -1))
     list(APPEND _link_libraries pybind11::embed)
     set(_compile_flags COMPILE_OPTIONS "AKANTU_TEST_USE_PYBIND11")
   endif()
 
   is_test_active(_is_active ${ARGN} PACKAGE ${_gtest_PACKAGE})
   if(NOT _is_active)
     return()
   endif()
 
   register_gtest_sources(${ARGN}
     SOURCES ${PROJECT_SOURCE_DIR}/test/test_gtest_main.cc
     LINK_LIBRARIES ${_link_libraries}
     PACKAGE ${_gtest_PACKAGE}
     ${_compile_flags}
     )
 
   foreach (_var ${_test_flags})
     if(_gtest_${_var})
       list(APPEND _argn ${_var})
       unset(_gtest_${_var})
     endif()
   endforeach()
 
   foreach (_var ${_test_multi_variables})
     if(_gtest_${_var})
       list(APPEND _argn ${_var} ${_gtest_${_var}})
       unset(_gtest_${_var})
     endif()
   endforeach()
 
   register_test(${_argn} GTEST)
   target_include_directories(${test_name}_gtest PRIVATE ${PROJECT_SOURCE_DIR}/test)
 endfunction()
 
 # ==============================================================================
 function(register_test test_name)
   cmake_parse_arguments(_register_test
     "${_test_flags}"
     "${_test_one_variables}"
     "${_test_multi_variables}"
     ${ARGN}
     )
 
   register_test_files_to_package(${ARGN})
   is_test_active(_test_act ${ARGN})
   if(NOT _test_act)
     return()
   endif()
 
   set(_extra_args)
 
   # check that the sources are files that need to be compiled
   if(_register_test_SOURCES} OR _register_test_UNPARSED_ARGUMENTS)
     set(_need_to_compile TRUE)
   else()
     set(_need_to_compile FALSE)
   endif()
 
   set(_compile_source)
   foreach(_file ${_register_test_SOURCES} ${_register_test_UNPARSED_ARGUMENTS})
     if(_file MATCHES "\\.cc$" OR _file MATCHES "\\.hh$")
       list(APPEND _compile_source ${_file})
     endif()
   endforeach()
 
   if(_compile_source)
     # get the include directories for sources in activated directories
     package_get_all_include_directories(
       AKANTU_LIBRARY_INCLUDE_DIRS
       )
 
     # get the external packages compilation and linking informations
     package_get_all_external_informations(
       INTERFACE_INCLUDE AKANTU_EXTERNAL_INCLUDE_DIR
       )
 
     foreach(_pkg ${_register_test_PACKAGE})
       package_get_nature(${_pkg} _nature)
       if(_nature MATCHES "^external.*")
         package_get_include_dir(${_pkg} _incl)
         package_get_libraries(${_pkg} _libs)
 
         list(APPEND _register_test_INCLUDE_DIRECTORIES ${_incl})
         list(APPEND _register_test_LINK_LIBRARIES ${_libs})
       endif()
     endforeach()
 
     # Register the executable to compile
     add_executable(${test_name} ${_compile_source})
 
     # set the proper includes to build most of the tests
     target_include_directories(${test_name}
       PRIVATE ${AKANTU_LIBRARY_INCLUDE_DIRS}
               ${AKANTU_EXTERNAL_INCLUDE_DIR}
               ${PROJECT_BINARY_DIR}/src
               ${_register_test_INCLUDE_DIRECTORIES})
 
     if(NOT _register_test_HEADER_ONLY)
       target_link_libraries(${test_name} PRIVATE akantu ${_register_test_LINK_LIBRARIES})
     else()
       get_target_property(_features akantu INTERFACE_COMPILE_FEATURES)
       target_link_libraries(${test_name} ${_register_test_LINK_LIBRARIES})
       target_compile_features(${test_name} PRIVATE ${_features})
     endif()
 
     # add the extra compilation options
     if(_register_test_COMPILE_OPTIONS)
       set_target_properties(${test_name}
         PROPERTIES COMPILE_DEFINITIONS "${_register_test_COMPILE_OPTIONS}")
     endif()
 
     if(AKANTU_EXTRA_CXX_FLAGS)
       set_target_properties(${test_name}
         PROPERTIES COMPILE_FLAGS "${AKANTU_EXTRA_CXX_FLAGS}")
     endif()
   else()
     add_custom_target(${test_name} ALL)
     if(_register_test_UNPARSED_ARGUMENTS AND NOT _register_test_SCRIPT)
       set(_register_test_SCRIPT ${_register_test_UNPARSED_ARGUMENTS})
     endif()
   endif()
 
   if(_register_test_DEPENDS)
     add_dependencies(${test_name} ${_register_test_DEPENDS})
   endif()
 
   # copy the needed files to the build folder
   if(_register_test_FILES_TO_COPY)
     foreach(_file ${_register_test_FILES_TO_COPY})
       _add_file_to_copy(${test_name} "${_file}")
     endforeach()
   endif()
 
   # create the needed folders in the build folder
   if(_register_test_DIRECTORIES_TO_CREATE)
     foreach(_dir ${_register_test_DIRECTORIES_TO_CREATE})
       if(IS_ABSOLUTE ${dir})
         file(MAKE_DIRECTORY "${_dir}")
       else()
         file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${_dir}")
       endif()
     endforeach()
   endif()
 
   # register the test for ctest
   set(_arguments -n "${test_name}")
   if(_register_test_SCRIPT)
     _add_file_to_copy(${test_name} ${_register_test_SCRIPT})
     if(_register_test_PYTHON)
       if(NOT PYTHONINTERP_FOUND)
         find_package(PythonInterp ${AKANTU_PREFERRED_PYTHON_VERSION} REQUIRED)
       endif()
       list(APPEND _arguments -e "${PYTHON_EXECUTABLE}")
       list(APPEND _extra_args "${_register_test_SCRIPT}")
       add_dependencies(${test_name} py11_akantu)
     else()
       list(APPEND _arguments -e "./${_register_test_SCRIPT}")
     endif()
   elseif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.sh")
     _add_file_to_copy(${test_name} ${test_name}.sh)
     list(APPEND _arguments -e "./${test_name}.sh")
   else()
     list(APPEND _arguments -e "./${test_name}")
   endif()
 
   if(_register_test_GTEST)
     list(APPEND _extra_args "--" "--gtest_output=xml:${PROJECT_BINARY_DIR}/gtest_reports/${test_name}.xml")
   endif()
   
   list(APPEND _arguments -E "${PROJECT_BINARY_DIR}/akantu_environement.sh")
 
   package_is_activated(parallel _is_parallel)
   if(_is_parallel AND AKANTU_TESTS_ALWAYS_USE_MPI AND NOT _register_test_PARALLEL)
     set(_register_test_PARALLEL TRUE)
     set(_register_test_PARALLEL_LEVEL 1)
   endif()
 
   if(_register_test_PARALLEL AND _is_parallel)
     set(_exe ${MPIEXEC})
     if(NOT _exe)
       set(_exe ${MPIEXEC_EXECUTABLE})
     endif()
     list(APPEND _arguments -p "${_exe} ${MPIEXEC_PREFLAGS} ${MPIEXEC_NUMPROC_FLAG}")
     if(_register_test_PARALLEL_LEVEL)
       set(_procs "${_register_test_PARALLEL_LEVEL}")
     elseif(CMAKE_VERSION VERSION_GREATER "3.0")
       set(_procs)
       if(MPIEXEC_MAX_NUMPROCS)
         set(N MPIEXEC_MAX_NUMPROCS)
       else()
         include(ProcessorCount)
         ProcessorCount(N)
       endif()
       
       while(N GREATER 1)
         list(APPEND _procs ${N})
         math(EXPR N "${N} / 2")
       endwhile()
       list(APPEND _procs 1)
     endif()
 
     if(NOT _procs)
       set(_procs 2)
     endif()
   endif()
 
   if(_register_test_POSTPROCESS)
     list(APPEND _arguments -s "${_register_test_POSTPROCESS}")
     file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/${_register_test_POSTPROCESS}
       FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
       DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
   endif()
 
   list(APPEND _arguments -w "${CMAKE_CURRENT_BINARY_DIR}")
 
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.verified")
     list(APPEND _arguments -r "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.verified")
   endif()
 
   if(CMAKE_BUILD_TYPE MATCHES "[Vv][Aa][Ll][Gg][Rr][Ii][Nn][Dd]" AND VALGRINDXECUTABLE)
     list(APPEND _arguments -v "${VALGRIND_EXECUTABLE} --error-exitcode=111 --leak-check=full --suppressions=${PROJECT_SOURCE_DIR}/test/ci/ompi_init.supp")
   endif()
 
   string(REPLACE ";" " " _command "${_arguments}")
 
   # register them test
   if(_procs)
     foreach(p ${_procs})
       add_test(NAME ${test_name}_${p} COMMAND ${AKANTU_DRIVER_SCRIPT} ${_arguments} -N ${p} ${_extra_args})
       set_property(TEST ${test_name}_${p} PROPERTY PROCESSORS ${p})
     endforeach()
   else()
     add_test(NAME ${test_name} COMMAND ${AKANTU_DRIVER_SCRIPT} ${_arguments} ${_extra_args})
     set_property(TEST ${test_name} PROPERTY PROCESSORS 1)
   endif()
 endfunction()
 
 
 function(register_test_files_to_package)
   cmake_parse_arguments(_register_test
     "${_test_flags}"
     "${_test_one_variables}"
     "${_test_multi_variables}"
     ${ARGN}
     )
 
   if(_register_test_PYTHON)
     list(APPEND _register_test_PACKAGE python_interface)
   endif()
 
   set(_test_all_files)
   # add the source files in the list of all files
   foreach(_file ${_register_test_SOURCES} ${_register_test_UNPARSED_ARGUMENTS}
       ${_register_test_EXTRA_FILES} ${_register_test_SOURCES} ${_register_test_SCRIPT}
       ${_register_test_POSTPROCESS} ${_register_test_FILES_TO_COPY})
     if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${_file} OR EXISTS ${_file})
       list(APPEND _test_all_files "${_file}")
     else()
       message("The file \"${_file}\" registred by the test \"${test_name}\" does not exists")
     endif()
   endforeach()
 
   # add the different dependencies files (meshes, local libraries, ...)
   foreach(_dep ${_register_test_DEPENDS})
     get_target_list_of_associated_files(${_dep} _dep_ressources)
     if(_dep_ressources)
       list(APPEND _test_all_files "${_dep_ressources}")
     endif()
   endforeach()
 
   # add extra files to the list of files referenced by a given test
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.sh")
     list(APPEND _test_all_files "${test_name}.sh")
   endif()
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_name}.verified")
     list(APPEND _test_all_files "${test_name}.verified")
   endif()
   if(_register_test_SCRIPT)
     list(APPEND _test_all_files "${_register_test_SCRIPT}")
   endif()
 
   # clean the list of all files for this test and add them in the total list
   foreach(_file ${_test_all_files})
     get_filename_component(_full ${_file} ABSOLUTE)
     file(RELATIVE_PATH __file ${PROJECT_SOURCE_DIR} ${_full})
     list(APPEND _tmp "${__file}")
   endforeach()
 
   foreach(_pkg ${_register_test_PACKAGE})
     package_get_name(${_pkg} _pkg_name)
     _package_add_to_variable(TESTS_FILES ${_pkg_name} ${_tmp})
   endforeach()
 endfunction()
diff --git a/cmake/Modules/CMakePackagesSystem.cmake b/cmake/Modules/CMakePackagesSystem.cmake
index d8bfd34c0..c4240d703 100644
--- a/cmake/Modules/CMakePackagesSystem.cmake
+++ b/cmake/Modules/CMakePackagesSystem.cmake
@@ -1,1108 +1,1108 @@
 #===============================================================================
 # @file   CMakePackagesSystem.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sun Oct 19 2014
 # @date last modification: Mon Mar 08 2021
 #
 # @brief  Set of macros used by akantu to handle the package system
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # 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 <ON|OFF|AUTO> [ <script_to_compile> ]]
 #       [FEATURES_PUBLIC <feature> ...]
 #       [FEATURES_PRIVATE <feature> ...]
 #       [EXCLUDE_FROM_ALL]
 #       )
 #
 #.. 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>)
 #
 #.. 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> <PRIVATE|INTERFACE> <retval>)
 #.. command:: package_add_dependencies
 #     package_add_dependencies(<pkg> <PRIVATE|INTERFACE> <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
 #
 #     package_set_package_system_dependency(<pkg> <system> <dep1>
 #                                           <dep2> ... <depn>)
 #
 #                                       .. command:: package_get_package_system_dependency
 #
 #     package_get_package_system_dependency(<pkg> <var>)
 #
 #
 #]=======================================================================]
 if (DEFINED CMAKE_PACKAGES_SYSTEM_LOADED)
   return()
 endif()
 set(CMAKE_PACKAGES_SYSTEM_LOADED TRUE)
 
 
 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()
 
 # ------------------------------------------------------------------------------
 # Add package's targets to the export list
 # ------------------------------------------------------------------------------
 function(package_add_to_export_list pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_export_list(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Removes packages's targets from export list
 # ------------------------------------------------------------------------------
 function(package_remove_from_export_list pkg)
   package_get_name(${pkg} _pkg_name)
   _package_remove_from_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 type ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_dependencies(${_pkg_name} ${type} _tmp_name)
   _package_get_real_name(${_tmp_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_dependencies pkg type)
   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} ${type} ${_tmp_deps})
 endfunction()
 
 function(package_remove_dependencies pkg type)
   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} PRIVATE ${_dep_pkg_name})
   _package_remove_dependency(${_pkg_name} INTERFACE ${_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)
   cmake_parse_arguments(_opt "" "PRIVATE_INCLUDE;INTERFACE_INCLUDE;LIBRARIES" "" ${ARGN})
 
   foreach(_type PRIVATE INTERFACE)
     if(_opt_${_type}_INCLUDE)
       _package_get_variable_for_external_dependencies(INCLUDE_DIR ${_type} tmp_INCLUDE_DIR)
       foreach(_dir ${tmp_INCLUDE_DIR})
         string(FIND "${_dir}" "${CMAKE_CURRENT_SOURCE_DIR}" _pos)
         if(NOT _pos EQUAL -1)
           list(REMOVE_ITEM tmp_INCLUDE_DIR ${_dir})
         endif()
       endforeach()
 
       set(${_opt_${_type}_INCLUDE} ${tmp_INCLUDE_DIR} PARENT_SCOPE)
     endif()
   endforeach()
 
   if(_opt_LIBRARIES)
     _package_get_variable_for_external_dependencies(LIBRARIES PRIVATE tmp_LIBRARIES)
     _package_get_variable_for_external_dependencies(LIBRARIES INTERFACE tmp_LIBRARIES_INTERFACE)
     set(${_opt_LIBRARIES} ${tmp_LIBRARIES} ${tmp_LIBRARIES_INTERFACE} PARENT_SCOPE)
   endif()
 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} PRIVATE)
     _package_unset_dependencies(${_pkg_name} INTERFACE)
     _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
     EXCLUDE_FROM_ALL)
   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)
     mark_as_advanced(${_option_name})
   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(_deps_types PRIVATE PUBLIC INTERFACE)
     cmake_parse_arguments(_pkg_deps
       ""
       ""
       "${_deps_types}"
       ${_opt_pkg_DEPENDS})
 
     list(APPEND _pkg_deps_PRIVATE ${_pkg_deps_UNPARSED_ARGUMENTS})
     foreach(_type ${_deps_types})
       set(_depends)
       foreach(_dep ${_pkg_deps_${_type}})
-	package_get_name(${_dep} _dep_pkg_name)
-	list(APPEND _depends ${_dep_pkg_name})
+        package_get_name(${_dep} _dep_pkg_name)
+        list(APPEND _depends ${_dep_pkg_name})
       endforeach()
       _package_add_dependencies(${_pkg_name} ${_type} ${_depends})
     endforeach()
   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()
 
   set(_variables FEATURES_PUBLIC FEATURES_PRIVATE EXCLUDE_FROM_ALL)
   foreach(_variable ${_variables})
     if(_opt_pkg_${_variable})
       _package_set_variable(${_variable} ${_pkg_name} "${_opt_pkg_${_variable}}")
     endif()
   endforeach()
 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
       set(_full_path "${_src_folder}/${_file}")
       list(APPEND ${_type} "${_full_path}")
     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/cmake/Modules/CMakeVersionGenerator.cmake b/cmake/Modules/CMakeVersionGenerator.cmake
index 74a30e938..6911d3eeb 100644
--- a/cmake/Modules/CMakeVersionGenerator.cmake
+++ b/cmake/Modules/CMakeVersionGenerator.cmake
@@ -1,241 +1,247 @@
 #===============================================================================
 # @file   CMakeVersionGenerator.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sun Oct 19 2014
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  Set of macros used by akantu to handle the package system
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 if(__DEFINE_PROJECT_VERSION__)
   return()
 endif()
 set(__DEFINE_PROJECT_VERSION__ TRUE)
 
 function(_match_semver _input_semver prefix)
   set(_semver_regexp
     "^([0-9]+(\\.[0-9]+)?(\\.[0-9]+)?)(-([a-zA-Z0-9-]*))?(\\+(.*))?")
 
   if(_input_semver MATCHES "^([0-9]+(\\.[0-9]+)?(\\.[0-9]+)?)(-([a-zA-Z0-9-]*))?(\\+(.*))?")
     set(${prefix}_version ${CMAKE_MATCH_1} PARENT_SCOPE)
     if(CMAKE_MATCH_4)
       set(${prefix}_version_prerelease "${CMAKE_MATCH_5}" PARENT_SCOPE)
     endif()
 
     if(CMAKE_MATCH_6)
       set(${prefix}_version_metadata "${CMAKE_MATCH_7}" PARENT_SCOPE)
     endif()
 
   endif()
 endfunction()
 
 function(_get_version_from_git)
   if(NOT CMAKE_VERSION_GENERATOR_TAG_PREFIX)
-    set(CMAKE_VERSION_GENERATOR_TAG_PREFIX "av")
+    set(CMAKE_VERSION_GENERATOR_TAG_PREFIX "v")
   endif()
 
-
   find_package(Git)
+
   if(Git_FOUND)
     execute_process(
       COMMAND ${GIT_EXECUTABLE} describe
         --tags
         --abbrev=0
         --match ${CMAKE_VERSION_GENERATOR_TAG_PREFIX}*
       WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
       RESULT_VARIABLE _res
       OUTPUT_VARIABLE _out_tag
       OUTPUT_STRIP_TRAILING_WHITESPACE
       ERROR_VARIABLE _err_tag)
 
     if(NOT _res EQUAL 0)
       return()
     endif()
 
     string(REGEX REPLACE "^${CMAKE_VERSION_GENERATOR_TAG_PREFIX}(.*)" "\\1" _tag "${_out_tag}")
 
     _match_semver("${_tag}" _tag)
 
     execute_process(
       COMMAND ${GIT_EXECUTABLE} describe
         --tags
         --dirty
         --always
         --long
         --match ${CMAKE_VERSION_GENERATOR_TAG_PREFIX}*
       WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
       RESULT_VARIABLE _res
       OUTPUT_VARIABLE _out
       OUTPUT_STRIP_TRAILING_WHITESPACE)
 
     set(_git_version ${_tag_version} PARENT_SCOPE)
 
     if(_tag_version_prerealease)
       set(_git_version_prerelease ${_tag_version_prerealease} PARENT_SCOPE)
     endif()
 
     # git describe to PEP404 version
     set(_version_regex
-      "^${CMAKE_VERSION_GENERATOR_TAG_PREFIX}${_tag}(-([0-9]+)-g([0-9a-f]+)(-dirty)?)?$")
+      "^${CMAKE_VERSION_GENERATOR_TAG_PREFIX}${_tag}(-([0-9]+)-(g[0-9a-f]+)(-dirty)?)?$")
 
     if(_out MATCHES ${_version_regex})
       if(CMAKE_MATCH_1)
         if(_tag_version_metadata)
           set(_metadata "${_tag_version_metadata}.")
         endif()
         set(_metadata "${_metadata}${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
       endif()
       if(CMAKE_MATCH_4)
         set(_metadata "${_metadata}.dirty")
       endif()
     else()
       execute_process(
         COMMAND ${GIT_EXECUTABLE} rev-list HEAD --count
         WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
         RESULT_VARIABLE _res
         OUTPUT_VARIABLE _out_count
         OUTPUT_STRIP_TRAILING_WHITESPACE)
 
       if(_out MATCHES "^([0-9a-f]+)(-dirty)?$")
         set(_metadata "${CMAKE_MATCH_1}")
         if(_res EQUAL 0)
           set(_metadata "${_out_count}.${_metadata}")
         endif()
 
         if(CMAKE_MATCH_2)
           set(_metadata "${_metadata}.dirty")
         endif()
       endif()
     endif()
-
     set(_git_version_metadata ${_metadata} PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_get_version_from_file)
   if(EXISTS ${PROJECT_SOURCE_DIR}/VERSION)
     file(STRINGS ${PROJECT_SOURCE_DIR}/VERSION _file_version)
     _match_semver("${_file_version}" "_file")
     set(_file_version ${_file_version} PARENT_SCOPE)
     if(_file_version_metadata)
       set(_file_version_metadata ${_file_version_metadata} PARENT_SCOPE)
     endif()
 
     if(_file_version_prerelease)
       set(_file_version_prerelease ${_file_version_prerelease} PARENT_SCOPE)
     endif()
   endif()
 endfunction()
 
 function(_get_metadata_from_ci)
   if(NOT DEFINED ENV{CI})
     return()
   endif()
 
   if(DEFINED ENV{CI_MERGE_REQUEST_ID})
     set(_ci_version_metadata "ci.mr$ENV{CI_MERGE_REQUEST_ID}" PARENT_SCOPE)
-  elseif(DEFINED ENV{CI_COMMIT_SHORT_SHA})
-    set(_ci_version_metadata "ci.$ENV{CI_COMMIT_SHORT_SHA}" PARENT_SCOPE)
   endif()
 endfunction()
 
 function(define_project_version)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   _get_version_from_git()
 
   if(_git_version)
-    set(_git_version ${_file_version})
-    if(_version_metadata)
+    set(_version "${_git_version}")
+    if(_git_version_metadata)
       set(_version_metadata "${_git_version_metadata}")
     endif()
 
     if (_git_version_prerelease)
       set(_version_prerelease "${_git_version_prerelease}")
     endif()
   else()
     # we can get metadata if and no version if not tag is properly defined
     if(_git_version_metadata)
       set(git_version_metadata ".${_git_version_metadata}")
     endif()
 
     _get_version_from_file()
 
     if(_file_version_metadata)
       set(_version_metadata "${_version_metadata}${_git_version_metadata}")
     endif()
 
     if (_file_version)
       set(_version "${_file_version}")
     endif()
 
     if (_file_version_prerelease)
       set(_version_prerelease "${_file_version_prerelease}")
     endif()
   endif()
 
   _get_metadata_from_ci()
 
   if(_version)
-    set(${_project}_VERSION ${_version} PARENT_SCOPE)
     if(_version_prerelease)
       set(_version_prerelease "-${_version_prerelease}")
     endif()
     if(_version_metadata)
       set(_version_metadata "+${_version_metadata}")
       if(_ci_version_metadata)
         set(_version_metadata "${_version_metadata}.${_ci_version_metadata}")
       endif()
     endif()
+    set(${_project}_VERSION ${_version} PARENT_SCOPE)
 
     set(_semver "${_version}${_version_prerelease}${_version_metadata}")
     set(${_project}_SEMVER "${_semver}" PARENT_SCOPE)
     message(STATUS "${PROJECT_NAME} version: ${_semver}")
 
     if(_version MATCHES "^([0-9]+)(\\.([0-9]+))?(\\.([0-9]+))?")
       set(_major_version ${CMAKE_MATCH_1})
       set(${_project}_MAJOR_VERSION ${_major_version} PARENT_SCOPE)
       if(CMAKE_MATCH_2)
         set(_minor_version ${CMAKE_MATCH_3})
         set(${_project}_MINOR_VERSION ${_minor_version} PARENT_SCOPE)
       endif()
       if(CMAKE_MATCH_4)
         set(_patch_version ${CMAKE_MATCH_5})
         set(${_project}_PATCH_VERSION ${_patch_version} PARENT_SCOPE)
       endif()
+      if(_version_prerelease)
+        set(${_project}_PRERELEASE_VERSION ${_version_prerelease} PARENT_SCOPE)
+      endif()
+      if(_version_metadata)
+        set(${_project}_LOCAL_VERSION ${_version_metadata} PARENT_SCOPE)
+      endif()
+      if(_version_metadata MATCHES "(\\+([0-9]+))(\\..*)*")
+        set(${_project}_TWEAK ${CMAKE_MATCH_1} PARENT_SCOPE)
+      endif()
     endif()
   else()
     message(FATAL_ERROR "Could not determine the VERSION for ${PROJECT_NAME}")
   endif()
 
   if(NOT ${_project}_NO_LIBRARY_VERSION)
     set(${_project}_LIBRARY_PROPERTIES ${${_project}_LIBRARY_PROPERTIES}
       VERSION "${_version}"
       SOVERSION "${_major_version}.${_minor_version}"
       )
   endif()
 endfunction()
diff --git a/cmake/Modules/FindCppArray.cmake b/cmake/Modules/FindCppArray.cmake
deleted file mode 100644
index d8230583d..000000000
--- a/cmake/Modules/FindCppArray.cmake
+++ /dev/null
@@ -1,37 +0,0 @@
-#===============================================================================
-# @file   FindCppArray.cmake
-#
-# @author Alejandro M. Aragón <alejandro.aragon@epfl.ch>
-#
-# @date creation: Fri Sep 03 2010
-# @date last modification: Fri Mar 16 2018
-#
-# @brief  The find_package file for cpp-array library
-#
-#
-# @section LICENSE
-#
-# Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
-# Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
-#
-# Akantu is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-# 
-# Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-# details.
-# 
-# You should have received a copy of the GNU Lesser General Public License along
-# with Akantu. If not, see <http://www.gnu.org/licenses/>.
-#
-#===============================================================================
-
-
-find_path (CPPARRAY_INCLUDE_DIR expr.hpp PATH_SUFFIXES array)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(CppArray DEFAULT_MSG CPPARRAY_INCLUDE_DIR)
-
diff --git a/cmake/Modules/FindGMSH.cmake b/cmake/Modules/FindGMSH.cmake
index 212bae0e4..8785e9023 100644
--- a/cmake/Modules/FindGMSH.cmake
+++ b/cmake/Modules/FindGMSH.cmake
@@ -1,113 +1,118 @@
 #===============================================================================
 # @file   FindGMSH.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sun Oct 19 2014
 # @date last modification: Wed Aug 14 2019
 #
 # @brief  Find gmsh and delacre the add_mesh macro
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 find_program(GMSH gmsh
   DOC "The mesh generetor gmsh")
 
 mark_as_advanced(GMSH)
 
 if (GMSH)
   execute_process(COMMAND ${GMSH} --version
-    ERROR_VARIABLE GMSH_VERSION
+    OUTPUT_VARIABLE GMSH_VERSION
+    ERROR_VARIABLE GMSH_VERSION_ERR
     ERROR_STRIP_TRAILING_WHITESPACE)
 endif()
 
+if(NOT GMSH_VERSION)
+  set(GMSH_VERSION ${GMSH_VERSION_ERR})
+endif()
+
 find_package(PackageHandleStandardArgs)
 find_package_handle_standard_args(GMSH
   REQUIRED_VARS GMSH
   VERSION_VAR GMSH_VERSION)
 
 #===============================================================================
 function(ADD_MESH MESH_TARGET GEO_FILE)
   if(NOT GMSH_FOUND)
     return()
   endif()
   set(arguments
     ${MESH_TARGET} ${GEO_FILE}
     ${ARGN}
     )
 
   cmake_parse_arguments(_add_mesh
     ""
     "OUTPUT;DIM;ORDER"
     ""
     ${arguments}
     )
 
   if(NOT _add_mesh_DIM AND NOT _add_mesh_ORDER)
     list(GET _add_mesh_UNPARSED_ARGUMENTS 2 _add_mesh_DIM)
     list(GET _add_mesh_UNPARSED_ARGUMENTS 3 _add_mesh_ORDER)
   endif()
 
   if(NOT _add_mesh_DIM)
     set(_add_mesh_DIM 3)
   endif()
 
   if(NOT _add_mesh_ORDER)
     set(_add_mesh_ORDER 1)
   endif()
   
   set(_geo_file ${CMAKE_CURRENT_SOURCE_DIR}/${GEO_FILE})
 
   set(_r_geo_file "${GEO_FILE}")
 
   if(_add_mesh_OUTPUT)
     set(_msh_file ${CMAKE_CURRENT_BINARY_DIR}/${_add_mesh_OUTPUT})
     set(_r_msh_file "${_add_mesh_OUTPUT}")
   else(_add_mesh_OUTPUT)
     get_filename_component(_msh_file "${GEO_FILE}" NAME_WE)
     set(_r_msh_file "${_msh_file}.msh")
     set(_msh_file ${CMAKE_CURRENT_BINARY_DIR}/${_msh_file}.msh)
   endif(_add_mesh_OUTPUT)
 
   if(GMSH_VERSION VERSION_LESS 3.0.0)
     set(OPTIMIZE -optimize)
   endif()
 
   if(EXISTS ${_geo_file})
     add_custom_command(
       OUTPUT ${_msh_file}
       DEPENDS ${_geo_file}
       COMMAND ${GMSH}
       ARGS -${_add_mesh_DIM} -order ${_add_mesh_ORDER} ${OPTIMIZE} -o ${_msh_file} ${_geo_file} 2>&1 > /dev/null
       COMMENT "Generating the ${_add_mesh_DIM}D mesh ${_r_msh_file} (order ${_add_mesh_ORDER}) form the geometry ${_r_geo_file}"
       )
 
     add_custom_target(${MESH_TARGET}
       DEPENDS ${_msh_file})
     set_target_properties(${MESH_TARGET} PROPERTIES RESSOURCES ${_geo_file})
   else(EXISTS ${_geo_file})
     message(WARNING
       "File ${_geo_file} not found for target ${MESH_TARGET}")
   endif(EXISTS ${_geo_file})
 endfunction()
diff --git a/cmake/Modules/FindIOHelper.cmake b/cmake/Modules/FindIOHelper.cmake
deleted file mode 100644
index 9d4676559..000000000
--- a/cmake/Modules/FindIOHelper.cmake
+++ /dev/null
@@ -1,62 +0,0 @@
-#===============================================================================
-# @file   FindIOHelper.cmake
-#
-# @author Nicolas Richart <nicolas.richart@epfl.ch>
-#
-# @date creation: Sun Oct 19 2014
-# @date last modification: Fri Jan 15 2016
-#
-# @brief  The find_package file for IOHelper
-#
-#
-# @section LICENSE
-#
-# Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
-# Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
-#
-# Akantu is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-# 
-# Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-# details.
-# 
-# You should have received a copy of the GNU Lesser General Public License along
-# with Akantu. If not, see <http://www.gnu.org/licenses/>.
-#
-#===============================================================================
-
-
-#===============================================================================
-#set(IOHELPER_LIBRARY "NOTFOUND" CACHE INTERNAL "Cleared" FORCE)
-find_library(IOHELPER_LIBRARY iohelper
-  PATHS ${IOHELPER_DIR}
-  PATH_SUFFIXES lib
-  )
-
-find_path(IOHELPER_INCLUDE_DIR io_helper.hh
-  PATHS ${IOHELPER_DIR}
-  PATH_SUFFIXES include include/iohelper
-  )
-
-#===============================================================================
-mark_as_advanced(IOHELPER_LIBRARY)
-mark_as_advanced(IOHELPER_INCLUDE_DIR)
-
-#===============================================================================
-find_package(ZLIB REQUIRED)
-
-set(IOHELPER_LIBRARIES_ALL ${IOHELPER_LIBRARY} ${ZLIB_LIBRARIES})
-set(IOHELPER_LIBRARIES ${IOHELPER_LIBRARIES_ALL} CACHE INTERNAL "Libraries for IOHelper" FORCE)
-
-#===============================================================================
-if(NOT IOHELPER_FOUND)
-  set(IOHELPER_DIR "" CACHE PATH "Location of IOHelper source directory.")
-endif()
-
-#===============================================================================
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(IOHelper DEFAULT_MSG IOHELPER_LIBRARY IOHELPER_INCLUDE_DIR)
diff --git a/cmake/Modules/FindMumps.cmake b/cmake/Modules/FindMumps.cmake
index 30e60646c..102eaf8f8 100644
--- a/cmake/Modules/FindMumps.cmake
+++ b/cmake/Modules/FindMumps.cmake
@@ -1,320 +1,343 @@
 #===============================================================================
 # @file   FindMumps.cmake
 #
 # @author Mathias Lebihain <mathias.lebihain@enpc.fr>
 # @author Philip Mueller <philip.mueller@math.ethz.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sun Oct 19 2014
 # @date last modification: Fri Jan 22 2021
 #
 # @brief  The find_package file for the Mumps solver
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 set(_MUMPS_COMPONENTS "sequential" "parallel" "double" "float" "complex_double" "complex_float")
 
 if(NOT Mumps_FIND_COMPONENTS)
   set(Mumps_FIND_COMPONENTS "parallel" "double" "float" "complex_double" "complex_float")
 endif()
 #===============================================================================
 enable_language(Fortran)
 
+option(MUMPS_DETECT_DEBUG "Helps to debug mumps detection problems" OFF)
+mark_as_advanced(MUMPS_DETECT_DEBUG)
+
 set(MUMPS_PRECISIONS)
 set(MUMPS_PLAT)
 foreach(_comp ${Mumps_FIND_COMPONENTS})
   if("${_comp}" STREQUAL "sequential")
     set(MUMPS_PLAT _seq) #default plat on debian based distribution
   endif()
 
   if("${_comp}" STREQUAL "float")
     list(APPEND MUMPS_PRECISIONS s)
   endif()
   if("${_comp}" STREQUAL "double")
     list(APPEND MUMPS_PRECISIONS d)
   endif()
   if("${_comp}" STREQUAL "complex_float")
     list(APPEND MUMPS_PRECISIONS c)
   endif()
   if("${_comp}" STREQUAL "complex_double")
     list(APPEND MUMPS_PRECISIONS z)
   endif()
 endforeach()
 
 if(NOT MUMPS_PRECISIONS)
   set(MUMPS_PRECISIONS s d c z)
 endif()
 
 list(GET MUMPS_PRECISIONS 0 _first_precision)
 
 string(TOUPPER "${_first_precision}" _u_first_precision)
 
 find_path(MUMPS_INCLUDE_DIR ${_first_precision}mumps_c.h
   PATHS "${MUMPS_DIR}"
   ENV MUMPS_DIR
   PATH_SUFFIXES include
   )
 mark_as_advanced(MUMPS_INCLUDE_DIR)
 
 set(_mumps_required_vars)
 foreach(_precision ${MUMPS_PRECISIONS})
   string(TOUPPER "${_precision}" _u_precision)
   find_library(MUMPS_LIBRARY_${_u_precision}MUMPS NAMES ${_precision}mumps${MUMPS_PREFIX}
     PATHS "${MUMPS_DIR}"
     ENV MUMPS_DIR
     PATH_SUFFIXES lib
     )
   mark_as_advanced(MUMPS_LIBRARY_${_u_precision}MUMPS)
   list(APPEND _mumps_required_vars MUMPS_LIBRARY_${_u_precision}MUMPS)
 
   list(APPEND MUMPS_LIBRARIES_ALL ${MUMPS_LIBRARY_${_u_precision}MUMPS})
 endforeach()
 
 
 if(MUMPS_LIBRARY_${_u_first_precision}MUMPS MATCHES ".*${_first_precision}mumps.*${CMAKE_STATIC_LIBRARY_SUFFIX}")
   # Assuming mumps was compiled as a static library
   set(MUMPS_LIBRARY_TYPE STATIC CACHE INTERNAL "" FORCE)
 
   if (CMAKE_Fortran_COMPILER MATCHES ".*gfortran")
     set(_compiler_specific gfortran)
   elseif (CMAKE_Fortran_COMPILER MATCHES ".*ifort")
     set(_compiler_specific ifcore)
   else()
     message("Compiler ${CMAKE_Fortran_COMPILER} is not known, you will probably "
       "have to add semething instead of this message to be able to test mumps "
       "install")
   endif()
 else()
   set(MUMPS_LIBRARY_TYPE SHARED CACHE INTERNAL "" FORCE)
 endif()
 
 
+macro(find_mpiseq)
+  find_library(MUMPS_LIBRARY_MPISEQ mpiseq${MUMPS_PREFIX}
+    PATHS "${MUMPS_DIR}"
+    ENV MUMPS_DIR
+    PATH_SUFFIXES lib
+    )
+  if (NOT MUMPS_LIBRARY_MPISEQ)
+    message("Could not find libmpiseq for sequential version of MUMPS, was "
+      "MUMPS compiled in sequential ?")
+  endif()
+  set(${_libs} ${MUMPS_LIBRARY_MPISEQ} PARENT_SCOPE)
+  mark_as_advanced(MUMPS_LIBRARY_MPISEQ)
+endmacro()
+
 function(mumps_add_dependency _pdep _libs)
   string(TOUPPER ${_pdep} _u_pdep)
   if(_pdep STREQUAL "mumps_common")
     find_library(MUMPS_LIBRARY_COMMON mumps_common${MUMPS_PREFIX}
       PATHS "${MUMPS_DIR}"
       ENV MUMPS_DIR
       PATH_SUFFIXES lib
       )
     set(${_libs} ${MUMPS_LIBRARY_COMMON} PARENT_SCOPE)
     mark_as_advanced(MUMPS_LIBRARY_COMMON)
   elseif(_pdep STREQUAL "pord")
     find_library(MUMPS_LIBRARY_PORD pord${MUMPS_PREFIX}
       PATHS "${MUMPS_DIR}"
       ENV MUMPS_DIR
       PATH_SUFFIXES lib
       )
     set(${_libs} ${MUMPS_LIBRARY_PORD} PARENT_SCOPE)
     mark_as_advanced(MUMPS_LIBRARY_PORD)
   elseif(_pdep MATCHES "Scotch")
     find_package(Scotch REQUIRED ${ARGN} QUIET)
     if(ARGN)
       list(GET ARGN 1 _comp)
       string(TOUPPER ${_comp} _u_comp)
       set(${_libs} ${SCOTCH_LIBRARY_${_u_comp}} PARENT_SCOPE)
     else()
       set(${_libs} ${${_u_pdep}_LIBRARIES} PARENT_SCOPE)
     endif()
   elseif(_pdep MATCHES "MPI")
     if(MUMPS_PLAT STREQUAL "_seq")
-      find_library(MUMPS_LIBRARY_MPISEQ mpiseq${MUMPS_PREFIX}
-        PATHS "${MUMPS_DIR}"
-        ENV MUMPS_DIR
-        PATH_SUFFIXES lib
-        )
-      if (NOT MUMPS_LIBRARY_MPISEQ)
-        message("Could not find libmpiseq for sequential version of MUMPS, was "
-          "MUMPS compiled in sequential ?")
-      endif()
-      set(${_libs} ${MUMPS_LIBRARY_MPISEQ} PARENT_SCOPE)
-      mark_as_advanced(MUMPS_LIBRARY_MPISEQ)
+      find_mpiseq()
     else()
       find_package(MPI REQUIRED C Fortran QUIET)
       set(${_libs} ${MPI_C_LIBRARIES} ${MPI_Fortran_LIBRARIES} PARENT_SCOPE)
     endif()
   elseif(_pdep MATCHES "Threads")
     find_package(Threads REQUIRED)
     set(${_libs} Threads::Threads PARENT_SCOPE)
   elseif(_pdep MATCHES "OpenMP")
     find_package(OpenMP REQUIRED)
     set(${_libs} OpenMP::OpenMP_C PARENT_SCOPE)
   elseif(_pdep MATCHES "Math")
     set(${_libs} m PARENT_SCOPE)
+  elseif(_pdep MATCHES "ScaLAPACK")
+    if(MUMPS_PLAT STREQUAL "_seq")
+      # ScaLAPACK symbols are in mpiseq form 5.20+
+      find_mpiseq()
+    else()
+      find_package(ScaLAPACK REQUIRED QUIET)
+      set(${_libs} ${SCALAPACK_LIBRARIES} PARENT_SCOPE)
+    endif()
   else()
     find_package(${_pdep} REQUIRED QUIET)
     set(${_libs} ${${_u_pdep}_LIBRARIES} ${${_u_pdep}_LIBRARY} PARENT_SCOPE)
   endif()
 endfunction()
 
 function(mumps_find_dependencies)
   set(_libraries_all m ${MUMPS_LIBRARIES_ALL})
   set(_include_dirs ${MUMPS_INCLUDE_DIR})
 
   set(_mumps_test_dir "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}")
   file(READ ${CMAKE_CURRENT_LIST_DIR}/CheckFindMumps.c _output)
   file(WRITE "${_mumps_test_dir}/mumps_test_code.c"
     "#include <${_first_precision}mumps_c.h>
 ${_u_first_precision}MUMPS_STRUC_C id;
 
 #define mumps_c ${_first_precision}mumps_c
 #define Real ${_u_first_precision}MUMPS_REAL
 ")
 
   if(MUMPS_PLAT STREQUAL _seq)
     file(APPEND "${_mumps_test_dir}/mumps_test_code.c"
       "#define MUMPS_SEQ
 ")
   else()
     file(APPEND "${_mumps_test_dir}/mumps_test_code.c"
       "// #undef MUMPS_SEQ
 ")
-        find_package(MPI REQUIRED)
+    find_package(MPI REQUIRED)
     list(APPEND _compiler_specific ${MPI_C_LIBRARIES})
     list(APPEND _include_dirs ${MPI_C_INCLUDE_PATH} ${MPI_INCLUDE_DIR})
   endif()
 
   file(APPEND "${_mumps_test_dir}/mumps_test_code.c" "${_output}")
 
   #===============================================================================
+  set(_mumps_dep_symbol_MPI mpi_send)
   set(_mumps_dep_symbol_BLAS ${_first_precision}gemm)
   set(_mumps_dep_symbol_ScaLAPACK numroc)
   set(_mumps_dep_symbol_LAPACK ilaenv)
-  set(_mumps_dep_symbol_MPI mpi_send)
   set(_mumps_dep_symbol_Scotch SCOTCH_graphInit)
   set(_mumps_dep_symbol_Scotch_ptscotch scotchfdgraphexit)
   set(_mumps_dep_symbol_Scotch_esmumps esmumps)
   set(_mumps_dep_symbol_mumps_common mumps_abort)
   set(_mumps_dep_symbol_pord SPACE_ordering)
   set(_mumps_dep_symbol_METIS metis_nodend)
   set(_mumps_dep_symbol_Threads pthread_create)
   set(_mumps_dep_symbol_OpenMP GOMP_loop_end_nowait)
   # TODO find missing symbols for IOMP
   set(_mumps_dep_symbol_Math lround)
   set(_mumps_dep_symbol_ParMETIS ParMETIS_V3_NodeND)
 
   # added for fucking macosx that cannot fail at link
   set(_mumps_run_dep_symbol_mumps_common mumps_fac_descband)
   set(_mumps_run_dep_symbol_MPI mpi_bcast)
   set(_mumps_run_dep_symbol_ScaLAPACK idamax)
 
   set(_mumps_dep_comp_Scotch_ptscotch COMPONENTS ptscotch)
   set(_mumps_dep_comp_Scotch_esmumps COMPONENTS esmumps)
 
   set(_mumps_potential_dependencies
+    MPI
     mumps_common pord
     BLAS LAPACK ScaLAPACK
-    MPI
-	  Scotch Scotch_ptscotch Scotch_esmumps
+    Scotch Scotch_ptscotch Scotch_esmumps
     METIS ParMETIS
     Threads OpenMP
     Math)
   #===============================================================================
 
   set(_retry_try_run TRUE)
   set(_retry_count 0)
 
   # trying only as long as we add dependencies to avoid inifinte loop in case of an unkown dependency
   while (_retry_try_run AND _retry_count LESS 100)
     try_run(_mumps_run _mumps_compiles
       "${_mumps_test_dir}"
       "${_mumps_test_dir}/mumps_test_code.c"
       CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${_include_dirs}"
       LINK_LIBRARIES ${_libraries_all} ${_libraries_all} ${_compiler_specific}
       RUN_OUTPUT_VARIABLE _run
       COMPILE_OUTPUT_VARIABLE _out)
 
     set(_retry_compile FALSE)
-    #message("COMPILATION outputs: \n${_out} \n RUN OUTPUT \n${_run}")
+    if(MUMPS_DETECT_DEBUG)
+      message("COMPILATION outputs: \n${_out} \n RUN OUTPUT \n${_run}")
+    endif()
     if(_mumps_compiles AND NOT (_mumps_run STREQUAL "FAILED_TO_RUN"))
       break()
     endif()
 
     foreach(_pdep ${_mumps_potential_dependencies})
-      #message("CHECKING ${_pdep}")
+      set(_libs)
+      if(MUMPS_DETECT_DEBUG)
+        message("Trying to add: ${_pdep} as a dependency")
+      endif()
       set(_add_pdep FALSE)
       if (NOT _mumps_compiles AND
           _out MATCHES "undefined reference.*${_mumps_dep_symbol_${_pdep}}")
         set(_add_pdep TRUE)
         #message("NEED COMPILE ${_pdep}")
       elseif(_mumps_run STREQUAL "FAILED_TO_RUN" AND
           DEFINED _mumps_run_dep_symbol_${_pdep} AND
           _run MATCHES "${_mumps_run_dep_symbol_${_pdep}}")
         set(_add_pdep TRUE)
-	      #message("NEED RUN ${_pdep}")
+        #message("NEED RUN ${_pdep}")
       endif()
 
       if(_add_pdep)
         mumps_add_dependency(${_pdep} _libs ${_mumps_dep_comp_${_pdep}})
-	#message("ADDING ${_libs}")
-	if(NOT _libs)
-	  message(FATAL_ERROR "MUMPS depends on ${_pdep} but no libraries where found")
-	endif()
-	list(APPEND _libraries_all ${_libs})
+        if(MUMPS_DETECT_DEBUG)
+          message("Found: ${_pdep} (${_libs})")
+        endif()
+
+        if(NOT _libs)
+          message(FATAL_ERROR "MUMPS depends on ${_pdep} but no libraries where found")
+        endif()
+        list(APPEND _libraries_all ${_libs})
         set(_retry_try_run TRUE)
       endif()
     endforeach()
 
     math(EXPR _retry_count "${_retry_count} + 1")
   endwhile()
 
   if(_retry_count GREATER 10)
     message(FATAL_ERROR "Do not know what to do to link with mumps on your system, I give up!")
     message("Last compilation outputs: \n${_out} \n And last run output \n${_run}")
   endif()
 
   if(APPLE)
     # in doubt add some stuff because mumps was perhaps badly compiled
     mumps_add_dependency(pord _libs)
     list(APPEND _libraries_all ${_libs})
   endif()
 
   set(MUMPS_LIBRARIES_ALL ${_libraries_all} PARENT_SCOPE)
 endfunction()
 
 mumps_find_dependencies()
 
 set(MUMPS_LIBRARIES ${MUMPS_LIBRARIES_ALL} CACHE INTERNAL "" FORCE)
 
 #===============================================================================
 include(FindPackageHandleStandardArgs)
 if(CMAKE_VERSION VERSION_GREATER 2.8.12)
   if(MUMPS_INCLUDE_DIR)
     file(STRINGS ${MUMPS_INCLUDE_DIR}/dmumps_c.h _versions
       REGEX "^#define MUMPS_VERSION .*")
     foreach(_ver ${_versions})
       string(REGEX MATCH "MUMPS_VERSION *\"([0-9.]+)\"" _tmp "${_ver}")
       set(_mumps_VERSION ${CMAKE_MATCH_1})
     endforeach()
     set(MUMPS_VERSION "${_mumps_VERSION}" CACHE INTERNAL "")
   endif()
 
   find_package_handle_standard_args(Mumps
     REQUIRED_VARS ${_mumps_required_vars}
-                  MUMPS_INCLUDE_DIR
+    MUMPS_INCLUDE_DIR
     VERSION_VAR MUMPS_VERSION
     )
 else()
   find_package_handle_standard_args(Mumps DEFAULT_MSG
     ${_mumps_required_vars} MUMPS_INCLUDE_DIR)
 endif()
diff --git a/cmake/Modules/FindNumpy.cmake b/cmake/Modules/FindNumpy.cmake
deleted file mode 100644
index cf04c7bd6..000000000
--- a/cmake/Modules/FindNumpy.cmake
+++ /dev/null
@@ -1,74 +0,0 @@
-#===============================================================================
-# @file   FindNumpy.cmake
-#
-# @author Nicolas Richart <nicolas.richart@epfl.ch>
-#
-# @date creation: Mon Nov 16 2015
-# @date last modification: Fri Jan 15 2016
-#
-# @brief  The find_package file for numpy
-#
-#
-# @section LICENSE
-#
-# Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
-# Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
-#
-# Akantu is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-# 
-# Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-# details.
-# 
-# You should have received a copy of the GNU Lesser General Public License along
-# with Akantu. If not, see <http://www.gnu.org/licenses/>.
-#
-#===============================================================================
-
-
-find_package(PythonInterp)
-#numpy includes
-if(PYTHONINTERP_FOUND)
-  set(_get_include "from __future__ import print_function; import numpy; print(numpy.get_include(), end='')")
-  set(_get_version "from __future__ import print_function; import numpy; print(numpy.version.full_version, end=''),")
-
-  execute_process(COMMAND
-    ${PYTHON_EXECUTABLE} -c "${_get_include}"
-    OUTPUT_VARIABLE _numpy_include_dir
-    ERROR_QUIET
-    RESULT_VARIABLE _res)
-
-  if(_res EQUAL 0)
-    set(NUMPY_INCLUDE_DIR "${_numpy_include_dir}" CACHE PATH "Include directory for numpy" FORCE)
-
-    execute_process(COMMAND
-      ${PYTHON_EXECUTABLE} -c "${_get_version}"
-      OUTPUT_VARIABLE _numpy_version
-      ERROR_QUIET
-      RESULT_VARIABLE _res)
-    if(_res EQUAL 0)
-      set(NUMPY_VERSION "${_numpy_version}" CACHE STRING "Version of numpy")
-    else()
-      set(NUMPY_VERSION "NUMPY_VERSION-NOTFOUND" CACHE STRING "Version of numpy")
-    endif()
-
-    mark_as_advanced(NUMPY_INCLUDE_DIR NUMPY_VERSION)
-  else()
-    set(NUMPY_INCLUDE_DIR "NUMPY_INCLUDE_DIR-NOTFOUND" CACHE PATH "")
-  endif()
-endif()
-
-#===============================================================================
-include(FindPackageHandleStandardArgs)
-if(CMAKE_VERSION VERSION_GREATER 2.8.12)
-  find_package_handle_standard_args(Numpy
-    REQUIRED_VARS NUMPY_INCLUDE_DIR
-    VERSION_VAR NUMPY_VERSION)
-else()
-  find_package_handle_standard_args(Numpy DEFAULT_MSG
-    NUMPY_INCLUDE_DIR NUMPY_VERSION)
-endif()
diff --git a/cmake/Modules/FindScaLAPACK.cmake b/cmake/Modules/FindScaLAPACK.cmake
index b695ed985..857d35048 100644
--- a/cmake/Modules/FindScaLAPACK.cmake
+++ b/cmake/Modules/FindScaLAPACK.cmake
@@ -1,156 +1,156 @@
 #===============================================================================
 # @file   FindScaLAPACK.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Tue Mar 31 2015
 # @date last modification: Wed Jan 13 2016
 #
 # @brief  The find_package file for the Mumps solver
 #
 # @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/>.
 #
 #===============================================================================
 set(SCALAPACK_VENDOR "Auto" CACHE
   STRING "Vendor for scalapack (Auto, Netlib, Intel_(i?)lp64_(openmpi|intelmpi|sgimpt)")
 mark_as_advanced(SCALAPACK_VENDOR)
 set_property(CACHE SCALAPACK_VENDOR PROPERTY STRINGS
   Auto Netlib
   Intel_lp64_openmpi Intel_lp64_intelmpi Intel_lp64_sgimpt
   Intel_ilp64_openmpi Intel_ilp64_intelmpi Intel_ilp64_sgimpt)
 
 
 macro(scalapack_find_library prefix target name list_libraries list_headers)
   foreach(_lib ${list_libraries})
     find_library(${prefix}_${_lib}_LIBRARY NAMES ${_lib}
       PATHS ${prefix}_DIR
       )
     mark_as_advanced(${prefix}_${_lib}_LIBRARY)
 
     if(${prefix}_${_lib}_LIBRARY)
       list(APPEND ${prefix}_libraries ${${prefix}_${_lib}_LIBRARY})
 
       get_filename_component(_ext ${${prefix}_${_lib}_LIBRARY} EXT)
       if(NOT TARGET ${target})
-	if("${_ext}" STREQUAL "${CMAKE_SHARED_LIBRARY_SUFFIX}")
-	  add_library(${target} SHARED IMPORTED)
-	  get_filename_component(_soname ${${prefix}_${_lib}_LIBRARY} NAME)
-	  set_property(TARGET ${target} PROPERTY IMPORTED_SONAME ${_soname})
-	else()
-	  add_library(${target}_${name} STATIC IMPORTED)
-	endif()
-	set_property(TARGET ${target} PROPERTY
-	    IMPORTED_LOCATION ${${prefix}_${_lib}_LIBRARY})
+        if("${_ext}" STREQUAL "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+          add_library(${target} SHARED IMPORTED)
+          get_filename_component(_soname ${${prefix}_${_lib}_LIBRARY} NAME)
+          set_property(TARGET ${target} PROPERTY IMPORTED_SONAME ${_soname})
+        else()
+          add_library(${target}_${name} STATIC IMPORTED)
+        endif()
+        set_property(TARGET ${target} PROPERTY
+          IMPORTED_LOCATION ${${prefix}_${_lib}_LIBRARY})
       else()
-	if("${_ext}" STREQUAL "${CMAKE_SHARED_LIBRARY_SUFFIX}")
-	  set_property(TARGET ${target} APPEND PROPERTY
-	    IMPORTED_LINK_DEPENDENT_LIBRARIES ${${prefix}_${_lib}_LIBRARY}
-	    )
-	else()
-	  set_property(TARGET ${target} APPEND PROPERTY
-	    IMPORTED_LINK_INTERFACE_LIBRARIES ${${prefix}_${_lib}_LIBRARY}
-	    )
-	endif()
+        if("${_ext}" STREQUAL "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+          set_property(TARGET ${target} APPEND PROPERTY
+            IMPORTED_LINK_DEPENDENT_LIBRARIES ${${prefix}_${_lib}_LIBRARY}
+            )
+        else()
+          set_property(TARGET ${target} APPEND PROPERTY
+            IMPORTED_LINK_INTERFACE_LIBRARIES ${${prefix}_${_lib}_LIBRARY}
+            )
+        endif()
       endif()
     else()
       unset(${prefix}_${_lib}_LIBRARY CACHE)
     endif()
   endforeach()
 
   if(${prefix}_libraries)
     foreach(_hdr ${list_headers})
       get_filename_component(_hdr_name ${_hdr} NAME_WE)
       find_path(${prefix}_${_hdr_name}_INCLUDE_DIR NAMES ${_hdr}
-	PATHS ${prefix}_DIR)
+        PATHS ${prefix}_DIR)
       mark_as_advanced(${prefix}_${_hdr_name}_INCLUDE_DIR)
 
       if(${prefix}_${_hdr_name}_INCLUDE_DIR)
-	list(APPEND ${prefix}_include_dir ${${prefix}_${_hdr_name}_INCLUDE_DIR})
-	set_property(TARGET ${target} APPEND PROPERTY
-	  INTERFACE_INCLUDE_DIRECTORIES ${${prefix}_${_lib}_INCLUDE_DIR}
-	  )
+        list(APPEND ${prefix}_include_dir ${${prefix}_${_hdr_name}_INCLUDE_DIR})
+        set_property(TARGET ${target} APPEND PROPERTY
+          INTERFACE_INCLUDE_DIRECTORIES ${${prefix}_${_lib}_INCLUDE_DIR}
+          )
       else()
-	unset(${prefix}_${_lib}_INCLUDE_DIR CACHE)
+        unset(${prefix}_${_lib}_INCLUDE_DIR CACHE)
       endif()
     endforeach()
   endif()
 endmacro()
 
 set(SCALAPACK_libraries)
 set(SCALAPACK_INCLUDE_DIR)
 
 if(SCALAPACK_VENDOR STREQUAL "Auto" OR SCALAPACK_VENDOR STREQUAL "Netlib")
   if(NOT SCALAPACK_libraries)
     scalapack_find_library(
       SCALAPACK
       ScaLAPACK
       "netlib"
       "scalapack;blacsC;blacsF77;blacs"
       ""
       )
   endif()
 endif()
 
 foreach(_precision lp64 ilp64)
   foreach(_mpi intelmpi openmpi sgimpt)
     if(NOT SCALAPACK_libraries)
       if(SCALAPACK_VENDOR STREQUAL "Auto" OR SCALAPACK_VENDOR STREQUAL "Intel_${_precision}_${_mpi}")
-	if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
-	  set(_mkl_common "mkl_intel_${_precision}")
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+          set(_mkl_common "mkl_intel_${_precision}")
 
-	else()
-	  set(_mkl_common "mkl_gf_${_precision}")
-	endif()
-	scalapack_find_library(
-	  SCALAPACK
-	  ScaLAPACK
-	  "intel_${_precision}_${_mpi}"
-	  "mkl_scalapack_${_precision};${_mkl_common};mkl_sequential;mkl_core;mkl_blacs_${_mpi}_${_precision}"
-	  "mkl_scalapack.h"
-	  )
+        else()
+          set(_mkl_common "mkl_gf_${_precision}")
+        endif()
+        scalapack_find_library(
+          SCALAPACK
+          ScaLAPACK
+          "intel_${_precision}_${_mpi}"
+          "mkl_scalapack_${_precision};${_mkl_common};mkl_sequential;mkl_core;mkl_blacs_${_mpi}_${_precision}"
+          "mkl_scalapack.h"
+          )
 
-	if(SCALAPACK_libraries AND _precision STREQUAL "ilp64")
-	  set_property(TARGET ${target} APPEND PROPERTY
-	    INTERFACE_COMPILE_DEFINITIONS MKL_ILP64}
-	    )
-	endif()
+        if(SCALAPACK_libraries AND _precision STREQUAL "ilp64")
+          set_property(TARGET ${target} APPEND PROPERTY
+            INTERFACE_COMPILE_DEFINITIONS MKL_ILP64}
+            )
+        endif()
 
-	if(EXISTS ${SCALAPACK_include_dir}/mkl_version.h)
-	  file(STRINGS ${SCALAPACK_include_dir}/mkl_version.h _versions
-	    REGEX "^#define\ +__INTEL_MKL(_MINOR|_UPDATE)?__ .*")
-	  foreach(_ver ${_versions})
-	    string(REGEX MATCH "__INTEL_MKL(_MINOR|_UPDATE)?__ *([0-9.]+)" _tmp "${_ver}")
-	    set(_mkl${CMAKE_MATCH_1} ${CMAKE_MATCH_2})
-	  endforeach()
-	  set(SCALAPACK_VERSION "mkl:${_mkl}.${_mkl_MINOR}.${_mkl_UPDATE}" CACHE INTERNAL "")
-	endif()
+        if(EXISTS ${SCALAPACK_include_dir}/mkl_version.h)
+          file(STRINGS ${SCALAPACK_include_dir}/mkl_version.h _versions
+            REGEX "^#define\ +__INTEL_MKL(_MINOR|_UPDATE)?__ .*")
+          foreach(_ver ${_versions})
+            string(REGEX MATCH "__INTEL_MKL(_MINOR|_UPDATE)?__ *([0-9.]+)" _tmp "${_ver}")
+            set(_mkl${CMAKE_MATCH_1} ${CMAKE_MATCH_2})
+          endforeach()
+          set(SCALAPACK_VERSION "mkl:${_mkl}.${_mkl_MINOR}.${_mkl_UPDATE}" CACHE INTERNAL "")
+        endif()
 
       endif()
     endif()
   endforeach()
 endforeach()
 
 set(SCALAPACK_LIBRARIES ${SCALAPACK_libraries} CACHE INTERNAL "")
 set(SCALAPACK_INCLUDE_DIR ${SCALAPACK_include_dir} CACHE INTERNAL "")
 
 #===============================================================================
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(ScaLAPACK
   REQUIRED_VARS SCALAPACK_LIBRARIES
   VERSION_VAR SCALAPACK_VERSION)
diff --git a/cmake/akantu_install_environement.csh.in b/cmake/akantu_install_environement.csh.in
index 83297ef39..20f0f3cc2 100644
--- a/cmake/akantu_install_environement.csh.in
+++ b/cmake/akantu_install_environement.csh.in
@@ -1,2 +1,2 @@
-setenv PYTHONPATH $PYTHONPATH:@AKANTU_PYTHON_INSTALL_PREFIX@/lib/python@PYTHON_VERSION_MAJOR@.@PYTHON_VERSION_MINOR@/site-packages
+setenv PYTHONPATH $PYTHONPATH:@AKANTU_PYTHON_INSTALL_PREFIX@/lib/python@Python_VERSION_MAJOR@.@Python_VERSION_MINOR@/site-packages
 setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:@CMAKE_INSTALL_PREFIX@/lib
diff --git a/cmake/akantu_install_environement.sh.in b/cmake/akantu_install_environement.sh.in
index b52cf6ca1..8efc0c49a 100644
--- a/cmake/akantu_install_environement.sh.in
+++ b/cmake/akantu_install_environement.sh.in
@@ -1,2 +1,2 @@
-export PYTHONPATH=$PYTHONPATH:@AKANTU_PYTHON_INSTALL_PREFIX@/lib/python@PYTHON_VERSION_MAJOR@.@PYTHON_VERSION_MINOR@/site-packages
+export PYTHONPATH=$PYTHONPATH:@AKANTU_PYTHON_INSTALL_PREFIX@/lib/python@Python_VERSION_MAJOR@.@Python_VERSION_MINOR@/site-packages
 export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:@CMAKE_INSTALL_PREFIX@/lib
diff --git a/cmake/akantu_version.py.in b/cmake/akantu_version.py.in
new file mode 100644
index 000000000..2cbc4dd6f
--- /dev/null
+++ b/cmake/akantu_version.py.in
@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+
+def get_version():
+    AKANTU_VERSION_MAJOR = @AKANTU_MAJOR_VERSION@
+    AKANTU_VERSION_MINOR = @AKANTU_MINOR_VERSION@
+    AKANTU_VERSION_PATCH = @AKANTU_PATCH_VERSION@
+    AKANTU_VERSION_PRERELEASE = '@AKANTU_PRERELASE_VERSION@'
+    AKANTU_VERSION_LOCAL = '@AKANTU_LOCAL_VERSION@'
+
+    return '{}.{}.{}{}{}'.format(
+        AKANTU_VERSION_MAJOR,
+        AKANTU_VERSION_MINOR,
+        AKANTU_VERSION_PATCH,
+        AKANTU_VERSION_PRERELEASE,
+        AKANTU_VERSION_LOCAL)
diff --git a/dev-requirements.txt b/dev-requirements.txt
new file mode 100644
index 000000000..6690d8e49
--- /dev/null
+++ b/dev-requirements.txt
@@ -0,0 +1,5 @@
+scikit-build
+pybind11
+numpy
+ninja
+cmake
diff --git a/examples/python/structural_mechanics/CMakeLists.txt b/examples/python/structural_mechanics/CMakeLists.txt
index cae0cc6c0..c7c2463a3 100644
--- a/examples/python/structural_mechanics/CMakeLists.txt
+++ b/examples/python/structural_mechanics/CMakeLists.txt
@@ -1,44 +1,44 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sat Mar 13 2021
 # @date last modification: Sun Mar 14 2021
 #
 # @brief  CMakeLists for structural mechanics examples
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
-register_example(structural_mechanics.py
+register_example(structural_mechanics
   SCRIPT structural_mechanics.py
   PYTHON
   )
 
-register_example(structural_mechanics_softening.py
+register_example(structural_mechanics_softening
   SCRIPT structural_mechanics_softening.py
   PYTHON
   )
 
-register_example(structural_mechanics_dynamics.py
+register_example(structural_mechanics_dynamics
   SCRIPT structural_mechanics_dynamics.py
   PYTHON
   )
diff --git a/extra_packages/igfem/src/solid_mechanics_model_igfem.cc b/extra_packages/igfem/src/solid_mechanics_model_igfem.cc
index 04d5a63d6..e6d1c34f1 100644
--- a/extra_packages/igfem/src/solid_mechanics_model_igfem.cc
+++ b/extra_packages/igfem/src/solid_mechanics_model_igfem.cc
@@ -1,583 +1,573 @@
 /**
  * @file   solid_mechanics_model_igfem.hh
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  *
  *
  * @brief  solid mechanics model for IGFEM analysis
  *
  *
  * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model_igfem.hh"
 #include "dumpable_inline_impl.hh"
 #include "group_manager_inline_impl.hh"
 #include "igfem_helper.hh"
 #include "material_igfem.hh"
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_igfem_element_partition.hh"
 #include "dumper_igfem_elemental_field.hh"
 #include "dumper_igfem_material_internal_field.hh"
 #include "dumper_material_padders.hh"
 #include "dumper_paraview.hh"
-#endif
 
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 const SolidMechanicsModelIGFEMOptions
     default_solid_mechanics_model_igfem_options(_static, false);
 
 SolidMechanicsModelIGFEM::SolidMechanicsModelIGFEM(Mesh & mesh, UInt dim,
                                                    const ID & id)
     : SolidMechanicsModel(mesh, dim, id), IGFEMEnrichment(mesh),
       global_ids_updater(NULL) {
   AKANTU_DEBUG_IN();
 
   delete material_selector;
   material_selector = new DefaultMaterialIGFEMSelector(*this);
 
   this->registerEventHandler(*this);
 
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("igfem elements", id);
   this->mesh.addDumpMeshToDumper("igfem elements", mesh, spatial_dimension,
                                  _not_ghost, _ek_igfem);
-#endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelIGFEM::~SolidMechanicsModelIGFEM() {
   AKANTU_DEBUG_IN();
   if (global_ids_updater)
     delete global_ids_updater;
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::initFull(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
   /// intialize the IGFEM enrichment
   this->initialize();
 
   SolidMechanicsModel::initFull(options);
 
   // set the initial condition to 0
   real_force->clear();
   real_displacement->clear();
   real_residual->clear();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Allocate all the needed vectors. By  default their are not necessarily set to
  * 0
  *
  */
 void SolidMechanicsModelIGFEM::initArrays() {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = mesh.getNbNodes();
   std::stringstream sstr_rdisp;
   sstr_rdisp << id << ":real_displacement";
   std::stringstream sstr_rforc;
   sstr_rforc << id << ":real_force";
   std::stringstream sstr_rresi;
   sstr_rresi << id << ":real_residual";
 
   real_displacement = &(alloc<Real>(sstr_rdisp.str(), nb_nodes,
                                     spatial_dimension, REAL_INIT_VALUE));
   real_force = &(alloc<Real>(sstr_rforc.str(), nb_nodes, spatial_dimension,
                              REAL_INIT_VALUE));
   real_residual = &(alloc<Real>(sstr_rresi.str(), nb_nodes, spatial_dimension,
                                 REAL_INIT_VALUE));
 
   SolidMechanicsModel::initArrays();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::initParallel(MeshPartition * partition,
                                             DataAccessor * data_accessor) {
   SolidMechanicsModel::initParallel(partition, data_accessor);
   this->intersector_sphere.setDistributedSynchronizer(synch_parallel);
   if (mesh.isDistributed())
     global_ids_updater = new GlobalIdsUpdater(mesh, synch_parallel);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::initMaterials() {
   AKANTU_DEBUG_IN();
 
   // make sure the material are instantiated
   if (!are_materials_instantiated)
     instantiateMaterials();
 
   /// find the first igfem material
   UInt igfem_index = 0;
 
   while ((dynamic_cast<MaterialIGFEM *>(materials[igfem_index]) == NULL) &&
          igfem_index <= materials.size())
     ++igfem_index;
 
   AKANTU_DEBUG_ASSERT(igfem_index != materials.size(),
                       "No igfem materials in the material input file");
 
   DefaultMaterialIGFEMSelector * igfem_mat_selector =
       dynamic_cast<DefaultMaterialIGFEMSelector *>(material_selector);
   if (igfem_mat_selector != NULL)
     igfem_mat_selector->setIGFEMFallback(igfem_index);
 
   SolidMechanicsModel::initMaterials();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the model, basically pre-compute the shapes, shapes derivatives
  * and jacobian
  *
  */
 void SolidMechanicsModelIGFEM::initModel() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel::initModel();
 
   registerFEEngineObject<MyFEEngineIGFEMType>("IGFEMFEEngine", mesh,
                                               spatial_dimension);
   /// insert the two feengines associated with the model in the map
   this->fe_engines_per_kind[_ek_regular] = &(this->getFEEngine());
   this->fe_engines_per_kind[_ek_igfem] = &(this->getFEEngine("IGFEMFEEngine"));
 
   /// add the igfem type connectivities
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
 
     GhostType type_ghost = *gt;
 
     Mesh::type_iterator it = mesh.firstType(spatial_dimension, type_ghost);
     Mesh::type_iterator last = mesh.lastType(spatial_dimension, type_ghost);
 
     for (; it != last; ++it) {
       const Array<UInt> & connectivity = mesh.getConnectivity(*it, type_ghost);
       if (connectivity.getSize() != 0) {
         ElementType type = *it;
         Vector<ElementType> types_igfem = FEEngine::getIGFEMElementTypes(type);
         for (UInt i = 0; i < types_igfem.size(); ++i)
           mesh.addConnectivityType(types_igfem(i), type_ghost);
       }
     }
   }
 
   getFEEngine("IGFEMFEEngine").initShapeFunctions(_not_ghost);
   getFEEngine("IGFEMFEEngine").initShapeFunctions(_ghost);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::onElementsAdded(const Array<Element> & elements,
                                                const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   const NewIGFEMElementsEvent * igfem_event =
       dynamic_cast<const NewIGFEMElementsEvent *>(&event);
   /// insert the new and old elements in the map
   if (igfem_event != NULL) {
     this->element_map.zero();
     const Array<Element> & old_elements = igfem_event->getOldElementsList();
     for (UInt e = 0; e < elements.getSize(); ++e) {
       this->element_map[elements(e)] = old_elements(e);
     }
   }
 
   /// update shape functions
   getFEEngine("IGFEMFEEngine").initShapeFunctions(_not_ghost);
   getFEEngine("IGFEMFEEngine").initShapeFunctions(_ghost);
 
   SolidMechanicsModel::onElementsAdded(elements, event);
   this->reassignMaterial();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::onElementsRemoved(
     const Array<Element> & element_list,
     const ElementTypeMapArray<UInt> & new_numbering,
     const RemovedElementsEvent & event) {
 
   this->getFEEngine("IGFEMFEEngine").initShapeFunctions(_not_ghost);
   this->getFEEngine("IGFEMFEEngine").initShapeFunctions(_ghost);
   SolidMechanicsModel::onElementsRemoved(element_list, new_numbering, event);
   if (synch_parallel)
     synch_parallel->computeAllBufferSizes(*this);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::onNodesAdded(const Array<UInt> & nodes_list,
                                             const NewNodesEvent & event) {
   AKANTU_DEBUG_IN();
 
   const NewIGFEMNodesEvent * igfem_event =
       dynamic_cast<const NewIGFEMNodesEvent *>(&event);
   // update the node type
   if (igfem_event != NULL) {
     intersector_sphere.updateNodeType(
         nodes_list, igfem_event->getNewNodePerElem(),
         igfem_event->getElementType(), igfem_event->getGhostType());
   }
 
   UInt nb_nodes = mesh.getNbNodes();
 
   if (real_displacement)
     real_displacement->resize(nb_nodes);
   if (real_force)
     real_force->resize(nb_nodes);
   if (real_residual)
     real_residual->resize(nb_nodes);
 
   if (mesh.isDistributed())
     mesh.getGlobalNodesIds().resize(mesh.getNbNodes());
 
   if (displacement)
     displacement->resize(nb_nodes);
   if (mass)
     mass->resize(nb_nodes);
   if (velocity)
     velocity->resize(nb_nodes);
   if (acceleration)
     acceleration->resize(nb_nodes);
   if (force)
     force->resize(nb_nodes);
   if (residual)
     residual->resize(nb_nodes);
   if (blocked_dofs)
     blocked_dofs->resize(nb_nodes);
 
   if (previous_displacement)
     previous_displacement->resize(nb_nodes);
   if (increment_acceleration)
     increment_acceleration->resize(nb_nodes);
   if (increment)
     increment->resize(nb_nodes);
 
   if (current_position)
     current_position->resize(nb_nodes);
 
   std::vector<Material *>::iterator mat_it;
   for (mat_it = materials.begin(); mat_it != materials.end(); ++mat_it) {
     (*mat_it)->onNodesAdded(nodes_list, event);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::onNodesRemoved(const Array<UInt> & nodes_list,
                                               const Array<UInt> & new_numbering,
                                               const RemovedNodesEvent & event) {
   if (real_displacement)
     mesh.removeNodesFromArray(*real_displacement, new_numbering);
   if (real_force)
     mesh.removeNodesFromArray(*real_force, new_numbering);
   if (real_residual)
     mesh.removeNodesFromArray(*real_residual, new_numbering);
 
   // communicate global connectivity for slave nodes
   if (global_ids_updater)
     global_ids_updater->updateGlobalIDs(
         mesh.getNbNodes() - intersector_sphere.getNbStandardNodes());
 
   SolidMechanicsModel::onNodesRemoved(nodes_list, new_numbering, event);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::addDumpGroupFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const std::string & group_name, ElementKind element_kind,
     bool padding_flag) {
   AKANTU_DEBUG_IN();
 
   ElementKind _element_kind = element_kind;
   if (dumper_name == "igfem elements") {
     _element_kind = _ek_igfem;
   }
 
   SolidMechanicsModel::addDumpGroupFieldToDumper(
       dumper_name, field_id, group_name, _element_kind, padding_flag);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::onDump() {
   this->computeValuesOnEnrichedNodes();
   this->flattenAllRegisteredInternals(_ek_igfem);
   SolidMechanicsModel::onDump();
 }
 
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
-
 dumpers::Field * SolidMechanicsModelIGFEM::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag, const UInt & spatial_dimension, ElementKind kind) {
 
   dumpers::Field * field = NULL;
 
   if (kind != _ek_igfem)
     field = SolidMechanicsModel::createElementalField(
         field_name, group_name, padding_flag, spatial_dimension, kind);
 
   else {
 
     if (field_name == "partitions")
       field =
           mesh.createElementalField<UInt, dumpers::IGFEMElementPartitionField>(
               mesh.getConnectivities(), group_name, spatial_dimension, kind);
     else if (field_name == "material_index")
       field =
           mesh.createElementalField<UInt, Vector, dumpers::IGFEMElementalField>(
               material_index, group_name, spatial_dimension, kind);
     else {
       // this copy of field_name is used to compute derivated data such as
       // strain and von mises stress that are based on grad_u and stress
       std::string field_name_copy(field_name);
 
       if (field_name == "strain" || field_name == "Green strain" ||
           field_name == "principal strain" ||
           field_name == "principal Green strain")
         field_name_copy = "grad_u";
       else if (field_name == "Von Mises stress")
         field_name_copy = "stress";
 
       bool is_internal = this->isInternal(field_name_copy, kind);
 
       if (is_internal) {
         ElementTypeMap<UInt> nb_data_per_elem =
             this->getInternalDataPerElem(field_name_copy, kind);
         ElementTypeMapArray<Real> & internal_flat =
             this->flattenInternal(field_name_copy, kind);
         field = mesh.createElementalField<Real,
                                           dumpers::IGFEMInternalMaterialField>(
             internal_flat, group_name, spatial_dimension, kind,
             nb_data_per_elem);
         if (field_name == "strain") {
           dumpers::ComputeStrain<false> * foo =
               new dumpers::ComputeStrain<false>(*this);
           field = dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
         } else if (field_name == "Von Mises stress") {
           dumpers::ComputeVonMisesStress * foo =
               new dumpers::ComputeVonMisesStress(*this);
           field = dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
         } else if (field_name == "Green strain") {
           dumpers::ComputeStrain<true> * foo =
               new dumpers::ComputeStrain<true>(*this);
           field = dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
         } else if (field_name == "principal strain") {
           dumpers::ComputePrincipalStrain<false> * foo =
               new dumpers::ComputePrincipalStrain<false>(*this);
           field = dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
         } else if (field_name == "principal Green strain") {
           dumpers::ComputePrincipalStrain<true> * foo =
               new dumpers::ComputePrincipalStrain<true>(*this);
           field = dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
         }
 
         /// treat the paddings
         if (padding_flag) {
           if (field_name == "stress") {
             if (spatial_dimension == 2) {
               dumpers::StressPadder<2> * foo =
                   new dumpers::StressPadder<2>(*this);
               field =
                   dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
             }
           } else if (field_name == "strain" || field_name == "Green strain") {
             if (spatial_dimension == 2) {
               dumpers::StrainPadder<2> * foo =
                   new dumpers::StrainPadder<2>(*this);
               field =
                   dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
             }
           }
         }
         // homogenize the field
         dumpers::ComputeFunctorInterface * foo =
             dumpers::HomogenizerProxy::createHomogenizer(*field);
 
         field = dumpers::FieldComputeProxy::createFieldCompute(field, *foo);
       }
     }
   }
   //  }
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
-
 dumpers::Field *
 SolidMechanicsModelIGFEM::createNodalFieldReal(const std::string & field_name,
                                                const std::string & group_name,
                                                bool padding_flag) {
-
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["real_displacement"] = real_displacement;
 
   dumpers::Field * field = NULL;
   if (padding_flag)
     field = mesh.createNodalField(real_nodal_fields[field_name], group_name, 3);
   else
     field = mesh.createNodalField(real_nodal_fields[field_name], group_name);
 
   if (field == NULL)
     return SolidMechanicsModel::createNodalFieldReal(field_name, group_name,
                                                      padding_flag);
 
   return field;
 }
 
 #else
 /* -------------------------------------------------------------------------- */
 dumpers::Field * SolidMechanicsModelIGFEM::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag, const UInt & spatial_dimension, ElementKind kind) {
   return NULL;
 }
 
 /* -------------------------------------------------------------------------- */
-
 dumpers::Field *
 SolidMechanicsModelIGFEM::createNodalFieldReal(const std::string & field_name,
                                                const std::string & group_name,
                                                bool padding_flag) {
   return NULL;
 }
 
-#endif
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::computeValuesOnEnrichedNodes() {
-
   for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
     for (UInt s = 0; s < spatial_dimension; ++s)
       (*real_displacement)(n, s) = (*displacement)(n, s);
   }
 
   Element element;
   Vector<Real> real_coords(spatial_dimension);
   Vector<Real> interpolated(spatial_dimension);
   Array<Real>::const_vector_iterator r_displ_it =
       this->real_displacement->begin(spatial_dimension);
 
   for (ghost_type_t::iterator gt = ghost_type_t::begin();
        gt != ghost_type_t::end(); ++gt) {
     element.ghost_type = *gt;
     Mesh::type_iterator it = mesh.firstType(spatial_dimension, *gt, _ek_igfem);
     Mesh::type_iterator last = mesh.lastType(spatial_dimension, *gt, _ek_igfem);
     for (; it != last; ++it) {
       element.type = *it;
       UInt nb_element = mesh.getNbElement(*it, *gt);
       if (!nb_element)
         continue;
       UInt * elem_val = mesh.getConnectivity(*it, *gt).storage();
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(*it);
       Matrix<Real> nodes_coord(spatial_dimension, nb_nodes_per_element);
       Matrix<Real> displ_val(spatial_dimension, nb_nodes_per_element);
 
       UInt nb_enriched_nodes = IGFEMHelper::getNbEnrichedNodes(*it);
       UInt nb_parent_nodes = IGFEMHelper::getNbParentNodes(*it);
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = el;
         /// get the node coordinates of the element
         mesh.extractNodalValuesFromElement(
             mesh.getNodes(), nodes_coord.storage(),
             elem_val + el * nb_nodes_per_element, nb_nodes_per_element,
             spatial_dimension);
 
         /// get the displacement values at the nodes of the element
         mesh.extractNodalValuesFromElement(
             *(this->displacement), displ_val.storage(),
             elem_val + el * nb_nodes_per_element, nb_nodes_per_element,
             spatial_dimension);
 
         for (UInt i = 0; i < nb_enriched_nodes; ++i) {
           /// coordinates of enriched node
           real_coords = nodes_coord(nb_parent_nodes + i);
           /// global index of the enriched node
           UInt idx = elem_val[el * nb_nodes_per_element + nb_parent_nodes + i];
           /// compute the real displacement value
           this->getFEEngine("IGFEMFEEngine")
               .interpolate(real_coords, displ_val, interpolated, element);
           r_displ_it[idx] = interpolated;
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::transferInternalValues(
     const ID & internal, std::vector<Element> & new_elements,
     Array<Real> & added_quads, Array<Real> & internal_values) {
 
   /// @todo sort the new elements by their corresponding old element type and
   /// old material!!!
 
   /// get the number of elements for which iternals need to be transfered
   UInt nb_new_elements = new_elements.size();
   UInt nb_new_quads = added_quads.getSize() / nb_new_elements;
 
   Array<Real>::const_matrix_iterator quad_coords =
       added_quads.begin_reinterpret(this->spatial_dimension, nb_new_quads,
                                     nb_new_elements);
   UInt nb_internal_component = internal_values.getNbComponent();
   Array<Real>::matrix_iterator internal_val = internal_values.begin_reinterpret(
       nb_internal_component, nb_new_quads, nb_new_elements);
   Vector<Real> default_values(nb_internal_component, 0.);
 
   for (UInt e = 0; e < nb_new_elements; ++e, ++quad_coords, ++internal_val) {
     Element new_element = new_elements[e];
     Element old_element = this->element_map[new_element];
     UInt mat_idx = (this->material_index(
         old_element.type, old_element.ghost_type))(old_element.element);
     Material & old_material = *(this->materials[mat_idx]);
     old_material.extrapolateInternal(internal, old_element, *quad_coords,
                                      *internal_val);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelIGFEM::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");
   std::vector<Material *>::iterator mat_it;
   for (mat_it = this->materials.begin(); mat_it != this->materials.end();
        ++mat_it) {
     MaterialIGFEM * mat_igfem = dynamic_cast<MaterialIGFEM *>(*mat_it);
     if (mat_igfem != NULL)
       mat_igfem->applyEigenGradU(prescribed_eigen_grad_u, material_name,
                                  ghost_type);
     else if ((*mat_it)->getName() == material_name)
       (*mat_it)->applyEigenGradU(prescribed_eigen_grad_u, ghost_type);
   }
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_coulomb_tmpl.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_coulomb_tmpl.hh
index 29259fa32..5ffe63414 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_coulomb_tmpl.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_coulomb_tmpl.hh
@@ -1,168 +1,162 @@
 /**
  * @file   ntn_friclaw_coulomb_tmpl.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Fri Jul 19 2019
  *
  * @brief  implementation of coulomb friction
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_nodal_field.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 NTNFricLawCoulomb<Regularisation>::NTNFricLawCoulomb(NTNBaseContact & contact,
                                                      const ID & id)
     : Regularisation(contact, id), mu(0, 1, 0., id + ":mu", 0., "mu") {
   AKANTU_DEBUG_IN();
 
   Regularisation::registerSynchronizedArray(this->mu);
 
   this->registerParam("mu", this->mu, _pat_parsmod, "friction coefficient");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawCoulomb<Regularisation>::computeFrictionalStrength() {
   AKANTU_DEBUG_IN();
 
   // get contact arrays
   const SynchronizedArray<bool> & is_in_contact =
       this->internalGetIsInContact();
   const SynchronizedArray<Real> & pressure = this->internalGetContactPressure();
 
   // array to fill
   SynchronizedArray<Real> & strength = this->internalGetFrictionalStrength();
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // node pair is NOT in contact
     if (!is_in_contact(n)) {
       strength(n) = 0.;
 
       // node pair is in contact
     } else {
       // compute frictional strength
       strength(n) = this->mu(n) * pressure(n);
     }
   }
 
   Regularisation::computeFrictionalStrength();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawCoulomb<Regularisation>::registerSynchronizedArray(
     SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->mu.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawCoulomb<Regularisation>::dumpRestart(
     const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->mu.dumpRestartFile(file_name);
 
   Regularisation::dumpRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawCoulomb<Regularisation>::readRestart(
     const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->mu.readRestartFile(file_name);
 
   Regularisation::readRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawCoulomb<Regularisation>::printself(std::ostream & stream,
                                                   int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNFricLawCoulomb [" << std::endl;
   Regularisation::printself(stream, ++indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawCoulomb<Regularisation>::addDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
-  //  const SynchronizedArray<UInt> * nodal_filter =
-  //  &(this->contact.getSlaves());
-
   if (field_id == "mu") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->mu.getArray()));
   }
   /*
   else if (field_id == "frictional_contact_pressure") {
     this->internalAddDumpFieldToDumper(dumper_name,
                        field_id,
                        new
   DumperIOHelper::NodalField<Real>(this->frictional_contact_pressure.getArray()));
   }
   */
   else {
     Regularisation::addDumpFieldToDumper(dumper_name, field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive_tmpl.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive_tmpl.hh
index 66d45c5f6..037c9c490 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive_tmpl.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_cohesive_tmpl.hh
@@ -1,190 +1,184 @@
 /**
  * @file   ntn_friclaw_linear_cohesive_tmpl.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Fri Jul 19 2019
  *
  * @brief  implementation of linear cohesive law
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 //#include "dumper_text.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 NTNFricLawLinearCohesive<Regularisation>::NTNFricLawLinearCohesive(
     NTNBaseContact & contact, const ID & id)
     : Regularisation(contact, id), G_c(0, 1, 0., id + ":G_c", 0., "G_c"),
       tau_c(0, 1, 0., id + ":tau_c", 0., "tau_c"),
       tau_r(0, 1, 0., id + ":tau_r", 0., "tau_r") {
   AKANTU_DEBUG_IN();
 
   Regularisation::registerSynchronizedArray(this->G_c);
   Regularisation::registerSynchronizedArray(this->tau_c);
   Regularisation::registerSynchronizedArray(this->tau_r);
 
   this->registerParam("G_c", this->G_c, _pat_parsmod, "fracture energy");
   this->registerParam("tau_c", this->tau_c, _pat_parsmod,
                       "peak shear strength");
   this->registerParam("tau_r", this->tau_r, _pat_parsmod,
                       "residual shear strength");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearCohesive<Regularisation>::computeFrictionalStrength() {
   AKANTU_DEBUG_IN();
 
   // get arrays
   const SynchronizedArray<bool> & is_in_contact =
       this->internalGetIsInContact();
   // const SynchronizedArray<Real> & slip  = this->internalGetSlip();
   const SynchronizedArray<Real> & slip = this->internalGetCumulativeSlip();
 
   // array to fill
   SynchronizedArray<Real> & strength = this->internalGetFrictionalStrength();
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // node pair is NOT in contact
     if (!is_in_contact(n)) {
       strength(n) = 0.;
 
       // node pair is in contact
     } else {
       if (this->G_c(n) == 0.) {
         // strength(n) = 0.;
         strength(n) = this->tau_r(n);
       } else {
         Real slope = (this->tau_c(n) - this->tau_r(n)) *
                      (this->tau_c(n) - this->tau_r(n)) / (2 * this->G_c(n));
         // no strength < tau_r
         strength(n) =
             std::max(this->tau_c(n) - slope * slip(n), this->tau_r(n));
         // strength(n) = std::max(this->tau_c(n) - slope * slip(n), 0.); // no
         // negative strength
       }
     }
   }
 
   Regularisation::computeFrictionalStrength();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearCohesive<Regularisation>::registerSynchronizedArray(
     SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->G_c.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearCohesive<Regularisation>::dumpRestart(
     const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->G_c.dumpRestartFile(file_name);
   this->tau_c.dumpRestartFile(file_name);
   this->tau_r.dumpRestartFile(file_name);
 
   Regularisation::dumpRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearCohesive<Regularisation>::readRestart(
     const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->G_c.readRestartFile(file_name);
   this->tau_c.readRestartFile(file_name);
   this->tau_r.readRestartFile(file_name);
 
   Regularisation::readRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearCohesive<Regularisation>::printself(std::ostream & stream,
                                                          int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNFricLawLinearCohesive [" << std::endl;
   Regularisation::printself(stream, ++indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearCohesive<Regularisation>::addDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
-  //  const SynchronizedArray<UInt> * nodal_filter =
-  //  &(this->contact.getSlaves());
-
   if (field_id == "G_c") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->G_c.getArray()));
   } else if (field_id == "tau_c") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->tau_c.getArray()));
   } else if (field_id == "tau_r") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->tau_r.getArray()));
   } else {
     Regularisation::addDumpFieldToDumper(dumper_name, field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_slip_weakening_tmpl.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_slip_weakening_tmpl.hh
index 5101a1d16..1ced8d969 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_slip_weakening_tmpl.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_laws/ntn_friclaw_linear_slip_weakening_tmpl.hh
@@ -1,192 +1,186 @@
 /**
  * @file   ntn_friclaw_linear_slip_weakening_tmpl.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Fri Jul 19 2019
  *
  * @brief  implementation of linear slip weakening
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_text.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 NTNFricLawLinearSlipWeakening<Regularisation>::NTNFricLawLinearSlipWeakening(
     NTNBaseContact & contact, const ID & id)
     : NTNFricLawCoulomb<Regularisation>(contact, id),
       mu_s(0, 1, 0., id + ":mu_s", 0., "mu_s"),
       mu_k(0, 1, 0., id + ":mu_k", 0., "mu_k"),
       d_c(0, 1, 0., id + ":d_c", 0., "d_c") {
   AKANTU_DEBUG_IN();
 
   NTNFricLawCoulomb<Regularisation>::registerSynchronizedArray(this->mu_s);
   NTNFricLawCoulomb<Regularisation>::registerSynchronizedArray(this->mu_k);
   NTNFricLawCoulomb<Regularisation>::registerSynchronizedArray(this->d_c);
 
   this->registerParam("mu_s", this->mu_s, _pat_parsmod,
                       "static friction coefficient");
   this->registerParam("mu_k", this->mu_k, _pat_parsmod,
                       "kinetic friction coefficient");
   this->registerParam("d_c", this->d_c, _pat_parsmod, "slip weakening length");
 
   this->setParameterAccessType("mu", _pat_readable);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearSlipWeakening<
     Regularisation>::computeFrictionalStrength() {
   AKANTU_DEBUG_IN();
 
   computeFrictionCoefficient();
   NTNFricLawCoulomb<Regularisation>::computeFrictionalStrength();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearSlipWeakening<
     Regularisation>::computeFrictionCoefficient() {
   AKANTU_DEBUG_IN();
 
   // get arrays
   const SynchronizedArray<bool> & stick = this->internalGetIsSticking();
   const SynchronizedArray<Real> & slip = this->internalGetSlip();
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     if (stick(n)) {
       this->mu(n) = this->mu_s(n);
     } else {
       if (slip(n) >= this->d_c(n)) {
         this->mu(n) = this->mu_k(n);
       } else {
         // mu = mu_k + (1 - slip / Dc) * (mu_s - mu_k)
         this->mu(n) = this->mu_k(n) + (1 - (slip(n) / this->d_c(n))) *
                                           (this->mu_s(n) - this->mu_k(n));
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearSlipWeakening<Regularisation>::registerSynchronizedArray(
     SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->mu_s.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearSlipWeakening<Regularisation>::dumpRestart(
     const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->mu_s.dumpRestartFile(file_name);
   this->mu_k.dumpRestartFile(file_name);
   this->d_c.dumpRestartFile(file_name);
 
   NTNFricLawCoulomb<Regularisation>::dumpRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearSlipWeakening<Regularisation>::readRestart(
     const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->mu_s.readRestartFile(file_name);
   this->mu_k.readRestartFile(file_name);
   this->d_c.readRestartFile(file_name);
 
   NTNFricLawCoulomb<Regularisation>::readRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearSlipWeakening<Regularisation>::printself(
     std::ostream & stream, int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNFricLawLinearSlipWeakening [" << std::endl;
   NTNFricLawCoulomb<Regularisation>::printself(stream, ++indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class Regularisation>
 void NTNFricLawLinearSlipWeakening<Regularisation>::addDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
-  //  const SynchronizedArray<UInt> * nodal_filter =
-  //  &(this->contact.getSlaves());
-
   if (field_id == "mu_s") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->mu_s.getArray()));
   } else if (field_id == "mu_k") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->mu_k.getArray()));
   } else if (field_id == "d_c") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->d_c.getArray()));
   } else {
     NTNFricLawCoulomb<Regularisation>::addDumpFieldToDumper(dumper_name,
                                                             field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_no_regularisation.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_no_regularisation.cc
index 956812e85..d6b69d742 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_no_regularisation.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_no_regularisation.cc
@@ -1,170 +1,164 @@
 /**
  * @file   ntn_fricreg_no_regularisation.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Fri Jul 19 2019
  *
  * @brief  implementation of no regularisation
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_fricreg_no_regularisation.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_text.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NTNFricRegNoRegularisation::NTNFricRegNoRegularisation(NTNBaseContact & contact,
                                                        const ID & id)
     : NTNBaseFriction(contact, id),
       frictional_contact_pressure(0, 1, 0., id + ":frictional_contact_pressure",
                                   0., "frictional_contact_pressure") {
   AKANTU_DEBUG_IN();
 
   NTNBaseFriction::registerSynchronizedArray(this->frictional_contact_pressure);
 
   this->registerParam("frictional_contact_pressure",
                       this->frictional_contact_pressure, _pat_internal,
                       "contact pressure used for friction law");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 const SynchronizedArray<Real> &
 NTNFricRegNoRegularisation::internalGetContactPressure() {
   AKANTU_DEBUG_IN();
 
   this->computeFrictionalContactPressure();
 
   AKANTU_DEBUG_OUT();
   return this->frictional_contact_pressure;
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegNoRegularisation::computeFrictionalContactPressure() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel & model = this->contact.getModel();
   UInt dim = model.getSpatialDimension();
 
   // get contact arrays
   const SynchronizedArray<bool> & is_in_contact =
       this->internalGetIsInContact();
   const Array<Real> & pressure = this->contact.getContactPressure().getArray();
   Array<Real>::const_iterator<Vector<Real>> it = pressure.begin(dim);
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // node pair is NOT in contact
     if (!is_in_contact(n)) {
       this->frictional_contact_pressure(n) = 0.;
 
       // node pair is in contact
     } else {
       // compute frictional contact pressure
       const Vector<Real> & pres = it[n];
       this->frictional_contact_pressure(n) = pres.norm();
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegNoRegularisation::registerSynchronizedArray(
     SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->frictional_contact_pressure.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegNoRegularisation::dumpRestart(
     const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->frictional_contact_pressure.dumpRestartFile(file_name);
 
   NTNBaseFriction::dumpRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegNoRegularisation::readRestart(const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->frictional_contact_pressure.readRestartFile(file_name);
 
   NTNBaseFriction::readRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegNoRegularisation::printself(std::ostream & stream,
                                            int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNFricRegNoRegularisation [" << std::endl;
   NTNBaseFriction::printself(stream, ++indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegNoRegularisation::addDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
-  //  const SynchronizedArray<UInt> * nodal_filter =
-  //  &(this->contact.getSlaves());
-
   if (field_id == "frictional_contact_pressure") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(
             this->frictional_contact_pressure.getArray()));
   } else {
     NTNBaseFriction::addDumpFieldToDumper(dumper_name, field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.cc
index ba84f90f1..9498816f4 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_rubin_ampuero.cc
@@ -1,177 +1,171 @@
 /**
  * @file   ntn_fricreg_rubin_ampuero.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Fri Jul 19 2019
  *
  * @brief  implementation of no regularisation
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_fricreg_rubin_ampuero.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_text.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NTNFricRegRubinAmpuero::NTNFricRegRubinAmpuero(NTNBaseContact & contact,
                                                const ID & id)
     : NTNFricRegNoRegularisation(contact, id),
       t_star(0, 1, 0., id + ":t_star", 0., "t_star") {
   AKANTU_DEBUG_IN();
 
   NTNFricRegNoRegularisation::registerSynchronizedArray(this->t_star);
 
   this->registerParam("t_star", this->t_star, _pat_parsmod,
                       "time scale of regularization");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 const SynchronizedArray<Real> &
 NTNFricRegRubinAmpuero::internalGetContactPressure() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel & model = this->contact.getModel();
   UInt dim = model.getSpatialDimension();
   Real delta_t = model.getTimeStep();
 
   // get contact arrays
   const SynchronizedArray<bool> & is_in_contact =
       this->internalGetIsInContact();
   const Array<Real> & pressure = this->contact.getContactPressure().getArray();
   Array<Real>::const_iterator<Vector<Real>> it = pressure.begin(dim);
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // node pair is NOT in contact
     if (!is_in_contact(n)) {
       this->frictional_contact_pressure(n) = 0.;
 
       // if t_star is too small compute like Coulomb friction (without
       // regularization)
     } else if (Math::are_float_equal(this->t_star(n), 0.)) {
       const Vector<Real> & pres = it[n];
       this->frictional_contact_pressure(n) = pres.norm();
     }
 
     else {
       // compute frictional contact pressure
       // backward euler method: first order implicit numerical integration
       // method
       // \reg_pres_n+1 = (\reg_pres_n + \delta_t / \t_star * \cur_pres)
       //               / (1 + \delta_t / \t_star)
       Real alpha = delta_t / this->t_star(n);
       const Vector<Real> & pres = it[n];
       this->frictional_contact_pressure(n) += alpha * pres.norm();
       this->frictional_contact_pressure(n) /= 1 + alpha;
     }
   }
 
   AKANTU_DEBUG_OUT();
   return this->frictional_contact_pressure;
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegRubinAmpuero::setToSteadyState() {
   AKANTU_DEBUG_IN();
   NTNFricRegNoRegularisation::computeFrictionalContactPressure();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegRubinAmpuero::registerSynchronizedArray(
     SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->t_star.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegRubinAmpuero::dumpRestart(const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->t_star.dumpRestartFile(file_name);
 
   NTNFricRegNoRegularisation::dumpRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegRubinAmpuero::readRestart(const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->t_star.readRestartFile(file_name);
 
   NTNFricRegNoRegularisation::readRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegRubinAmpuero::printself(std::ostream & stream,
                                        int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNFricRegRubinAmpuero [" << std::endl;
   NTNFricRegNoRegularisation::printself(stream, ++indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegRubinAmpuero::addDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
-  //  const SynchronizedArray<UInt> * nodal_filter =
-  //  &(this->contact.getSlaves());
-
   if (field_id == "t_star") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->t_star.getArray()));
   } else {
     NTNFricRegNoRegularisation::addDumpFieldToDumper(dumper_name, field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_simplified_prakash_clifton.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_simplified_prakash_clifton.cc
index c922aa14f..165f83e72 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_simplified_prakash_clifton.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/friction_regularisations/ntn_fricreg_simplified_prakash_clifton.cc
@@ -1,165 +1,159 @@
 /**
  * @file   ntn_fricreg_simplified_prakash_clifton.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Fri Jul 19 2019
  *
  * @brief  implementation of simplified prakash clifton with one parameter
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_fricreg_simplified_prakash_clifton.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_text.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NTNFricRegSimplifiedPrakashClifton::NTNFricRegSimplifiedPrakashClifton(
     NTNBaseContact & contact, const ID & id)
     : NTNFricRegNoRegularisation(contact, id),
       t_star(0, 1, 0., id + ":t_star", 0., "t_star"),
       spc_internal(0, 1, 0., id + ":spc_internal", 0., "spc_internal") {
   AKANTU_DEBUG_IN();
 
   NTNFricRegNoRegularisation::registerSynchronizedArray(this->t_star);
   NTNFricRegNoRegularisation::registerSynchronizedArray(this->spc_internal);
 
   this->registerParam("t_star", this->t_star, _pat_parsmod,
                       "time scale of regularisation");
   this->registerParam("spc_internal", this->spc_internal, _pat_internal, "");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegSimplifiedPrakashClifton::computeFrictionalStrength() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel & model = this->contact.getModel();
   Real delta_t = model.getTimeStep();
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     Real alpha = delta_t / this->t_star(n);
     this->frictional_strength(n) += alpha * this->spc_internal(n);
     this->frictional_strength(n) /= 1 + alpha;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegSimplifiedPrakashClifton::setToSteadyState() {
   AKANTU_DEBUG_IN();
 
   /// fill the spc_internal array
   computeFrictionalStrength();
 
   /// set strength without regularisation
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     this->frictional_strength(n) = this->spc_internal(n);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegSimplifiedPrakashClifton::registerSynchronizedArray(
     SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->t_star.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegSimplifiedPrakashClifton::dumpRestart(
     const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->t_star.dumpRestartFile(file_name);
   this->spc_internal.dumpRestartFile(file_name);
 
   NTNFricRegNoRegularisation::dumpRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegSimplifiedPrakashClifton::readRestart(
     const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->t_star.readRestartFile(file_name);
   this->spc_internal.readRestartFile(file_name);
 
   NTNFricRegNoRegularisation::readRestart(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegSimplifiedPrakashClifton::printself(std::ostream & stream,
                                                    int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNFricRegSimplifiedPrakashClifton [" << std::endl;
   NTNFricRegNoRegularisation::printself(stream, ++indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNFricRegSimplifiedPrakashClifton::addDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
-  //  const SynchronizedArray<UInt> * nodal_filter =
-  //  &(this->contact.getSlaves());
-
   if (field_id == "t_star") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->t_star.getArray()));
   } else {
     NTNFricRegNoRegularisation::addDumpFieldToDumper(dumper_name, field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_contact.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_contact.cc
index 1051b1817..37c58e56f 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_contact.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_contact.cc
@@ -1,569 +1,567 @@
 /**
  * @file   ntn_base_contact.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  implementation of ntn base contact
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "ntn_base_contact.hh"
 #include "dof_manager_default.hh"
 #include "dumpable_inline_impl.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_text.hh"
 #include "element_synchronizer.hh"
 #include "mesh_utils.hh"
 #include "non_linear_solver_lumped.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 // NTNContactSynchElementFilter::NTNContactSynchElementFilter(
 //     NTNBaseContact & contact)
 //     : contact(contact),
 //       connectivity(contact.getModel().getMesh().getConnectivities()) {
 //   AKANTU_DEBUG_IN();
 
 //   AKANTU_DEBUG_OUT();
 // }
 
 /* -------------------------------------------------------------------------- */
 // bool NTNContactSynchElementFilter::operator()(const Element & e) {
 //   AKANTU_DEBUG_IN();
 
 //   ElementType type = e.type;
 //   UInt element = e.element;
 //   GhostType ghost_type = e.ghost_type;
 
 //   // loop over all nodes of this element
 //   bool need_element = false;
 //   UInt nb_nodes = Mesh::getNbNodesPerElement(type);
 //   for (UInt n = 0; n < nb_nodes; ++n) {
 //     UInt nn = this->connectivity(type, ghost_type)(element, n);
 
 //     // if one nodes is in this contact, we need this element
 //     if (this->contact.getNodeIndex(nn) >= 0) {
 //       need_element = true;
 //       break;
 //     }
 //   }
 
 //   AKANTU_DEBUG_OUT();
 //   return need_element;
 // }
 
 /* -------------------------------------------------------------------------- */
 NTNBaseContact::NTNBaseContact(SolidMechanicsModel & model, const ID & id)
     : id(id), model(model),
       slaves(0, 1, 0, id + ":slaves", std::numeric_limits<UInt>::quiet_NaN(),
              "slaves"),
       normals(0, model.getSpatialDimension(), 0, id + ":normals",
               std::numeric_limits<Real>::quiet_NaN(), "normals"),
       contact_pressure(
           0, model.getSpatialDimension(), 0, id + ":contact_pressure",
           std::numeric_limits<Real>::quiet_NaN(), "contact_pressure"),
       is_in_contact(0, 1, false, id + ":is_in_contact", false, "is_in_contact"),
       lumped_boundary_slaves(0, 1, 0, id + ":lumped_boundary_slaves",
                              std::numeric_limits<Real>::quiet_NaN(),
                              "lumped_boundary_slaves"),
       impedance(0, 1, 0, id + ":impedance",
                 std::numeric_limits<Real>::quiet_NaN(), "impedance"),
       slave_elements("slave_elements", id) {
   AKANTU_DEBUG_IN();
 
   auto & boundary_fem = this->model.getFEEngineBoundary();
   for (auto && ghost_type : ghost_types) {
     boundary_fem.initShapeFunctions(ghost_type);
   }
 
   auto & mesh = this->model.getMesh();
   auto spatial_dimension = this->model.getSpatialDimension();
 
   this->slave_elements.initialize(mesh,
                                   _spatial_dimension = spatial_dimension - 1);
 
   MeshUtils::buildNode2Elements(mesh, this->node_to_elements,
                                 spatial_dimension - 1);
 
   this->registerDumper<DumperText>("text_all", id, true);
   this->addDumpFilteredMesh(mesh, slave_elements, slaves.getArray(),
                             spatial_dimension - 1, _not_ghost, _ek_regular);
 
   // parallelisation
   this->synch_registry = std::make_unique<SynchronizerRegistry>();
   this->synch_registry->registerDataAccessor(*this);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 NTNBaseContact::~NTNBaseContact() = default;
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::initParallel() {
   AKANTU_DEBUG_IN();
 
   this->synchronizer = std::make_unique<ElementSynchronizer>(
       this->model.getMesh().getElementSynchronizer());
 
   this->synchronizer->filterScheme([&](auto && element) {
     // loop over all nodes of this element
     Vector<UInt> conn = const_cast<const Mesh &>(this->model.getMesh())
                             .getConnectivity(element);
     for (auto & node : conn) {
       // if one nodes is in this contact, we need this element
       if (this->getNodeIndex(node) >= 0) {
         return true;
       }
     }
     return false;
   });
 
   this->synch_registry->registerSynchronizer(*(this->synchronizer),
                                              SynchronizationTag::_cf_nodal);
   this->synch_registry->registerSynchronizer(*(this->synchronizer),
                                              SynchronizationTag::_cf_incr);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::findBoundaryElements(
     const Array<UInt> & interface_nodes, ElementTypeMapArray<UInt> & elements) {
   AKANTU_DEBUG_IN();
 
   // add connected boundary elements that have all nodes on this contact
   for (const auto & node : interface_nodes) {
     for (const auto & element : this->node_to_elements.getRow(node)) {
       Vector<UInt> conn = const_cast<const Mesh &>(this->model.getMesh())
                               .getConnectivity(element);
       auto nb_nodes = conn.size();
       decltype(nb_nodes) nb_found_nodes = 0;
 
       for (auto & nn : conn) {
         if (interface_nodes.find(nn) != UInt(-1)) {
           nb_found_nodes++;
         } else {
           break;
         }
       }
 
       // this is an element between all contact nodes
       // and is not already in the elements
       if ((nb_found_nodes == nb_nodes) &&
           (elements(element.type, element.ghost_type).find(element.element) ==
            UInt(-1))) {
         elements(element.type, element.ghost_type).push_back(element.element);
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::addSplitNode(UInt node, UInt /*unused*/) {
   AKANTU_DEBUG_IN();
 
   UInt dim = this->model.getSpatialDimension();
 
   // add to node arrays
   this->slaves.push_back(node);
 
   // set contact as false
   this->is_in_contact.push_back(false);
 
   // before initializing
   // set contact pressure, normal, lumped_boundary to Nan
   this->contact_pressure.push_back(std::numeric_limits<Real>::quiet_NaN());
   this->impedance.push_back(std::numeric_limits<Real>::quiet_NaN());
   this->lumped_boundary_slaves.push_back(
       std::numeric_limits<Real>::quiet_NaN());
 
   Vector<Real> nan_normal(dim, std::numeric_limits<Real>::quiet_NaN());
   this->normals.push_back(nan_normal);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::registerSynchronizedArray(SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->slaves.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::dumpRestart(const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->slaves.dumpRestartFile(file_name);
   this->normals.dumpRestartFile(file_name);
   this->is_in_contact.dumpRestartFile(file_name);
   this->contact_pressure.dumpRestartFile(file_name);
   this->lumped_boundary_slaves.dumpRestartFile(file_name);
   this->impedance.dumpRestartFile(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::readRestart(const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->slaves.readRestartFile(file_name);
   this->normals.readRestartFile(file_name);
   this->is_in_contact.readRestartFile(file_name);
   this->contact_pressure.readRestartFile(file_name);
   this->lumped_boundary_slaves.readRestartFile(file_name);
   this->impedance.readRestartFile(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt NTNBaseContact::getNbNodesInContact() const {
   AKANTU_DEBUG_IN();
 
   UInt nb_contact = 0;
 
   UInt nb_nodes = this->getNbContactNodes();
   const Mesh & mesh = this->model.getMesh();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     bool is_local_node = mesh.isLocalOrMasterNode(this->slaves(n));
     bool is_pbc_slave_node = mesh.isPeriodicSlave(this->slaves(n));
     if (is_local_node && !is_pbc_slave_node && this->is_in_contact(n)) {
       nb_contact++;
     }
   }
 
   mesh.getCommunicator().allReduce(nb_contact, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return nb_contact;
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::updateInternalData() {
   AKANTU_DEBUG_IN();
 
   updateNormals();
   updateLumpedBoundary();
   updateImpedance();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::updateLumpedBoundary() {
   AKANTU_DEBUG_IN();
 
   this->internalUpdateLumpedBoundary(this->slaves.getArray(),
                                      this->slave_elements,
                                      this->lumped_boundary_slaves);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::internalUpdateLumpedBoundary(
     const Array<UInt> & nodes, const ElementTypeMapArray<UInt> & elements,
     SynchronizedArray<Real> & boundary) {
   AKANTU_DEBUG_IN();
 
   // set all values in lumped_boundary to zero
   boundary.zero();
 
   UInt dim = this->model.getSpatialDimension();
   //  UInt nb_contact_nodes = getNbContactNodes();
 
   const FEEngine & boundary_fem = this->model.getFEEngineBoundary();
 
   const Mesh & mesh = this->model.getMesh();
 
   for (auto ghost_type : ghost_types) {
     for (const auto & type : mesh.elementTypes(dim - 1, ghost_type)) {
       UInt nb_elements = mesh.getNbElement(type, ghost_type);
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
       const Array<UInt> & connectivity = mesh.getConnectivity(type, ghost_type);
 
       // get shapes and compute integral
       const Array<Real> & shapes = boundary_fem.getShapes(type, ghost_type);
       Array<Real> area(nb_elements, nb_nodes_per_element);
       boundary_fem.integrate(shapes, area, nb_nodes_per_element, type,
                              ghost_type);
 
       if (this->contact_surfaces.empty()) {
         AKANTU_DEBUG_WARNING(
             "No surfaces in ntn base contact."
             << " You have to define the lumped boundary by yourself.");
       }
 
       Array<UInt>::const_iterator<UInt> elem_it =
           (elements)(type, ghost_type).begin();
       Array<UInt>::const_iterator<UInt> elem_it_end =
           (elements)(type, ghost_type).end();
       // loop over contact nodes
       for (; elem_it != elem_it_end; ++elem_it) {
         for (UInt q = 0; q < nb_nodes_per_element; ++q) {
           UInt node = connectivity(*elem_it, q);
           UInt node_index = nodes.find(node);
           AKANTU_DEBUG_ASSERT(node_index != UInt(-1), "Could not find node "
                                                           << node
                                                           << " in the array!");
           Real area_to_add = area(*elem_it, q);
           boundary(node_index) += area_to_add;
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::computeAcceleration(Array<Real> & acceleration) const {
   auto && dof_manager =
       dynamic_cast<DOFManagerDefault &>(model.getDOFManager());
   const auto & b = dof_manager.getResidual();
   acceleration.resize(b.size());
   const auto & blocked_dofs = dof_manager.getGlobalBlockedDOFs();
   const auto & A = dof_manager.getLumpedMatrix("M");
 
   Array<bool> blocked_dofs_bool(blocked_dofs.size());
   for (auto && data : zip(blocked_dofs, blocked_dofs_bool)) {
     std::get<1>(data) = (std::get<0>(data) != 0);
   }
 
   // pre-compute the acceleration
   // (not increment acceleration, because residual is still Kf)
   NonLinearSolverLumped::solveLumped(A, acceleration, b, this->model.getF_M2A(),
                                      blocked_dofs_bool);
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::computeContactPressure() {
   AKANTU_DEBUG_IN();
 
   UInt dim = this->model.getSpatialDimension();
   Real delta_t = this->model.getTimeStep();
   UInt nb_contact_nodes = getNbContactNodes();
 
   AKANTU_DEBUG_ASSERT(delta_t > 0.,
                       "Cannot compute contact pressure if no time step is set");
 
   // synchronize data
   this->synch_registry->synchronize(SynchronizationTag::_cf_nodal);
 
   Array<Real> acceleration(0, dim);
   this->computeAcceleration(acceleration);
 
   // compute relative normal fields of displacement, velocity and acceleration
   Array<Real> r_disp(0, 1);
   Array<Real> r_velo(0, 1);
   Array<Real> r_acce(0, 1);
   Array<Real> r_old_acce(0, 1);
   computeNormalGap(r_disp);
   //  computeRelativeNormalField(this->model.getCurrentPosition(), r_disp);
   computeRelativeNormalField(this->model.getVelocity(), r_velo);
   computeRelativeNormalField(acceleration, r_acce);
   computeRelativeNormalField(this->model.getAcceleration(), r_old_acce);
 
   AKANTU_DEBUG_ASSERT(r_disp.size() == nb_contact_nodes,
                       "computeRelativeNormalField does not give back arrays "
                           << "size == nb_contact_nodes. nb_contact_nodes = "
                           << nb_contact_nodes
                           << " | array size = " << r_disp.size());
 
   // compute gap array for all nodes
   Array<Real> gap(nb_contact_nodes, 1);
   Real * gap_p = gap.storage();
   Real * r_disp_p = r_disp.storage();
   Real * r_velo_p = r_velo.storage();
   Real * r_acce_p = r_acce.storage();
   Real * r_old_acce_p = r_old_acce.storage();
   for (UInt i = 0; i < nb_contact_nodes; ++i) {
     *gap_p = *r_disp_p + delta_t * *r_velo_p + delta_t * delta_t * *r_acce_p -
              0.5 * delta_t * delta_t * *r_old_acce_p;
     // increment pointers
     gap_p++;
     r_disp_p++;
     r_velo_p++;
     r_acce_p++;
     r_old_acce_p++;
   }
 
   // check if gap is negative -> is in contact
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     if (gap(n) <= 0.) {
       for (UInt d = 0; d < dim; ++d) {
         this->contact_pressure(n, d) =
             this->impedance(n) * gap(n) / (2 * delta_t) * this->normals(n, d);
       }
       this->is_in_contact(n) = true;
     } else {
       for (UInt d = 0; d < dim; ++d) {
         this->contact_pressure(n, d) = 0.;
       }
       this->is_in_contact(n) = false;
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::applyContactPressure() {
   AKANTU_DEBUG_IN();
 
   UInt nb_contact_nodes = getNbContactNodes();
   UInt dim = this->model.getSpatialDimension();
 
   Array<Real> & residual = this->model.getInternalForce();
 
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     UInt slave = this->slaves(n);
 
     for (UInt d = 0; d < dim; ++d) {
       // residual(master,d) += this->lumped_boundary(n,0) *
       // this->contact_pressure(n,d);
       residual(slave, d) -=
           this->lumped_boundary_slaves(n) * this->contact_pressure(n, d);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Int NTNBaseContact::getNodeIndex(UInt node) const {
   return this->slaves.find(node);
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::printself(std::ostream & stream, int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNBaseContact [" << std::endl;
   stream << space << " + id            : " << id << std::endl;
   stream << space << " + slaves        : " << std::endl;
   this->slaves.printself(stream, indent + 2);
   stream << space << " + normals       : " << std::endl;
   this->normals.printself(stream, indent + 2);
   stream << space << " + contact_pressure : " << std::endl;
   this->contact_pressure.printself(stream, indent + 2);
 
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::syncArrays(SyncChoice sync_choice) {
   AKANTU_DEBUG_IN();
 
   this->slaves.syncElements(sync_choice);
   this->normals.syncElements(sync_choice);
   this->is_in_contact.syncElements(sync_choice);
   this->contact_pressure.syncElements(sync_choice);
   this->lumped_boundary_slaves.syncElements(sync_choice);
   this->impedance.syncElements(sync_choice);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseContact::addDumpFieldToDumper(const std::string & dumper_name,
                                           const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
   const Array<UInt> & nodal_filter = this->slaves.getArray();
 
 #define ADD_FIELD(field_id, field, type)                                       \
   internalAddDumpFieldToDumper(                                                \
       dumper_name, field_id,                                                   \
       std::make_unique<                                                        \
           dumpers::NodalField<type, true, Array<type>, Array<UInt>>>(          \
           field, 0, 0, &nodal_filter))
 
   if (field_id == "displacement") {
     ADD_FIELD(field_id, this->model.getDisplacement(), Real);
   } else if (field_id == "mass") {
     ADD_FIELD(field_id, this->model.getMass(), Real);
   } else if (field_id == "velocity") {
     ADD_FIELD(field_id, this->model.getVelocity(), Real);
   } else if (field_id == "acceleration") {
     ADD_FIELD(field_id, this->model.getAcceleration(), Real);
   } else if (field_id == "external_force") {
     ADD_FIELD(field_id, this->model.getExternalForce(), Real);
   } else if (field_id == "internal_force") {
     ADD_FIELD(field_id, this->model.getInternalForce(), Real);
   } else if (field_id == "blocked_dofs") {
     ADD_FIELD(field_id, this->model.getBlockedDOFs(), bool);
   } else if (field_id == "increment") {
     ADD_FIELD(field_id, this->model.getIncrement(), Real);
   } else if (field_id == "normal") {
     internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->normals.getArray()));
   } else if (field_id == "contact_pressure") {
     internalAddDumpFieldToDumper(dumper_name, field_id,
                                  std::make_unique<dumpers::NodalField<Real>>(
                                      this->contact_pressure.getArray()));
   } else if (field_id == "is_in_contact") {
     internalAddDumpFieldToDumper(dumper_name, field_id,
                                  std::make_unique<dumpers::NodalField<bool>>(
                                      this->is_in_contact.getArray()));
   } else if (field_id == "lumped_boundary_slave") {
     internalAddDumpFieldToDumper(dumper_name, field_id,
                                  std::make_unique<dumpers::NodalField<Real>>(
                                      this->lumped_boundary_slaves.getArray()));
   } else if (field_id == "impedance") {
     internalAddDumpFieldToDumper(dumper_name, field_id,
                                  std::make_unique<dumpers::NodalField<Real>>(
                                      this->impedance.getArray()));
   } else {
     std::cerr << "Could not add field '" << field_id
               << "' to the dumper. Just ignored it." << std::endl;
   }
 
 #undef ADD_FIELD
-#endif
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.cc
index 79e07047f..5f8afe7fb 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_base_friction.cc
@@ -1,382 +1,376 @@
 /**
  * @file   ntn_base_friction.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  implementation of ntn base friction
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_base_friction.hh"
 #include "dof_manager_default.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_text.hh"
 #include "non_linear_solver_lumped.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NTNBaseFriction::NTNBaseFriction(NTNBaseContact & contact, const ID & id)
     : Parsable(ParserType::_friction, id), contact(contact),
       is_sticking(0, 1, true, id + ":is_sticking", true, "is_sticking"),
       frictional_strength(0, 1, 0., id + ":frictional_strength", 0.,
                           "frictional_strength"),
       friction_traction(0, contact.getModel().getSpatialDimension(), 0.,
                         id + ":friction_traction", 0., "friction_traction"),
       slip(0, 1, 0., id + ":slip", 0., "slip"),
       cumulative_slip(0, 1, 0., id + ":cumulative_slip", 0., "cumulative_slip"),
       slip_velocity(0, contact.getModel().getSpatialDimension(), 0.,
                     id + ":slip_velocity", 0., "slip_velocity") {
   AKANTU_DEBUG_IN();
 
   this->contact.registerSynchronizedArray(this->is_sticking);
   this->contact.registerSynchronizedArray(this->frictional_strength);
   this->contact.registerSynchronizedArray(this->friction_traction);
   this->contact.registerSynchronizedArray(this->slip);
   this->contact.registerSynchronizedArray(this->cumulative_slip);
   this->contact.registerSynchronizedArray(this->slip_velocity);
 
   this->registerExternalDumper(contact.getDumper().shared_from_this(),
                                contact.getDefaultDumperName(), true);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::updateSlip() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel & model = this->contact.getModel();
   UInt dim = model.getSpatialDimension();
 
   // synchronize increment
   this->contact.getSynchronizerRegistry().synchronize(
       SynchronizationTag::_cf_incr);
 
   Array<Real> rel_tan_incr(0, dim);
   this->contact.computeRelativeTangentialField(model.getIncrement(),
                                                rel_tan_incr);
   Array<Real>::const_iterator<Vector<Real>> it = rel_tan_incr.begin(dim);
 
   UInt nb_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_nodes; ++n) {
     if (this->is_sticking(n)) {
       this->slip(n) = 0.;
     } else {
       const Vector<Real> & rti = it[n];
       this->slip(n) += rti.norm();
       this->cumulative_slip(n) += rti.norm();
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::computeFrictionTraction() {
   AKANTU_DEBUG_IN();
 
   this->computeStickTraction();
   this->computeFrictionalStrength();
 
   SolidMechanicsModel & model = this->contact.getModel();
   UInt dim = model.getSpatialDimension();
 
   // get contact arrays
   const SynchronizedArray<bool> & is_in_contact =
       this->contact.getIsInContact();
 
   auto & traction =
       const_cast<Array<Real> &>(this->friction_traction.getArray());
   Array<Real>::iterator<Vector<Real>> it_fric_trac = traction.begin(dim);
 
   this->is_sticking.zero(); // set to not sticking
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // node pair is in contact
     if (is_in_contact(n)) {
       Vector<Real> fric_trac = it_fric_trac[n];
       // check if it is larger than frictional strength
       Real abs_fric = fric_trac.norm();
       if (abs_fric != 0.) {
         Real alpha = this->frictional_strength(n) / abs_fric;
 
         // larger -> sliding
         if (alpha < 1.) {
           fric_trac *= alpha;
         } else {
           this->is_sticking(n) = true;
         }
       } else {
         // frictional traction is already zero
         this->is_sticking(n) = true;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::computeStickTraction() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel & model = this->contact.getModel();
   UInt dim = model.getSpatialDimension();
   Real delta_t = model.getTimeStep();
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
 
   // get contact arrays
   const SynchronizedArray<Real> & impedance = this->contact.getImpedance();
   const SynchronizedArray<bool> & is_in_contact =
       this->contact.getIsInContact();
 
   Array<Real> acceleration(0, dim);
   this->contact.computeAcceleration(acceleration);
 
   // compute relative normal fields of velocity and acceleration
   Array<Real> r_velo(0, dim);
   Array<Real> r_acce(0, dim);
   Array<Real> r_old_acce(0, dim);
   this->contact.computeRelativeTangentialField(model.getVelocity(), r_velo);
   this->contact.computeRelativeTangentialField(acceleration, r_acce);
   this->contact.computeRelativeTangentialField(model.getAcceleration(),
                                                r_old_acce);
 
   AKANTU_DEBUG_ASSERT(r_velo.size() == nb_contact_nodes,
                       "computeRelativeNormalField does not give back arrays "
                           << "size == nb_contact_nodes. nb_contact_nodes = "
                           << nb_contact_nodes
                           << " | array size = " << r_velo.size());
 
   // compute tangential gap_dot array for all nodes
   Array<Real> gap_dot(nb_contact_nodes, dim);
   for (auto && data : zip(make_view(gap_dot), make_view(r_velo),
                           make_view(r_acce), make_view(r_old_acce))) {
     auto & gap_dot = std::get<0>(data);
     auto & r_velo = std::get<1>(data);
     auto & r_acce = std::get<2>(data);
     auto & r_old_acce = std::get<3>(data);
 
     gap_dot = r_velo + delta_t * r_acce - 1. / 2. * delta_t * r_old_acce;
   }
 
   // compute friction traction to stop sliding
   auto & traction =
       const_cast<Array<Real> &>(this->friction_traction.getArray());
   auto it_fric_trac = traction.begin(dim);
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     Vector<Real> fric_trac = it_fric_trac[n];
     // node pair is NOT in contact
     if (!is_in_contact(n)) {
       fric_trac.zero(); // set to zero
     }
 
     // node pair is in contact
     else {
       // compute friction traction
       for (UInt d = 0; d < dim; ++d) {
         fric_trac(d) = impedance(n) * gap_dot(n, d) / 2.;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::applyFrictionTraction() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel & model = this->contact.getModel();
   Array<Real> & residual = model.getInternalForce();
   UInt dim = model.getSpatialDimension();
 
   const SynchronizedArray<UInt> & slaves = this->contact.getSlaves();
   const SynchronizedArray<Real> & lumped_boundary_slaves =
       this->contact.getLumpedBoundarySlaves();
 
   UInt nb_contact_nodes = this->contact.getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     UInt slave = slaves(n);
 
     for (UInt d = 0; d < dim; ++d) {
       residual(slave, d) -=
           lumped_boundary_slaves(n) * this->friction_traction(n, d);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::registerSynchronizedArray(SynchronizedArrayBase & array) {
   AKANTU_DEBUG_IN();
 
   this->frictional_strength.registerDependingArray(array);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::dumpRestart(const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   this->is_sticking.dumpRestartFile(file_name);
   this->frictional_strength.dumpRestartFile(file_name);
   this->friction_traction.dumpRestartFile(file_name);
   this->slip.dumpRestartFile(file_name);
   this->cumulative_slip.dumpRestartFile(file_name);
   this->slip_velocity.dumpRestartFile(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::readRestart(const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   this->is_sticking.readRestartFile(file_name);
   this->frictional_strength.readRestartFile(file_name);
   this->friction_traction.readRestartFile(file_name);
   this->cumulative_slip.readRestartFile(file_name);
   this->slip_velocity.readRestartFile(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::setParam(const std::string & name, UInt node,
                                Real value) {
   AKANTU_DEBUG_IN();
 
   auto & array = this->get(name).get<SynchronizedArray<Real>>();
   Int index = this->contact.getNodeIndex(node);
   if (index < 0) {
     AKANTU_DEBUG_WARNING("Node "
                          << node << " is not a contact node. "
                          << "Therefore, cannot set interface parameter!!");
   } else {
     array(index) = value; // put value
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt NTNBaseFriction::getNbStickingNodes() const {
   AKANTU_DEBUG_IN();
 
   UInt nb_stick = 0;
 
   UInt nb_nodes = this->contact.getNbContactNodes();
   const SynchronizedArray<UInt> & nodes = this->contact.getSlaves();
   const SynchronizedArray<bool> & is_in_contact =
       this->contact.getIsInContact();
 
   const Mesh & mesh = this->contact.getModel().getMesh();
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     bool is_local_node = mesh.isLocalOrMasterNode(nodes(n));
     bool is_pbc_slave_node = mesh.isPeriodicSlave(nodes(n));
     if (is_local_node && !is_pbc_slave_node && is_in_contact(n) &&
         this->is_sticking(n)) {
       nb_stick++;
     }
   }
 
   mesh.getCommunicator().allReduce(nb_stick, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return nb_stick;
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::printself(std::ostream & stream, int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNBaseFriction [" << std::endl;
   Parsable::printself(stream, indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNBaseFriction::addDumpFieldToDumper(const std::string & dumper_name,
                                            const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
-  //  const SynchronizedArray<UInt> * nodal_filter =
-  //  &(this->contact.getSlaves());
-
   if (field_id == "is_sticking") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<bool>>(
             this->is_sticking.getArray()));
   } else if (field_id == "frictional_strength") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(
             this->frictional_strength.getArray()));
   } else if (field_id == "friction_traction") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(
             this->friction_traction.getArray()));
   } else if (field_id == "slip") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(this->slip.getArray()));
   } else if (field_id == "cumulative_slip") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(
             this->cumulative_slip.getArray()));
   } else if (field_id == "slip_velocity") {
     this->internalAddDumpFieldToDumper(
         dumper_name, field_id,
         std::make_unique<dumpers::NodalField<Real>>(
             this->slip_velocity.getArray()));
   } else {
     this->contact.addDumpFieldToDumper(dumper_name, field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_contact.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_contact.cc
index c8297bc98..194cdad3e 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_contact.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntn_contact.cc
@@ -1,558 +1,556 @@
 /**
  * @file   ntn_contact.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Tue Sep 29 2020
  *
  * @brief  implementation of ntn_contact
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntn_contact.hh"
 #include "dumper_nodal_field.hh"
 #include "dumper_text.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NTNContact::NTNContact(SolidMechanicsModel & model, const ID & id)
     : NTNBaseContact(model, id),
       masters(0, 1, 0, id + ":masters", std::numeric_limits<UInt>::quiet_NaN(),
               "masters"),
       lumped_boundary_masters(0, 1, 0, id + ":lumped_boundary_masters",
                               std::numeric_limits<Real>::quiet_NaN(),
                               "lumped_boundary_masters"),
       master_elements("master_elements", id) {
   AKANTU_DEBUG_IN();
 
   const Mesh & mesh = this->model.getMesh();
   UInt spatial_dimension = this->model.getSpatialDimension();
 
   this->master_elements.initialize(mesh, _nb_component = 1,
                                    _spatial_dimension = spatial_dimension - 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::pairInterfaceNodes(const ElementGroup & slave_boundary,
                                     const ElementGroup & master_boundary,
                                     UInt surface_normal_dir, const Mesh & mesh,
                                     Array<UInt> & pairs) {
   AKANTU_DEBUG_IN();
 
   pairs.resize(0);
   AKANTU_DEBUG_ASSERT(pairs.getNbComponent() == 2,
                       "Array of node pairs should have nb_component = 2,"
                           << " but has nb_component = "
                           << pairs.getNbComponent());
 
   UInt dim = mesh.getSpatialDimension();
   AKANTU_DEBUG_ASSERT(surface_normal_dir < dim,
                       "Mesh is of " << dim << " dimensions"
                                     << " and cannot have direction "
                                     << surface_normal_dir
                                     << " for surface normal");
 
   // offset for projection computation
   Vector<UInt> offset(dim - 1);
   for (UInt i = 0, j = 0; i < dim; ++i) {
     if (surface_normal_dir != i) {
       offset(j) = i;
       ++j;
     }
   }
 
   // find projected node coordinates
   const Array<Real> & coordinates = mesh.getNodes();
 
   // find slave nodes
   Array<Real> proj_slave_coord(slave_boundary.getNbNodes(), dim - 1, 0.);
   Array<UInt> slave_nodes(slave_boundary.getNbNodes());
   UInt n(0);
   for (auto && slave_node : slave_boundary.getNodeGroup().getNodes()) {
     for (UInt d = 0; d < dim - 1; ++d) {
       proj_slave_coord(n, d) = coordinates(slave_node, offset[d]);
       slave_nodes(n) = slave_node;
     }
     ++n;
   }
 
   // find master nodes
   Array<Real> proj_master_coord(master_boundary.getNbNodes(), dim - 1, 0.);
   Array<UInt> master_nodes(master_boundary.getNbNodes());
   n = 0;
   for (auto && master_node : master_boundary.getNodeGroup().getNodes()) {
     for (UInt d = 0; d < dim - 1; ++d) {
       proj_master_coord(n, d) = coordinates(master_node, offset[d]);
       master_nodes(n) = master_node;
     }
     ++n;
   }
 
   // find minimum distance between slave nodes to define tolerance
   Real min_dist = std::numeric_limits<Real>::max();
   for (UInt i = 0; i < proj_slave_coord.size(); ++i) {
     for (UInt j = i + 1; j < proj_slave_coord.size(); ++j) {
       Real dist = 0.;
       for (UInt d = 0; d < dim - 1; ++d) {
         dist += (proj_slave_coord(i, d) - proj_slave_coord(j, d)) *
                 (proj_slave_coord(i, d) - proj_slave_coord(j, d));
       }
       if (dist < min_dist) {
         min_dist = dist;
       }
     }
   }
   min_dist = std::sqrt(min_dist);
   Real local_tol = 0.1 * min_dist;
 
   // find master slave node pairs
   for (UInt i = 0; i < proj_slave_coord.size(); ++i) {
     for (UInt j = 0; j < proj_master_coord.size(); ++j) {
       Real dist = 0.;
       for (UInt d = 0; d < dim - 1; ++d) {
         dist += (proj_slave_coord(i, d) - proj_master_coord(j, d)) *
                 (proj_slave_coord(i, d) - proj_master_coord(j, d));
       }
       dist = std::sqrt(dist);
       if (dist < local_tol) { // it is a pair
         Vector<UInt> pair(2);
         pair[0] = slave_nodes(i);
         pair[1] = master_nodes(j);
         pairs.push_back(pair);
         continue; // found master do not need to search further for this slave
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::addSurfacePair(const ID & slave, const ID & master,
                                 UInt surface_normal_dir) {
   AKANTU_DEBUG_IN();
 
   const Mesh & mesh = this->model.getMesh();
 
   const ElementGroup & slave_boundary = mesh.getElementGroup(slave);
   const ElementGroup & master_boundary = mesh.getElementGroup(master);
 
   this->contact_surfaces.insert(&slave_boundary);
   this->contact_surfaces.insert(&master_boundary);
 
   Array<UInt> pairs(0, 2);
   NTNContact::pairInterfaceNodes(slave_boundary, master_boundary,
                                  surface_normal_dir, this->model.getMesh(),
                                  pairs);
 
   // eliminate pairs which contain a pbc slave node
   Array<UInt> pairs_no_PBC_slaves(0, 2);
   Array<UInt>::const_vector_iterator it = pairs.begin(2);
   Array<UInt>::const_vector_iterator end = pairs.end(2);
   for (; it != end; ++it) {
     const Vector<UInt> & pair = *it;
     if (not mesh.isPeriodicSlave(pair(0)) and
         not mesh.isPeriodicSlave(pair(1))) {
       pairs_no_PBC_slaves.push_back(pair);
     }
   }
 
   this->addNodePairs(pairs_no_PBC_slaves);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::addNodePairs(const Array<UInt> & pairs) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_ASSERT(pairs.getNbComponent() == 2,
                       "Array of node pairs should have nb_component = 2,"
                           << " but has nb_component = "
                           << pairs.getNbComponent());
   UInt nb_pairs = pairs.size();
   for (UInt n = 0; n < nb_pairs; ++n) {
     this->addSplitNode(pairs(n, 0), pairs(n, 1));
   }
 
   // synchronize with depending nodes
   findBoundaryElements(this->slaves.getArray(), this->slave_elements);
   findBoundaryElements(this->masters.getArray(), this->master_elements);
   updateInternalData();
   syncArrays(_added);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::getNodePairs(Array<UInt> & pairs) const {
   AKANTU_DEBUG_IN();
 
   pairs.resize(0);
   AKANTU_DEBUG_ASSERT(pairs.getNbComponent() == 2,
                       "Array of node pairs should have nb_component = 2,"
                           << " but has nb_component = "
                           << pairs.getNbComponent());
   UInt nb_pairs = this->getNbContactNodes();
   for (UInt n = 0; n < nb_pairs; ++n) {
     Vector<UInt> pair{this->slaves(n), this->masters(n)};
     pairs.push_back(pair);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::addSplitNode(UInt slave, UInt master) {
   AKANTU_DEBUG_IN();
 
   NTNBaseContact::addSplitNode(slave);
 
   this->masters.push_back(master);
   this->lumped_boundary_masters.push_back(
       std::numeric_limits<Real>::quiet_NaN());
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /*
   This function only works for surface elements with one quad point. For
   surface elements with more quad points, it computes still, but the result
   might not be what you are looking for.
  */
 void NTNContact::updateNormals() {
   AKANTU_DEBUG_IN();
 
   // set normals to zero
   this->normals.zero();
 
   // contact information
   UInt dim = this->model.getSpatialDimension();
   UInt nb_contact_nodes = this->getNbContactNodes();
 
   this->synch_registry->synchronize(
       SynchronizationTag::_cf_nodal); // synchronize current pos
   const Array<Real> & cur_pos = this->model.getCurrentPosition();
 
   FEEngine & boundary_fem = this->model.getFEEngineBoundary();
   const Mesh & mesh = this->model.getMesh();
 
   for (auto ghost_type : ghost_types) {
     for (const auto & type : mesh.elementTypes(dim - 1, ghost_type)) {
       // compute the normals
       Array<Real> quad_normals(0, dim);
       boundary_fem.computeNormalsOnIntegrationPoints(cur_pos, quad_normals,
                                                      type, ghost_type);
 
       UInt nb_quad_points =
           boundary_fem.getNbIntegrationPoints(type, ghost_type);
 
       // new version: compute normals only based on master elements (and not all
       // boundary elements)
       // -------------------------------------------------------------------------------------
 
       UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
       const Array<UInt> & connectivity = mesh.getConnectivity(type, ghost_type);
 
       // loop over contact nodes
       for (auto & element : (this->master_elements)(type, ghost_type)) {
         for (UInt q = 0; q < nb_nodes_per_element; ++q) {
           UInt node = connectivity(element, q);
           UInt node_index = this->masters.find(node);
           AKANTU_DEBUG_ASSERT(node_index != UInt(-1), "Could not find node "
                                                           << node
                                                           << " in the array!");
 
           for (UInt q = 0; q < nb_quad_points; ++q) {
             // add quad normal to master normal
             for (UInt d = 0; d < dim; ++d) {
               this->normals(node_index, d) +=
                   quad_normals(element * nb_quad_points + q, d);
             }
           }
         }
       }
     }
   }
 
   Real * master_normals = this->normals.storage();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     if (dim == 2) {
       Math::normalize2(&(master_normals[n * dim]));
     } else if (dim == 3) {
       Math::normalize3(&(master_normals[n * dim]));
     }
   }
 
   // // normalize normals
   // auto nit  = this->normals.begin();
   // auto nend = this->normals.end();
   // for (; nit != nend; ++nit) {
   //   nit->normalize();
   // }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::dumpRestart(const std::string & file_name) const {
   AKANTU_DEBUG_IN();
 
   NTNBaseContact::dumpRestart(file_name);
   this->masters.dumpRestartFile(file_name);
   this->lumped_boundary_masters.dumpRestartFile(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::readRestart(const std::string & file_name) {
   AKANTU_DEBUG_IN();
 
   NTNBaseContact::readRestart(file_name);
   this->masters.readRestartFile(file_name);
   this->lumped_boundary_masters.readRestartFile(file_name);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::updateImpedance() {
   AKANTU_DEBUG_IN();
 
   UInt nb_contact_nodes = getNbContactNodes();
   Real delta_t = this->model.getTimeStep();
   AKANTU_DEBUG_ASSERT(delta_t != NAN,
                       "Time step is NAN. Have you set it already?");
 
   const Array<Real> & mass = this->model.getMass();
 
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     UInt master = this->masters(n);
     UInt slave = this->slaves(n);
 
     Real imp = (this->lumped_boundary_masters(n) / mass(master)) +
                (this->lumped_boundary_slaves(n) / mass(slave));
     imp = 2 / delta_t / imp;
     this->impedance(n) = imp;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::updateLumpedBoundary() {
   AKANTU_DEBUG_IN();
 
   internalUpdateLumpedBoundary(this->slaves.getArray(), this->slave_elements,
                                this->lumped_boundary_slaves);
 
   internalUpdateLumpedBoundary(this->masters.getArray(), this->master_elements,
                                this->lumped_boundary_masters);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::applyContactPressure() {
   AKANTU_DEBUG_IN();
 
   UInt nb_ntn_pairs = getNbContactNodes();
   UInt dim = this->model.getSpatialDimension();
 
   Array<Real> & residual = this->model.getInternalForce();
 
   for (UInt n = 0; n < nb_ntn_pairs; ++n) {
     UInt master = this->masters(n);
     UInt slave = this->slaves(n);
 
     for (UInt d = 0; d < dim; ++d) {
       residual(master, d) +=
           this->lumped_boundary_masters(n) * this->contact_pressure(n, d);
       residual(slave, d) -=
           this->lumped_boundary_slaves(n) * this->contact_pressure(n, d);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::computeRelativeTangentialField(
     const Array<Real> & field, Array<Real> & rel_tang_field) const {
   AKANTU_DEBUG_IN();
 
   // resize arrays to zero
   rel_tang_field.resize(0);
 
   UInt dim = this->model.getSpatialDimension();
 
   auto it_field = field.begin(dim);
   auto it_normal = this->normals.getArray().begin(dim);
 
   Vector<Real> rfv(dim);
   Vector<Real> np_rfv(dim);
 
   UInt nb_contact_nodes = this->slaves.size();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // nodes
     UInt slave = this->slaves(n);
     UInt master = this->masters(n);
 
     // relative field vector (slave - master)
     rfv = Vector<Real>(it_field[slave]);
     rfv -= Vector<Real>(it_field[master]);
 
     // normal projection of relative field
     const Vector<Real> normal_v = it_normal[n];
     np_rfv = normal_v;
     np_rfv *= rfv.dot(normal_v);
 
     // subract normal projection from relative field to get the tangential
     // projection
     rfv -= np_rfv;
     rel_tang_field.push_back(rfv);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::computeRelativeNormalField(
     const Array<Real> & field, Array<Real> & rel_normal_field) const {
   AKANTU_DEBUG_IN();
 
   // resize arrays to zero
   rel_normal_field.resize(0);
 
   UInt dim = this->model.getSpatialDimension();
   //  Real * field_p = field.storage();
   //  Real * normals_p = this->normals.storage();
 
   Array<Real>::const_iterator<Vector<Real>> it_field = field.begin(dim);
   Array<Real>::const_iterator<Vector<Real>> it_normal =
       this->normals.getArray().begin(dim);
 
   Vector<Real> rfv(dim);
 
   UInt nb_contact_nodes = this->getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // nodes
     UInt slave = this->slaves(n);
     UInt master = this->masters(n);
 
     // relative field vector (slave - master)
     rfv = Vector<Real>(it_field[slave]);
     rfv -= Vector<Real>(it_field[master]);
 
     // length of normal projection of relative field
     const Vector<Real> normal_v = it_normal[n];
     rel_normal_field.push_back(rfv.dot(normal_v));
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Int NTNContact::getNodeIndex(UInt node) const {
   AKANTU_DEBUG_IN();
 
   Int slave_i = NTNBaseContact::getNodeIndex(node);
   Int master_i = this->masters.find(node);
 
   AKANTU_DEBUG_OUT();
   return std::max(slave_i, master_i);
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::printself(std::ostream & stream, int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTNContact [" << std::endl;
   NTNBaseContact::printself(stream, indent);
   stream << space << " + masters       : " << std::endl;
   this->masters.printself(stream, indent + 2);
   stream << space << " + lumped_boundary_mastres : " << std::endl;
   this->lumped_boundary_masters.printself(stream, indent + 2);
 
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::syncArrays(SyncChoice sync_choice) {
   AKANTU_DEBUG_IN();
 
   NTNBaseContact::syncArrays(sync_choice);
 
   this->masters.syncElements(sync_choice);
   this->lumped_boundary_masters.syncElements(sync_choice);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTNContact::addDumpFieldToDumper(const std::string & dumper_name,
                                       const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
   /*
-#ifdef AKANTU_USE_IOHELPER
   const Array<UInt> & nodal_filter = this->slaves.getArray();
 
 #define ADD_FIELD(field_id, field, type)				\
   internalAddDumpFieldToDumper(dumper_name,				\
                    field_id,				\
                    new DumperIOHelper::NodalField< type, true, \
                                    Array<type>, \
                                    Array<UInt> >(field, 0, 0, &nodal_filter))
   */
 
   if (field_id == "lumped_boundary_master") {
     internalAddDumpFieldToDumper(dumper_name, field_id,
                                  std::make_unique<dumpers::NodalField<Real>>(
                                      this->lumped_boundary_masters.getArray()));
   } else {
     NTNBaseContact::addDumpFieldToDumper(dumper_name, field_id);
   }
 
   /*
 #undef ADD_FIELD
-#endif
   */
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_contact.cc b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_contact.cc
index a6d980b15..6c6e9c106 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_contact.cc
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_contact.cc
@@ -1,324 +1,322 @@
 /**
  * @file   ntrf_contact.cc
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Tue May 21 2019
  *
  * @brief  contact for node to rigid flat interface
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 // simtools
 #include "ntrf_contact.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NTRFContact::NTRFContact(SolidMechanicsModel & model, const ID & id)
     : NTNBaseContact(model, id), reference_point(model.getSpatialDimension()),
       normal(model.getSpatialDimension()) {
   AKANTU_DEBUG_IN();
 
   is_ntn_contact = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::setReferencePoint(Real x, Real y, Real z) {
   AKANTU_DEBUG_IN();
 
   Real coord[3];
   coord[0] = x;
   coord[1] = y;
   coord[2] = z;
 
   UInt dim = this->model.getSpatialDimension();
   for (UInt d = 0; d < dim; ++d) {
     this->reference_point(d) = coord[d];
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::setNormal(Real x, Real y, Real z) {
   AKANTU_DEBUG_IN();
 
   UInt dim = this->model.getSpatialDimension();
 
   Real coord[3];
   coord[0] = x;
   coord[1] = y;
   coord[2] = z;
 
   for (UInt d = 0; d < dim; ++d) {
     this->normal(d) = coord[d];
   }
 
   this->normal.normalize();
 
   this->updateNormals();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::addSurface(const ID & surf) {
   AKANTU_DEBUG_IN();
 
   const Mesh & mesh_ref = this->model.getMesh();
 
   try {
     const ElementGroup & boundary = mesh_ref.getElementGroup(surf);
     this->contact_surfaces.insert(&boundary);
 
     // find slave nodes
     for (auto && node : boundary.getNodeGroup().getNodes()) {
       if (not mesh_ref.isPeriodicSlave(node)) {
         this->addSplitNode(node);
       }
     }
   } catch (debug::Exception & e) {
     AKANTU_DEBUG_INFO("NTRFContact addSurface did not found subboundary "
                       << surf
                       << " and ignored it. Other procs might have it :)");
   }
 
   // synchronize with depending nodes
   findBoundaryElements(this->slaves.getArray(), this->slave_elements);
   updateInternalData();
   syncArrays(_added);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::addNodes(Array<UInt> & nodes) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = nodes.size();
   UInt nb_compo = nodes.getNbComponent();
   for (UInt n = 0; n < nb_nodes; ++n) {
     for (UInt c = 0; c < nb_compo; ++c) {
       this->addSplitNode(nodes(n, c));
     }
   }
 
   // synchronize with depending nodes
   findBoundaryElements(this->slaves.getArray(), this->slave_elements);
   updateInternalData();
   syncArrays(_added);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::updateNormals() {
   AKANTU_DEBUG_IN();
 
   // normal is the same for all slaves
   this->normals.set(this->normal);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::updateImpedance() {
   AKANTU_DEBUG_IN();
 
   UInt nb_contact_nodes = getNbContactNodes();
   Real delta_t = this->model.getTimeStep();
   AKANTU_DEBUG_ASSERT(delta_t != NAN,
                       "Time step is NAN. Have you set it already?");
 
   const Array<Real> & mass = this->model.getMass();
 
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     UInt slave = this->slaves(n);
 
     Real imp = this->lumped_boundary_slaves(n) / mass(slave);
     imp = 2 / delta_t / imp;
     this->impedance(n) = imp;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::computeRelativeTangentialField(
     const Array<Real> & field, Array<Real> & rel_tang_field) const {
   AKANTU_DEBUG_IN();
 
   // resize arrays to zero
   rel_tang_field.resize(0);
 
   UInt dim = this->model.getSpatialDimension();
 
   Array<Real>::const_iterator<Vector<Real>> it_field = field.begin(dim);
   Array<Real>::const_iterator<Vector<Real>> it_normal =
       this->normals.getArray().begin(dim);
 
   Vector<Real> rfv(dim);
   Vector<Real> np_rfv(dim);
 
   UInt nb_contact_nodes = this->slaves.size();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // nodes
     UInt node = this->slaves(n);
 
     // relative field vector
     rfv = it_field[node];
     ;
 
     // normal projection of relative field
     const Vector<Real> & normal_v = it_normal[n];
     np_rfv = normal_v;
     np_rfv *= rfv.dot(normal_v);
 
     // subtract normal projection from relative field to get the tangential
     // projection
     rfv -= np_rfv;
     rel_tang_field.push_back(rfv);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::computeNormalGap(Array<Real> & gap) const {
   AKANTU_DEBUG_IN();
 
   gap.resize(0);
 
   UInt dim = this->model.getSpatialDimension();
 
   Array<Real>::const_iterator<Vector<Real>> it_cur_pos =
       this->model.getCurrentPosition().begin(dim);
   Array<Real>::const_iterator<Vector<Real>> it_normal =
       this->normals.getArray().begin(dim);
 
   Vector<Real> gap_v(dim);
 
   UInt nb_contact_nodes = this->getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // nodes
     UInt node = this->slaves(n);
 
     // gap vector
     gap_v = it_cur_pos[node];
     gap_v -= this->reference_point;
 
     // length of normal projection of gap vector
     const Vector<Real> & normal_v = it_normal[n];
     gap.push_back(gap_v.dot(normal_v));
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::computeRelativeNormalField(
     const Array<Real> & field, Array<Real> & rel_normal_field) const {
   AKANTU_DEBUG_IN();
 
   // resize arrays to zero
   rel_normal_field.resize(0);
 
   UInt dim = this->model.getSpatialDimension();
 
   Array<Real>::const_iterator<Vector<Real>> it_field = field.begin(dim);
   Array<Real>::const_iterator<Vector<Real>> it_normal =
       this->normals.getArray().begin(dim);
 
   UInt nb_contact_nodes = this->getNbContactNodes();
   for (UInt n = 0; n < nb_contact_nodes; ++n) {
     // nodes
     UInt node = this->slaves(n);
 
     const Vector<Real> & field_v = it_field[node];
     const Vector<Real> & normal_v = it_normal[n];
 
     rel_normal_field.push_back(field_v.dot(normal_v));
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::printself(std::ostream & stream, int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTRFContact [" << std::endl;
   NTNBaseContact::printself(stream, indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NTRFContact::addDumpFieldToDumper(const std::string & dumper_name,
                                        const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
   /*
-#ifdef AKANTU_USE_IOHELPER
   const Array<UInt> & nodal_filter = this->slaves.getArray();
 
 #define ADD_FIELD(field_id, field, type)				\
   internalAddDumpFieldToDumper(dumper_name,				\
                    field_id,				\
                    new DumperIOHelper::NodalField< type, true, \
                                    Array<type>, \
                                    Array<UInt> >(field, 0, 0, &nodal_filter))
   */
 
   /*
   if(field_id == "displacement") {
     ADD_FIELD(field_id, this->model.getDisplacement(), Real);
   }
   else if(field_id == "contact_pressure") {
     internalAddDumpFieldToDumper(dumper_name,
                  field_id,
                  new
   DumperIOHelper::NodalField<Real>(this->contact_pressure.getArray()));
   }
   else {*/
   NTNBaseContact::addDumpFieldToDumper(dumper_name, field_id);
   //}
 
   /*
 #undef ADD_FIELD
-#endif
   */
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_friction_tmpl.hh b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_friction_tmpl.hh
index 7697171bc..22b89af7f 100644
--- a/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_friction_tmpl.hh
+++ b/extra_packages/traction-at-split-node-contact/src/ntn_contact/ntrf_friction_tmpl.hh
@@ -1,107 +1,104 @@
 /**
  * @file   ntrf_friction_tmpl.hh
  *
  * @author David Simon Kammer <david.kammer@epfl.ch>
  *
  * @date creation: Fri Mar 16 2018
  * @date last modification: Wed Oct 17 2018
  *
  * @brief  implementation of node to rigid flat interface friction
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 //#include "ntrf_friction.hh"
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <template <class> class FrictionLaw, class Regularisation>
 NTRFFriction<FrictionLaw, Regularisation>::NTRFFriction(
     NTNBaseContact & contact, const ID & id)
     : FrictionLaw<Regularisation>(contact, id) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <template <class> class FrictionLaw, class Regularisation>
 void NTRFFriction<FrictionLaw, Regularisation>::printself(std::ostream & stream,
                                                           int indent) const {
   AKANTU_DEBUG_IN();
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "NTRFFriction [" << std::endl;
   FrictionLaw<Regularisation>::printself(stream, ++indent);
   stream << space << "]" << std::endl;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /*
 void NTRFFriction::addDumpFieldToDumper(const std::string & dumper_name,
                     const std::string & field_id) {
   AKANTU_DEBUG_IN();
 
-#ifdef AKANTU_USE_IOHELPER
   //  const SynchronizedArray<UInt> * nodal_filter =
 &(this->contact.getSlaves());
 
   if(field_id == "is_sticking") {
     this->internalAddDumpFieldToDumper(dumper_name,
                    field_id,
                    new
 DumperIOHelper::NodalField<bool>(this->is_sticking.getArray()));
   }
   else if(field_id == "frictional_strength") {
     this->internalAddDumpFieldToDumper(dumper_name,
                    field_id,
                    new
 DumperIOHelper::NodalField<Real>(this->frictional_strength.getArray()));
   }
   else if(field_id == "friction_traction") {
     this->internalAddDumpFieldToDumper(dumper_name,
                    field_id,
                    new
 DumperIOHelper::NodalField<Real>(this->friction_traction.getArray()));
   }
   else if(field_id == "slip") {
     this->internalAddDumpFieldToDumper(dumper_name,
                    field_id,
                    new DumperIOHelper::NodalField<Real>(this->slip.getArray()));
   }
   else {
     this->contact.addDumpFieldToDumper(dumper_name, field_id);
   }
 
-#endif
-
   AKANTU_DEBUG_OUT();
 }
 */
 
 } // namespace akantu
diff --git a/packages/akantu_iterators.cmake b/packages/akantu_iterators.cmake
index dd9cf6917..fbc216b19 100644
--- a/packages/akantu_iterators.cmake
+++ b/packages/akantu_iterators.cmake
@@ -1,38 +1,40 @@
 #===============================================================================
 # @file   akantu_iterators.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Sep 03 2010
 # @date last modification: Wed Nov 27 2019
 #
 # @brief  package description for akantu_iterators
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
-
+if(AKANTU_BYPASS_AKANTU_TARGET)
+  return()
+endif()
 
 package_declare(akantu_iterators EXTERNAL
   DESCRIPTION "Akantu's iterators hearder library"
   SYSTEM OFF third-party/cmake/akantu_iterators.cmake
   DEFAULT ON
   )
diff --git a/packages/blas.cmake b/packages/blas.cmake
index 9056f6ea8..591058bf2 100644
--- a/packages/blas.cmake
+++ b/packages/blas.cmake
@@ -1,85 +1,75 @@
 #===============================================================================
 # @file   blas.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Tue Oct 16 2012
 # @date last modification: Thu May 11 2017
 #
 # @brief  package description for blas support
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 package_declare(BLAS EXTERNAL
   DESCRIPTION "Use BLAS for arithmetic operations"
-  EXTRA_PACKAGE_OPTIONS LANGUAGE Fortran
-  SYSTEM ON third-party/cmake/blas.cmake)
-
-package_add_third_party_script_variable(BLAS BLAS_ARCHIVE "http://www.netlib.org/blas/blas-3.5.0.tgz")
-package_add_third_party_script_variable(BLAS BLAS_VERSION "3.5.0")
+  EXTRA_PACKAGE_OPTIONS LANGUAGE Fortran)
 
 set(_default_blas $ENV{BLA_VENDOR})
 if(NOT _default_blas)
   set(_default_blas All)
 endif()
 
 set(AKANTU_USE_BLAS_VENDOR "${_default_blas}" CACHE STRING "Version of blas to use")
 mark_as_advanced(AKANTU_USE_BLAS_VENDOR)
 set_property(CACHE AKANTU_USE_BLAS_VENDOR PROPERTY STRINGS
   All
   ACML
   ACML_GPU
   ACML_MP
   ATLAS
   Apple
   CXML
   DXML
   Generic
   Goto
   IBMESSL
   Intel
   Intel10_32
   Intel10_64lp
   Intel10_64lp_seq
   NAS
   OpenBLAS
   PhiPACK
   SCSL
   SGIMATH
   SunPerf
   )
 
 set(ENV{BLA_VENDOR} ${AKANTU_USE_BLAS_VENDOR})
 
 if(BLAS_mkl_core_LIBRARY)
   set(AKANTU_USE_BLAS_MKL CACHE INTERNAL "" FORCE)
 endif()
 
 package_set_package_system_dependency(BLAS deb libblas3)
 package_set_package_system_dependency(BLAS deb-src libblas3)
-
-package_declare_extra_files_to_package(BLAS
-  PROJECT
-    third-party/cmake/blas.cmake
-    third-party/blas_3.5.0_make.inc.cmake
-  )
diff --git a/packages/dumpers.cmake b/packages/dumpers.cmake
index 79fcfe832..407cc751f 100644
--- a/packages/dumpers.cmake
+++ b/packages/dumpers.cmake
@@ -1,64 +1,57 @@
 #===============================================================================
 # @file   dumpers.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Tue Jan 16 2018
 # @date last modification: Fri Mar 16 2018
 #
 # @brief  IO dumpers package description
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
-
 package_declare(dumpers
   DEFAULT ON
   DESCRIPTION "Dumpers for Akantu"
   DEPENDS INTERFACE IOHelper)
 
 package_declare_sources(dumpers
   io/dumper/dumpable_iohelper.hh
   io/dumper/dumper_compute.hh
   io/dumper/dumper_element_iterator.hh
   io/dumper/dumper_elemental_field.hh
   io/dumper/dumper_generic_elemental_field.hh
   io/dumper/dumper_generic_elemental_field_tmpl.hh
   io/dumper/dumper_homogenizing_field.hh
   io/dumper/dumper_internal_material_field.hh
   io/dumper/dumper_iohelper.cc
   io/dumper/dumper_iohelper.hh
   io/dumper/dumper_iohelper_paraview.cc
   io/dumper/dumper_iohelper_paraview.hh
   io/dumper/dumper_nodal_field.hh
   io/dumper/dumper_padding_helper.hh
   io/dumper/dumper_quadrature_point_iterator.hh
   io/dumper/dumper_text.cc
   io/dumper/dumper_text.hh
   io/dumper/dumper_type_traits.hh
   io/dumper/dumper_variable.hh
   )
-
-package_declare_extra_files_to_package(dumpers
-  PROJECT
-    third-party/cmake/iohelper.cmake
-    cmake/Modules/FindIOHelper.cmake
-  )
diff --git a/packages/google-test.cmake b/packages/google-test.cmake
index 010713667..aa7d46140 100644
--- a/packages/google-test.cmake
+++ b/packages/google-test.cmake
@@ -1,47 +1,47 @@
 #===============================================================================
 # @file   google-test.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Thu Nov 09 2017
 # @date last modification: Fri Mar 16 2018
 #
 # @brief  package for external dependency to google tests
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 package_declare(gtest EXTERNAL
   DESCRIPTION "Add GTest support for tests"
   SYSTEM AUTO third-party/cmake/gtest.cmake
   EXCLUDE_FROM_ALL
   )
 
 package_get_option_name(gtest _opt_name)
 if(AKANTU_TESTS)
   set(${_opt_name} ON CACHE BOOL "Add GTest support for tests (forced)" FORCE)
 endif()
 
 package_add_third_party_script_variable(google-test
-  GTEST_VERSION "master")
+  GTEST_VERSION "main")
 package_add_third_party_script_variable(google-test
   GTEST_GIT "https://github.com/google/googletest.git")
diff --git a/packages/iohelper.cmake b/packages/iohelper.cmake
index db89b78c6..7901ccce0 100644
--- a/packages/iohelper.cmake
+++ b/packages/iohelper.cmake
@@ -1,44 +1,52 @@
 #===============================================================================
 # @file   iohelper.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Tue Nov 29 2011
 # @date last modification: Fri Mar 16 2018
 #
 # @brief  package description for iohelper
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
+if(AKANTU_BYPASS_AKANTU_TARGET)
+  return()
+endif()
 
-package_declare(IOHelper EXTERNAL
+package_declare(IOHelper EXTERNAL NOT_OPTIONAL
   DESCRIPTION "Add IOHelper support in akantu"
   SYSTEM OFF third-party/cmake/iohelper.cmake
   DEFAULT ON)
 
 set(_version "1.1.1")
 package_add_third_party_script_variable(IOHelper
   IOHELPER_VERSION ${_version})
 package_add_third_party_script_variable(IOHelper
   IOHELPER_GIT "https://c4science.ch/source/iohelper.git")
 package_add_third_party_script_variable(IOHelper
   IOHELPER_ARCHIVE "iohelper_${_version}.tar.gz")
+
+package_declare_extra_files_to_package(dumpers
+  PROJECT
+  third-party/cmake/iohelper.cmake
+  )
diff --git a/packages/mumps.cmake b/packages/mumps.cmake
index 2e86f9f25..0b5fa473e 100644
--- a/packages/mumps.cmake
+++ b/packages/mumps.cmake
@@ -1,97 +1,72 @@
 #===============================================================================
 # @file   mumps.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Nov 21 2011
 # @date last modification: Wed Dec 18 2019
 #
 # @brief  package description for mumps support
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 package_declare(Mumps EXTERNAL
   DESCRIPTION "Add Mumps support in akantu"
-  SYSTEM ON
   )
 
 package_declare_sources(Mumps
   model/common/non_linear_solver/non_linear_solver_linear.cc
   model/common/non_linear_solver/non_linear_solver_linear.hh
   model/common/non_linear_solver/non_linear_solver_newton_raphson.cc
   model/common/non_linear_solver/non_linear_solver_newton_raphson.hh
   solver/sparse_solver_mumps.cc
   solver/sparse_solver_mumps.hh
   )
 
 set(_mumps_float_type ${AKANTU_FLOAT_TYPE})
 
 if(AKANTU_FLOAT_TYPE STREQUAL "float" OR
     AKANTU_FLOAT_TYPE STREQUAL "double")
   set(_mumps_components ${AKANTU_FLOAT_TYPE})
 else()
   if(DEFINED AKANTU_FLOAT_TYPE)
-    message(FATAL_ERROR "MUMPS doea not support floating point type \"${AKANTU_FLOAT_TYPE}\"")
+    message(FATAL_ERROR "MUMPS does not support floating point type \"${AKANTU_FLOAT_TYPE}\"")
   endif()
 endif()
 
 package_get_option_name(parallel _par_option)
 if(${_par_option})
-  package_set_find_package_extra_options(Mumps ARGS COMPONENTS "parallel" ${_mumps_components})
-  package_add_third_party_script_variable(Mumps MUMPS_TYPE "par")
-
+  list(APPEND _mumps_components "parallel")
   package_set_package_system_dependency(Mumps deb libmumps)
   package_set_package_system_dependency(Mumps deb-src libmumps-dev)
 else()
-  package_set_find_package_extra_options(Mumps ARGS COMPONENTS "sequential" ${_mumps_components})
-  package_add_third_party_script_variable(Mumps MUMPS_TYPE "seq")
-
+  list(APPEND _mumps_components "sequential")
   package_set_package_system_dependency(Mumps deb libmumps-seq)
   package_set_package_system_dependency(Mumps deb-src libmumps-seq-dev)
 endif()
 
-package_use_system(Mumps _use_system)
-if(NOT _use_system)
-  enable_language(Fortran)
-
-  set(AKANTU_USE_MUMPS_VERSION "4.10.0" CACHE STRING "Default Mumps version to compile")
-  mark_as_advanced(AKANTU_USE_MUMPS_VERSION)
-  set_property(CACHE AKANTU_USE_MUMPS_VERSION PROPERTY STRINGS "4.9.2" "4.10.0" "5.0.0")
-
-  package_get_option_name(MPI _mpi_option)
-  if(${_mpi_option})
-    package_add_dependencies(Mumps ScaLAPACK MPI)
-  endif()
-
-  package_add_dependencies(Mumps Scotch BLAS)
-endif()
-
+package_set_find_package_extra_options(Mumps ARGS COMPONENTS "${_mumps_components}")
 package_declare_extra_files_to_package(MUMPS
   PROJECT
-    third-party/MUMPS_4.10.0_make.inc.cmake
-    third-party/MUMPS_5.0.0.patch
-    third-party/MUMPS_4.10.0.patch
-    third-party/MUMPS_4.9.2_make.inc.cmake
-    third-party/cmake/mumps.cmake
     cmake/Modules/FindMumps.cmake
   )
diff --git a/packages/numpy.cmake b/packages/numpy.cmake
index 25cabc4d7..09d9339bb 100644
--- a/packages/numpy.cmake
+++ b/packages/numpy.cmake
@@ -1,39 +1,39 @@
 #===============================================================================
 # @file   numpy.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Jan 04 2013
 # @date last modification: Sat Jan 23 2016
 #
 # @brief  package description for the python library
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
-package_declare(Numpy EXTERNAL DESCRIPTION "Akantu's numpy dependance check")
+#package_declare(Numpy EXTERNAL DESCRIPTION "Akantu's numpy dependance check")
 
-package_set_package_system_dependency(Numpy deb python-numpy)
-package_set_package_system_dependency(Numpy deb-src python-numpy)
+#package_set_package_system_dependency(Numpy deb python-numpy)
+#package_set_package_system_dependency(Numpy deb-src python-numpy)
 
-package_declare_extra_files_to_package(Numpy
-  PROJECT cmake/Modules/FindNumpy.cmake)
+#package_declare_extra_files_to_package(Numpy
+#  PROJECT cmake/Modules/FindNumpy.cmake)
diff --git a/packages/pybind11.cmake b/packages/pybind11.cmake
index 5e258169e..5931ac988 100644
--- a/packages/pybind11.cmake
+++ b/packages/pybind11.cmake
@@ -1,47 +1,47 @@
 #===============================================================================
 # @file   pybind11.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Dec 22 2017
 # @date last modification: Wed Dec 04 2019
 #
 # @brief  package description for the pybind11 binding
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 set(PYBIND11_PYTHON_VERSION ${AKANTU_PREFERRED_PYTHON_VERSION} CACHE INTERNAL "")
 
 package_declare(pybind11 EXTERNAL
   EXTRA_PACKAGE_OPTIONS ARGS "2.4.2;CONFIG" LINK_LIBRARIES pybind11::embed PREFIX pybind11
   DESCRIPTION "Akantu's pybind11 interface"
   SYSTEM AUTO third-party/cmake/pybind11.cmake
-  DEPENDS PythonLibsNew
+  DEPENDS python
   EXCLUDE_FROM_ALL
   )
 
 package_add_third_party_script_variable(pybind11
   PYBIND11_VERSION "v2.4.2")
 package_add_third_party_script_variable(pybind11
   PYBIND11_GIT "https://github.com/pybind/pybind11.git")
diff --git a/packages/python.cmake b/packages/python.cmake
new file mode 100644
index 000000000..4e960383e
--- /dev/null
+++ b/packages/python.cmake
@@ -0,0 +1,80 @@
+#===============================================================================
+# @file   python_interpreter.cmake
+#
+# @author Nicolas Richart <nicolas.richart@epfl.ch>
+#
+# @date creation: Wed Oct 31 2018
+# @date last modification: Wed Oct 31 2018
+#
+# @brief  packages description for the external dependency to the python interpreted
+#
+#
+# @section LICENSE
+#
+# Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
+# Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+#
+# Akantu is free software: you can redistribute it and/or modify it under the
+# terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+# 
+# Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+# 
+# You should have received a copy of the GNU Lesser General Public License along
+# with Akantu. If not, see <http://www.gnu.org/licenses/>.
+#
+#===============================================================================
+if(FALSE AND CMAKE_VERSION VERSION_GREATER 3.21)
+  if (PYTHON_EXECUTABLE)
+    get_filename_component(_python_bin_dir "${PYTHON_EXECUTABLE}" DIRECTORY)
+    get_filename_component(_python_root_dir "${_python_bin_dir}" DIRECTORY)
+    set(Python_ROOT_DIR "${_python_bin_dir}" CACHE INTERNAL "")
+    message(STATUS "Python hint: ${Python_ROOT_DIR}")
+  endif()
+
+
+  package_declare(Python EXTERNAL DESCRIPTION "Akantu's python dependency"
+    EXTRA_PACKAGE_OPTIONS ARGS
+    COMPONENTS Interpreter;Development
+    )
+
+  package_on_enabled_script(Python
+    "set(Python_SITELIB \${Python_SITELIB} CACHE INTERNAL \"\")
+set(Python_EXECUTABLE \${Python_EXECUTABLE} CACHE INTERNAL \"\")
+set(Python_INCLUDE_DIRS \${Python_INCLUDE_DIRS} CACHE INTERNAL \"\")
+set(Python_VERSION_MAJOR \${Python_VERSION_MAJOR} CACHE INTERNAL \"\")
+set(Python_VERSION_MINOR \${Python_VERSION_MINOR} CACHE INTERNAL \"\")
+")
+else()
+  if (PYTHON_LIBRARY MATCHES "\.a$")
+    set(PYTHON_LIBRARY NOTFOUND CACHE INTERNAL "")
+  endif()
+  package_declare(Python ADVANCED META DESCRIPTION "Akantu's python dependency"
+    DEPENDS PythonLibsNew PythonInterp
+    )
+
+  package_declare(PythonInterp EXTERNAL
+    DESCRIPTION "Akantu's python Interpreter"
+    )
+
+  package_on_enabled_script(PythonInterp
+    "set(Python_EXECUTABLE \${PYTHON_EXECUTABLE} CACHE INTERNAL \"\")")
+
+  package_declare(PythonLibsNew EXTERNAL
+    DESCRIPTION "Akantu's python Development"
+    )
+
+  package_on_enabled_script(PythonLibsNew
+    "set(Python_INCLUDE_DIRS \${PYTHON_INCLUDE_DIRS} CACHE INTERNAL \"\")
+set(Python_VERSION_MAJOR \${PYTHON_VERSION_MAJOR} CACHE INTERNAL \"\")
+set(Python_VERSION_MINOR \${PYTHON_VERSION_MINOR} CACHE INTERNAL \"\")
+")
+
+  # package_declare(Numpy EXTERNAL
+  #   DESCRIPTION "Akantu's python Numpy"
+  #   )
+endif()
diff --git a/packages/python_interface.cmake b/packages/python_interface.cmake
index ddc4988e2..bed4e9a8d 100644
--- a/packages/python_interface.cmake
+++ b/packages/python_interface.cmake
@@ -1,36 +1,34 @@
 #===============================================================================
 # @file   python_interface.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Tue Nov 29 2011
 # @date last modification: Wed Nov 27 2019
 #
 # @brief  package description for the python interface
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
-
 package_declare(python_interface
-  DESCRIPTION "Akantu's python interface"
-  DEPENDS pybind11)
+  DESCRIPTION "Akantu's python interface")
diff --git a/packages/python_interpreter.cmake b/packages/python_interpreter.cmake
deleted file mode 100644
index a4a1b3313..000000000
--- a/packages/python_interpreter.cmake
+++ /dev/null
@@ -1,35 +0,0 @@
-#===============================================================================
-# @file   python_interpreter.cmake
-#
-# @author Nicolas Richart <nicolas.richart@epfl.ch>
-#
-# @date creation: Wed Oct 31 2018
-# @date last modification: Wed Oct 31 2018
-#
-# @brief  packages description for the external dependency to the python interpreted
-#
-#
-# @section LICENSE
-#
-# Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
-# Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
-#
-# Akantu is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-# 
-# Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-# details.
-# 
-# You should have received a copy of the GNU Lesser General Public License along
-# with Akantu. If not, see <http://www.gnu.org/licenses/>.
-#
-#===============================================================================
-
-
-package_declare(PythonInterp EXTERNAL DESCRIPTION "Akantu's python interpreter"
-  EXTRA_PACKAGE_OPTIONS ARGS ${AKANTU_PREFERRED_PYTHON_VERSION}
-  )
diff --git a/packages/pythonlibs.cmake b/packages/pythonlibs.cmake
deleted file mode 100644
index efb89cbc7..000000000
--- a/packages/pythonlibs.cmake
+++ /dev/null
@@ -1,51 +0,0 @@
-#===============================================================================
-# @file   pythonlibs.cmake
-#
-# @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
-# @author Nicolas Richart <nicolas.richart@epfl.ch>
-#
-# @date creation: Fri Sep 03 2010
-# @date last modification: Fri Jul 24 2020
-#
-# @brief  package description for the python library
-#
-#
-# @section LICENSE
-#
-# Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
-# Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
-#
-# Akantu is free software: you can redistribute it and/or modify it under the
-# terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-# 
-# Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-# details.
-# 
-# You should have received a copy of the GNU Lesser General Public License along
-# with Akantu. If not, see <http://www.gnu.org/licenses/>.
-#
-#===============================================================================
-
-
-package_declare(PythonLibsNew EXTERNAL DESCRIPTION "Akantu's python interface"
-  DEPENDS numpy
-  EXTRA_PACKAGE_OPTIONS ARGS ${AKANTU_PREFERRED_PYTHON_VERSION} PREFIX PYTHON FOUND PYTHONLIBS_FOUND
-  )
-
-package_on_enabled_script(PythonLibsNew
-  "set(PYTHON_MODULE_PREFIX \${PYTHON_MODULE_PREFIX} CACHE INTERNAL \"\")
-set(PYTHON_MODULE_EXTENSION \${PYTHON_MODULE_EXTENSION} CACHE INTERNAL \"\")
-set(PYTHON_VERSION_MAJOR \${PYTHON_VERSION_MAJOR} CACHE INTERNAL \"\")
-set(PYTHON_VERSION_MINOR \${PYTHON_VERSION_MINOR} CACHE INTERNAL \"\")
-set(PYTHON_SITE_PACKAGES \${PYTHON_SITE_PACKAGES} CACHE INTERNAL \"\")
-")
-
-
-if(AKANTU_PREFERRED_PYTHON_VERSION VERSION_GREATER 2.9)
-  package_set_package_system_dependency(PythonLibsNew deb libpython3)
-  package_set_package_system_dependency(PythonLibsNew deb-src libpython3-dev)
-endif()
diff --git a/packages/scalapack.cmake b/packages/scalapack.cmake
index 9164045af..16bd8ab43 100644
--- a/packages/scalapack.cmake
+++ b/packages/scalapack.cmake
@@ -1,54 +1,43 @@
 #===============================================================================
 # @file   scalapack.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Oct 19 2012
 # @date last modification: Fri Jan 22 2016
 #
 # @brief  package description for mumps support
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 package_declare(ScaLAPACK EXTERNAL
   DESCRIPTION "Add ScaLAPACK support in akantu"
-  SYSTEM OFF third-party/cmake/scalapack.cmake
   DEPENDS MPI
   )
 
-
-package_add_third_party_script_variable(ScaLAPACK
-  SCALAPACK_VERSION "2.0.2")
-package_add_third_party_script_variable(ScaLAPACK
-  SCALAPACK_ARCHIVE "http://www.netlib.org/scalapack/scalapack-${SCALAPACK_VERSION}.tgz")
-package_add_third_party_script_variable(ScaLAPACK
-  SCALAPACK_ARCHIVE_HASH_2.0.2 "MD5=2f75e600a2ba155ed9ce974a1c4b536f")
-
 package_set_package_system_dependency(ScaLAPACK deb-src libscalapack-mpi-dev)
 
 package_declare_extra_files_to_package(ScaLAPACK
   PROJECT
-    third-party/scalapack_2.0.2.patch
-    third-party/cmake/scalapack.cmake
     cmake/Modules/FindScaLAPACK.cmake
   )
diff --git a/packages/scotch.cmake b/packages/scotch.cmake
index af034c1f1..32e37a5cd 100644
--- a/packages/scotch.cmake
+++ b/packages/scotch.cmake
@@ -1,79 +1,65 @@
 #===============================================================================
 # @file   scotch.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Nov 21 2011
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  package description for scotch
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 
 package_declare(Scotch EXTERNAL
-  DESCRIPTION "Add Scotch support in akantu"
-  SYSTEM ON third-party/cmake/scotch.cmake)
+  DESCRIPTION "Add Scotch support in akantu")
 
 package_declare_sources(Scotch
   mesh_utils/mesh_partition/mesh_partition_scotch.cc
   )
 
-package_add_third_party_script_variable(Scotch
-  SCOTCH_VERSION "5.1.12b")
-package_add_third_party_script_variable(Scotch
-  SCOTCH_ARCHIVE_HASH "MD5=e13b49be804755470b159d7052764dc0")
-package_add_third_party_script_variable(Scotch
-  SCOTCH_ARCHIVE "scotch_${SCOTCH_VERSION}_esmumps.tar.gz")
-package_add_third_party_script_variable(Scotch
-  SCOTCH_URL "https://gforge.inria.fr/frs/download.php/28978/scotch_${SCOTCH_VERSION}_esmumps.tar.gz")
-
-
 package_get_option_name(Scotch _opt_name)
 package_use_system(Scotch _system)
 if(${_opt_name} AND _system)
   include(CheckTypeSize)
 
   package_get_include_dir(Scotch _include_dir)
   if(_include_dir)
     set(CMAKE_EXTRA_INCLUDE_FILES stdio.h scotch.h)
     set(CMAKE_REQUIRED_INCLUDES ${_include_dir})
     check_type_size("SCOTCH_Num" SCOTCH_NUM)
 
     if(SCOTCH_NUM AND NOT SCOTCH_NUM EQUAL AKANTU_INTEGER_SIZE)
       math(EXPR _n "${AKANTU_INTEGER_SIZE} * 8")
       message(SEND_ERROR "This version of Scotch cannot be used, it is compiled with the wrong size for SCOTCH_Num."
         "Recompile Scotch with the define -DINTSIZE${_n}. The current scotch integer size is ${SCOTCH_NUM}")
     endif()
   endif()
 endif()
 
 package_set_package_system_dependency(Scotch deb libscotch)
 package_set_package_system_dependency(Scotch deb-src libscotch-dev)
 
 package_declare_extra_files_to_package(Scotch
   PROJECT
-    third-party/cmake/scotch.cmake
-    third-party/scotch_5.1.12b.patch
-    third-party/scotch_5.1.12b_make.inc.cmake
     cmake/Modules/FindScotch.cmake
   )
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..eb75010ba
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,10 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel",
+    "pybind11~=2.6.0",
+    "scikit-build>=0.7.0",
+    "cmake>=3.5.3",
+    "ninja",
+]
+build-backend = "setuptools.build_meta"
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index a58bfb77a..4c76a6e89 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -1,145 +1,144 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Dec 12 2014
 # @date last modification: Fri May 07 2021
 #
 # @brief  CMake file for the python wrapping of akantu
 #
 #
 # @section LICENSE
 #
 # Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 # 
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 # 
 # You should have received a copy of the GNU Lesser General Public License along
 # with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
+set(PYBIND11_PYTHON_VERSION ${AKANTU_PREFERRED_PYTHON_VERSION} CACHE INTERNAL "")
 
 if(NOT SKBUILD)
   package_get_all_include_directories(
     AKANTU_LIBRARY_INCLUDE_DIRS
     )
 
   package_get_all_external_informations(
     PRIVATE_INCLUDE AKANTU_PRIVATE_EXTERNAL_INCLUDE_DIR
     INTERFACE_INCLUDE AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR
     LIBRARIES AKANTU_EXTERNAL_LIBRARIES
     )
 endif()
 
 set(PYAKANTU_SRCS
   py_aka_common.cc
   py_aka_error.cc
   py_akantu.cc
   py_boundary_conditions.cc
   py_dof_manager.cc
   py_fe_engine.cc
   py_group_manager.cc
   py_mesh.cc
   py_model.cc
   py_parser.cc
   py_solver.cc
+  py_dumpable.cc
   )
 
-package_is_activated(iohelper _is_activated)
-if (_is_activated)
-  list(APPEND PYAKANTU_SRCS
-    py_dumpable.cc
-    )
-endif()
-
-
 package_is_activated(solid_mechanics _is_activated)
 if (_is_activated)
   list(APPEND PYAKANTU_SRCS
     py_solid_mechanics_model.cc
     py_material.cc
     py_material_selector.cc
     )
 endif()
 
 package_is_activated(cohesive_element _is_activated)
 if (_is_activated)
   list(APPEND PYAKANTU_SRCS
     py_solid_mechanics_model_cohesive.cc
     py_fragment_manager.cc
     )
 endif()
 
 package_is_activated(heat_transfer _is_activated)
 if (_is_activated)
   list(APPEND PYAKANTU_SRCS
     py_heat_transfer_model.cc
     )
 endif()
 
 
 package_is_activated(contact_mechanics _is_activated)
 if(_is_activated)
   list(APPEND PYAKANTU_SRCS
     py_contact_mechanics_model.cc
     py_model_couplers.cc
     )
 endif()
 
 package_is_activated(phase_field _is_activated)
 if (_is_activated)
   list(APPEND PYAKANTU_SRCS
     py_phase_field_model.cc
     )
 endif()
 
 package_is_activated(structural_mechanics _is_activated)
 if (_is_activated)
   list(APPEND PYAKANTU_SRCS
     py_structural_mechanics_model.cc
     )
 endif()
 
 pybind11_add_module(py11_akantu ${PYAKANTU_SRCS})
 
 # to avoid compilation warnings from pybind11
 target_include_directories(py11_akantu
   SYSTEM BEFORE
   PRIVATE ${PYBIND11_INCLUDE_DIR}
   PRIVATE ${pybind11_INCLUDE_DIR}
-  PRIVATE ${PYTHON_INCLUDE_DIRS})
+  PRIVATE ${Python_INCLUDE_DIRS})
 
 target_link_libraries(py11_akantu PUBLIC akantu)
 set_target_properties(py11_akantu PROPERTIES
   DEBUG_POSTFIX ""
   LIBRARY_OUTPUT_DIRECTORY akantu)
 
 file(COPY akantu DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 
+if(NOT Python_MAJOR)
+  set(Python_VERSION_MAJOR ${PYTHON_VERSION_MAJOR})
+  set(Python_VERSION_MINOR ${PYTHON_VERSION_MINOR})
+endif()
+
 if(NOT SKBUILD)
   set(_python_install_dir
-    ${CMAKE_INSTALL_LIBDIR}/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
+    ${CMAKE_INSTALL_LIBDIR}/python${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}/site-packages/akantu)
 else()
-  set(_python_install_dir .)
+  set(_python_install_dir python/akantu)
 endif()
 
 install(TARGETS py11_akantu
   LIBRARY DESTINATION ${_python_install_dir})
 
 if(NOT SKBUILD)
   install(DIRECTORY akantu
     DESTINATION ${_python_install_dir}
     FILES_MATCHING PATTERN "*.py")
 endif()
diff --git a/python/py_akantu.cc b/python/py_akantu.cc
index 3c88c1e5c..85cb2fde6 100644
--- a/python/py_akantu.cc
+++ b/python/py_akantu.cc
@@ -1,174 +1,169 @@
 /**
  * @file   py_akantu.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Philip Mueller <philip.paul.mueller@bluemail.ch>
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Oct 31 2018
  * @date last modification: Mon Mar 29 2021
  *
  * @brief  pybind11 interface to akantu main's file
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_config.hh"
 /* -------------------------------------------------------------------------- */
 #include "py_aka_common.hh"
 #include "py_aka_error.hh"
 #include "py_boundary_conditions.hh"
 #include "py_dof_manager.hh"
+#include "py_dumpable.hh"
 #include "py_fe_engine.hh"
 #include "py_group_manager.hh"
 #include "py_mesh.hh"
 #include "py_model.hh"
 #include "py_parser.hh"
 #include "py_solver.hh"
 
-#if defined(AKANTU_USE_IOHELPER)
-#include "py_dumpable.hh"
-#endif
-
 #if defined(AKANTU_SOLID_MECHANICS)
 #include "py_material.hh"
 #include "py_material_selector.hh"
 #include "py_solid_mechanics_model.hh"
 #endif
 
 #if defined(AKANTU_HEAT_TRANSFER)
 #include "py_heat_transfer_model.hh"
 #endif
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "py_fragment_manager.hh"
 #include "py_solid_mechanics_model_cohesive.hh"
 #endif
 
 #if defined(AKANTU_CONTACT_MECHANICS)
 #include "py_contact_mechanics_model.hh"
 #include "py_model_couplers.hh"
 #endif
 
 #if defined(AKANTU_PHASE_FIELD)
 #include "py_phase_field_model.hh"
 #endif
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
 #include "py_structural_mechanics_model.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include <aka_error.hh>
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 namespace py = pybind11;
 
 namespace akantu {
 void register_all(pybind11::module & mod) {
   register_initialize(mod);
   register_enums(mod);
   register_error(mod);
   register_functions(mod);
   register_parser(mod);
   register_solvers(mod);
 
   register_group_manager(mod);
-#if defined(AKANTU_USE_IOHELPER)
   register_dumpable(mod);
-#endif
   register_mesh(mod);
 
   register_fe_engine(mod);
 
   register_dof_manager(mod);
 
   register_boundary_conditions(mod);
   register_model(mod);
 #if defined(AKANTU_HEAT_TRANSFER)
   register_heat_transfer_model(mod);
 #endif
 
 #if defined(AKANTU_SOLID_MECHANICS)
   register_solid_mechanics_model(mod);
   register_material(mod);
   register_material_selector(mod);
 #endif
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
   register_solid_mechanics_model_cohesive(mod);
   register_fragment_manager(mod);
 #endif
 
 #if defined(AKANTU_STRUCTURAL_MECHANICS)
   register_structural_mechanics_model(mod);
 #endif
 
 #if defined(AKANTU_CONTACT_MECHANICS)
   register_contact_mechanics_model(mod);
   register_model_couplers(mod);
 #endif
 
 #if defined(AKANTU_PHASE_FIELD)
   register_phase_field_model(mod);
   register_phase_field_coupler(mod);
 #endif
 }
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 PYBIND11_MODULE(py11_akantu, mod) {
   mod.doc() = "Akantu python interface";
 
   static py::exception<akantu::debug::Exception> akantu_exception(mod,
                                                                   "Exception");
 
   py::register_exception_translator([](std::exception_ptr ptr) {
     try {
       if (ptr) {
         std::rethrow_exception(ptr);
       }
     } catch (akantu::debug::Exception & e) {
       if (akantu::debug::debugger.printBacktrace()) {
         akantu::debug::printBacktrace();
       }
       akantu_exception(e.info().c_str());
     }
   });
 
   akantu::register_all(mod);
 
   mod.def("has_mpi", []() {
 #if defined(AKANTU_USE_MPI)
     return true;
 #else
     return false;
 #endif
   });
 
 } // Module akantu
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 000000000..c8a4ee85a
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,29 @@
+
+# See the docstring in versioneer.py for instructions. Note that you must
+# re-run 'versioneer.py setup' after changing this section, and commit the
+# resulting files.
+
+[versioneer]
+VCS = git
+style = pep440
+versionfile_source = python/akantu/_version.py
+versionfile_build = akantu/_version.py
+tag_prefix = v
+verbose = true
+#parentdir_prefix =
+
+[cmake_config]
+AKANTU_COHESIVE_ELEMENT = TRUE
+AKANTU_IMPLICIT = TRUE
+AKANTU_PARALLEL = FALSE
+AKANTU_STRUCTURAL_MECHANICS = TRUE
+AKANTU_HEAT_TRANSFER = TRUE
+AKANTU_DAMAGE_NON_LOCAL = TRUE
+AKANTU_PHASE_FIELD = TRUE
+AKANTU_PYTHON_INTERFACE = TRUE
+AKANTU_CONTACT_MECHANICS = TRUE
+AKANTU_EXAMPLES = FALSE
+AKANTU_TESTS = FALSE
+CMAKE_JOB_POOL_COMPILE = compile
+CMAKE_JOB_POOL_LINK = link
+CMAKE_JOB_POOLS = 'compile=10;link=2'
diff --git a/setup.py b/setup.py
new file mode 100755
index 000000000..740d2f777
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import sys
+import os.path
+import pybind11 as py11
+import configparser
+from setuptools import find_packages
+from packaging.version import LegacyVersion
+from skbuild.exceptions import SKBuildError
+from skbuild.cmaker import get_cmake_version
+
+try:
+    from skbuild import setup
+except ImportError:
+    sys.stderr.write(
+        "Please update pip, you need pip 10 or greater,\n"
+        " or you need to install the PEP 518 requirements in"
+        " pyproject.toml yourself"
+    )
+    raise
+
+# This is needed for versioneer to be importable when building with PEP 517.
+# See <https://github.com/warner/python-versioneer/issues/193> and links
+# therein for more information.
+source_folder = os.path.dirname(__file__)
+sys.path.append(source_folder)
+
+parser = configparser.ConfigParser()
+parser.read("setup.cfg")
+cmake_args = ["-Dpybind11_DIR:PATH={}".format(py11.get_cmake_dir())]
+
+_version = None
+if ("cmake_config" in parser) and ("akantu_dir" in parser["cmake_config"]):
+    sys.path.append(parser["cmake_config"]["akantu_dir"])
+    try:
+        import akantu_version
+
+        _version = akantu_version.get_version()
+    except ImportError:
+        pass
+
+try:
+    import versioneer
+
+    if not _version:
+        _version = versioneer.get_version()
+    setup_kw = {
+        "version": _version,
+        "cmdclass": versioneer.get_cmdclass(),
+    }
+    cmake_args.append("-DAKANTU_VERSION={}".format(_version))
+except ImportError:
+    # see https://github.com/warner/python-versioneer/issues/192
+    print("WARNING: failed to import versioneer," " falling back to no version for now")
+    setup_kw = {}
+
+
+if "cmake_config" in parser:
+    for k, v in parser["cmake_config"].items():
+        k = k.upper()
+        cmake_args.append("-D{}:BOOL={}".format(k, v))
+
+akantu_libs = []
+
+if "CI_AKANTU_INSTALL_PREFIX" in os.environ:
+    akantu_libs.extend(
+        [
+            # paths comming from the manylinux install via gitlab-ci
+            "/softs/view/lib/*",
+            "/softs/view/lib64/*",
+            os.path.join(os.environ["CI_AKANTU_INSTALL_PREFIX"], "lib64/*"),
+            os.path.join(os.environ["CI_AKANTU_INSTALL_PREFIX"], "lib/*"),
+        ]
+    )
+    cmake_args.extend(
+        [
+            "-DAKANTU_BYPASS_AKANTU_TARGET:BOOL=ON",
+            "-DAkantu_DIR:PATH={}".format(
+                os.path.join(
+                    os.environ["CI_AKANTU_INSTALL_PREFIX"], "lib", "cmake", "Akantu"
+                )
+            ),
+        ]
+    )
+
+# Add CMake as a build requirement if cmake is not installed or is too low a
+# version
+setup_requires = []
+try:
+    if LegacyVersion(get_cmake_version()) < LegacyVersion("3.4"):
+        setup_requires.append("cmake")
+except SKBuildError:
+    setup_requires.append("cmake")
+
+
+with open(os.path.join(source_folder, "README.md"), "r") as fh:
+    long_description = fh.read()
+
+setup(
+    name="akantu",
+    url="https://akantu.ch",
+    author="Nicolas Richart",
+    author_email="nicolas.richart@epfl.ch",
+    description="Akantu: Swiss-Made Open-Source Finite-Element Library",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    platforms="",
+    license="L-GPLv3",
+    license_files=["COPYING", "COPYING.lesser"],
+    project_urls={
+        "Bug Tracker": "https://github.com/akantu/akantu/issues",
+    },
+    setup_requires=setup_requires,
+    install_requires=["numpy", "scipy"],
+    package_data={"AkantuLibs": akantu_libs},
+    packages=find_packages(where="python"),
+    package_dir={"": "python"},
+    include_package_data=False,
+    cmake_args=cmake_args,
+    cmake_languages=["CXX"],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Environment :: Console",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Education",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+        "Natural Language :: English",
+        "Operating System :: POSIX :: Linux",
+        "Programming Language :: C++",
+        "Programming Language :: Python",
+        "Topic :: Education",
+        "Topic :: Scientific/Engineering",
+    ],
+    **setup_kw
+)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 1e52131e6..e9e2790a2 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,264 +1,269 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Jun 14 2010
 # @date last modification: Tue Feb 13 2018
 #
 # @brief  CMake file for the library
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free software: you can redistribute it and/or modify it under the
 # terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 # details.
 #
 # You should have received a copy of the GNU Lesser General Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #===============================================================================
 # Package Management
 #===============================================================================
 package_get_all_source_files(
   AKANTU_LIBRARY_SRCS
   AKANTU_LIBRARY_PUBLIC_HDRS
   AKANTU_LIBRARY_PRIVATE_HDRS
   )
 
 package_get_all_include_directories(
   AKANTU_LIBRARY_INCLUDE_DIRS
   )
 
 package_get_all_external_informations(
   PRIVATE_INCLUDE AKANTU_PRIVATE_EXTERNAL_INCLUDE_DIR
   INTERFACE_INCLUDE AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR
   LIBRARIES AKANTU_EXTERNAL_LIBRARIES
   )
 
 package_get_all_compilation_flags(CXX _cxx_flags)
 set(AKANTU_EXTRA_CXX_FLAGS
   "${_cxx_flags}" CACHE STRING "Extra flags defined by loaded packages" FORCE)
 mark_as_advanced(AKANTU_EXTRA_CXX_FLAGS)
 
 foreach(src_ ${AKANTU_SPIRIT_SOURCES})
   set_property(SOURCE ${src_} PROPERTY COMPILE_FLAGS "-g0 -Werror")
 endforeach()
 
 #===========================================================================
 # header for blas/lapack (any other fortran libraries)
 #===========================================================================
 package_is_activated(BLAS _blas_activated)
 package_is_activated(LAPACK _lapack_activated)
 
 if(_blas_activated OR _lapack_activated)
   if(CMAKE_Fortran_COMPILER)
     # ugly hack
     set(CMAKE_Fortran_COMPILER_LOADED TRUE)
   endif()
 
   include(FortranCInterface)
   FortranCInterface_HEADER(
     "${CMAKE_CURRENT_BINARY_DIR}/aka_fortran_mangling.hh"
     MACRO_NAMESPACE "AKA_FC_")
   mark_as_advanced(CDEFS)
   list(APPEND AKANTU_LIBRARY_PUBLIC_HDRS
     "${CMAKE_CURRENT_BINARY_DIR}/aka_fortran_mangling.hh"
     )
 endif()
 
 list(APPEND AKANTU_LIBRARY_INCLUDE_DIRS "${CMAKE_CURRENT_BINARY_DIR}")
 set(AKANTU_INCLUDE_DIRS
   ${CMAKE_CURRENT_BINARY_DIR} ${AKANTU_LIBRARY_INCLUDE_DIRS}
   CACHE INTERNAL "Internal include directories to link with Akantu as a subproject")
 
 #===========================================================================
 # configurations
 #===========================================================================
 package_get_all_material_includes(AKANTU_MATERIAL_INCLUDES)
 package_get_all_material_lists(AKANTU_MATERIAL_LISTS)
 configure_file(model/solid_mechanics/material_list.hh.in
   "${CMAKE_CURRENT_BINARY_DIR}/material_list.hh" @ONLY)
 
 package_get_element_lists()
 configure_file(common/aka_element_classes_info.hh.in
   "${CMAKE_CURRENT_BINARY_DIR}/aka_element_classes_info.hh" @ONLY)
 
 configure_file(common/aka_config.hh.in
   "${CMAKE_CURRENT_BINARY_DIR}/aka_config.hh" @ONLY)
 
 list(APPEND AKANTU_LIBRARY_PUBLIC_HDRS
   "${CMAKE_CURRENT_BINARY_DIR}/material_list.hh"
   "${CMAKE_CURRENT_BINARY_DIR}/aka_element_classes_info.hh"
   "${CMAKE_CURRENT_BINARY_DIR}/aka_config.hh")
 
 #===============================================================================
 # Debug infos
 #===============================================================================
 set(AKANTU_GDB_DIR ${PROJECT_SOURCE_DIR}/cmake)
 if(UNIX AND NOT APPLE)
   string(TOUPPER "${CMAKE_BUILD_TYPE}" _u_build_type)
   if(_u_build_type STREQUAL "DEBUG" OR _u_build_type STREQUAL "RELWITHDEBINFO")
     configure_file(${PROJECT_SOURCE_DIR}/cmake/libakantu-gdb.py.in
       "${PROJECT_BINARY_DIR}/libakantu-gdb.py"
       @ONLY)
     configure_file(${PROJECT_SOURCE_DIR}/cmake/akantu-debug.cc.in
       "${PROJECT_BINARY_DIR}/akantu-debug.cc" @ONLY)
 
     list(APPEND AKANTU_LIBRARY_SRCS ${PROJECT_BINARY_DIR}/akantu-debug.cc)
   endif()
 else()
   find_program(GDB_EXECUTABLE gdb)
 
   if(GDB_EXECUTABLE)
     execute_process(COMMAND
       ${GDB_EXECUTABLE} --batch -x "${PROJECT_SOURCE_DIR}/cmake/gdb_python_path"
       OUTPUT_VARIABLE AKANTU_PYTHON_GDB_DIR
       ERROR_QUIET
       RESULT_VARIABLE _res)
 
     if(_res EQUAL 0 AND UNIX)
       set(GDB_USER_CONFIG $ENV{HOME}/.gdb/auto-load)
       file(MAKE_DIRECTORY ${GDB_USER_CONFIG})
 
       configure_file(${PROJECT_SOURCE_DIR}/cmake/libakantu-gdb.py.in
         "${GDB_USER_CONFIG}/${CMAKE_SHARED_LIBRARY_PREFIX}akantu${CMAKE_SHARED_LIBRARY_SUFFIX}.${AKANTU_VERSION}-gdb.py"
         @ONLY)
     endif()
   endif()
 endif()
 
 #===============================================================================
 # GIT info
 #===============================================================================
 
 #include(AkantuBuildOptions)
 #git_version_info(akantu_git_info ALL
 #  OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/akantu_git_info.hh
 #  )
 #list(APPEND AKANTU_LIBRARY_SRCS ${CMAKE_CURRENT_BINARY_DIR}/akantu_git_info.hh)
 #===============================================================================
 # Library generation
 #===============================================================================
 add_library(akantu ${AKANTU_LIBRARY_SRCS})
 
 target_include_directories(akantu
   PRIVATE   $<BUILD_INTERFACE:${AKANTU_INCLUDE_DIRS}>
   INTERFACE $<INSTALL_INTERFACE:include/akantu>
   )
 
 # small trick for build includes in public
 set_property(TARGET akantu APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES
   $<BUILD_INTERFACE:${AKANTU_INCLUDE_DIRS}>)
 
 target_include_directories(akantu SYSTEM
   PUBLIC ${AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR}
   )
 
 target_include_directories(akantu SYSTEM
   PRIVATE ${AKANTU_PRIVATE_EXTERNAL_INCLUDE_DIR}
   )
 
 target_link_libraries(akantu PUBLIC ${AKANTU_EXTERNAL_LIBRARIES})
 
 set_target_properties(akantu
   PROPERTIES
     ${AKANTU_LIBRARY_PROPERTIES} # this contains the version
     COMPILE_FLAGS "${_cxx_flags}"
     #PRIVATE_HEADER ${AKANTU_LIBRARY_PRIVATE_HDRS}
-    )
+)
 
+if(NOT AKANTU_SHARED)
+  set_property(TARGET akantu PROPERTY
+    POSITION_INDEPENDENT_CODE ${AKANTU_POSITION_INDEPENDENT})
+endif()
+  
 if(AKANTU_LIBRARY_PUBLIC_HDRS)
   set_property(TARGET akantu PROPERTY PUBLIC_HEADER ${AKANTU_LIBRARY_PUBLIC_HDRS})
 endif()
 
 if(AKANTU_LIBRARY_PRIVATE_HDRS)
   set_property(TARGET akantu PROPERTY PRIVATE_HEADER ${AKANTU_LIBRARY_PRIVATE_HDRS})
 endif()
 
 if(NOT CMAKE_VERSION VERSION_LESS 3.1)
   package_get_all_features_public(_PUBLIC_features)
   package_get_all_features_private(_PRIVATE_features)
   foreach(_type PRIVATE PUBLIC)
     if(_${_type}_features)
       target_compile_features(akantu ${_type} ${_${_type}_features})
     endif()
   endforeach()
 else()
   set_target_properties(akantu
     PROPERTIES
     CXX_STANDARD 14
     )
 endif()
 
 package_get_all_extra_dependencies(_extra_target_dependencies)
 if(_extra_target_dependencies)
   # This only adding todo: find a solution for when a dependency was add the is removed...
   add_dependencies(akantu ${_extra_target_dependencies})
 endif()
 
 package_get_all_export_list(AKANTU_EXPORT_LIST)
 list(APPEND AKANTU_EXPORT_LIST akantu)
 
 
 # TODO separate public from private headers
 install(TARGETS akantu
   EXPORT ${AKANTU_TARGETS_EXPORT}
   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
           COMPONENT Akantu_runtime
   #         NAMELINK_ONLY
   # LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
   #         COMPONENT Akantu_development
   #         NAMELINK_SKIP Akantu_development
   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
           COMPONENT Akantu_runtime
   RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
           COMPONENT Akantu_runtime
   PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/akantu/
           COMPONENT Akantu_development
   )
 
 if("${AKANTU_TARGETS_EXPORT}" STREQUAL "AkantuTargets")
   install(EXPORT AkantuTargets
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/${PROJECT_NAME}
+    DESTINATION lib/cmake/${PROJECT_NAME}
     COMPONENT dev)
 
   #Export for build tree
   export(EXPORT AkantuTargets
     FILE "${CMAKE_BINARY_DIR}/AkantuTargets.cmake")
   export(PACKAGE Akantu)
 endif()
 
 #===============================================================================
 # Adding module names for debug
 package_get_all_packages(_pkg_list)
 foreach(_pkg ${_pkg_list})
   _package_get_real_name(${_pkg} _pkg_name)
   _package_get_source_files(${_pkg} _srcs _public_hdrs _private_hdrs)
   string(TOLOWER "${_pkg_name}" _l_package_name)
   set_property(SOURCE ${_srcs} ${_public_hdrs} ${_private_hdrs} 
     APPEND PROPERTY COMPILE_DEFINITIONS AKANTU_MODULE=${_l_package_name})
 endforeach()
 
 # print out the list of materials
 generate_material_list()
 
 register_target_to_tidy(akantu)
 register_tidy_all(${AKANTU_LIBRARY_SRCS})
 register_code_to_format(
   ${AKANTU_LIBRARY_SRCS}
   ${AKANTU_LIBRARY_PUBLIC_HDRS}
   ${AKANTU_LIBRARY_PRIVATE_HDRS}
   )
diff --git a/src/common/aka_config.hh.in b/src/common/aka_config.hh.in
index 1f51f6d11..d72744c92 100644
--- a/src/common/aka_config.hh.in
+++ b/src/common/aka_config.hh.in
@@ -1,94 +1,96 @@
 /**
  * @file   aka_config.hh.in
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Sep 26 2010
  * @date last modification: Thu Jan 25 2018
  *
  * @brief  Compilation time configuration of Akantu
  *
  *
- * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
+ * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
- * Akantu is free  software: you can redistribute it and/or  modify it under the terms  of the  GNU Lesser  General Public  License as published by  the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * Akantu is free  software: you can redistribute it and/or  modify it under the
+ * terms  of the  GNU Lesser  General Public  License as published by  the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
  *
- * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more details.
+ * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
+ * details.
  *
- * You should  have received  a copy  of the GNU  Lesser General  Public License along with Akantu. If not, see <http://www.gnu.org/licenses/>.
+ * You should  have received  a copy  of the GNU  Lesser General  Public License
+ * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef AKANTU_AKA_CONFIG_HH_
 #define AKANTU_AKA_CONFIG_HH_
 
+// clang-format off
 #define AKANTU_VERSION_MAJOR @AKANTU_MAJOR_VERSION@
 #define AKANTU_VERSION_MINOR @AKANTU_MINOR_VERSION@
 #define AKANTU_VERSION_PATCH @AKANTU_PATCH_VERSION@
+#define AKANTU_VERSION_LOCAL "@AKANTU_LOCAL_VERSION@"
 #define AKANTU_VERSION (AKANTU_VERSION_MAJOR * 10000 \
                         + AKANTU_VERSION_MINOR * 100 \
                         + AKANTU_VERSION_PATCH)
 
+
 @AKANTU_TYPES_EXTRA_INCLUDES@
 namespace akantu {
 using Real = @AKANTU_FLOAT_TYPE@;
 using Int = @AKANTU_SIGNED_INTEGER_TYPE@;
 using UInt = @AKANTU_UNSIGNED_INTEGER_TYPE@;
 } // akantu
 
 #define AKANTU_INTEGER_SIZE @AKANTU_INTEGER_SIZE@
 #define AKANTU_FLOAT_SIZE @AKANTU_FLOAT_SIZE@
-
-#cmakedefine AKANTU_HAS_STRDUP
+// clang-format on
 
 #cmakedefine AKANTU_USE_BLAS
 #cmakedefine AKANTU_USE_LAPACK
 
 #cmakedefine AKANTU_PARALLEL
 #cmakedefine AKANTU_USE_MPI
 
 #cmakedefine AKANTU_USE_SCOTCH
 #cmakedefine AKANTU_USE_PTSCOTCH
 #cmakedefine AKANTU_SCOTCH_NO_EXTERN
 
 #cmakedefine AKANTU_IMPLICIT
 #cmakedefine AKANTU_USE_MUMPS
 #cmakedefine AKANTU_USE_PETSC
 
-#cmakedefine AKANTU_USE_IOHELPER
-#cmakedefine AKANTU_USE_QVIEW
-#cmakedefine AKANTU_USE_BLACKDYNAMITE
-
 #cmakedefine AKANTU_USE_PYBIND11
 
-#cmakedefine AKANTU_USE_OBSOLETE_GETTIMEOFDAY
-
 #cmakedefine AKANTU_EXTRA_MATERIALS
 #cmakedefine AKANTU_STUDENTS_EXTRA_PACKAGE
 #cmakedefine AKANTU_DAMAGE_NON_LOCAL
 
 #cmakedefine AKANTU_SOLID_MECHANICS
 #cmakedefine AKANTU_STRUCTURAL_MECHANICS
 #cmakedefine AKANTU_HEAT_TRANSFER
 #cmakedefine AKANTU_PHASE_FIELD
-#cmakedefine AKANTU_PYTHON_INTERFACE
 
 #cmakedefine AKANTU_COHESIVE_ELEMENT
-#cmakedefine AKANTU_PARALLEL_COHESIVE_ELEMENT
 
 #cmakedefine AKANTU_CONTACT_MECHANICS
 #cmakedefine AKANTU_MODEL_COUPLERS
 
 #cmakedefine AKANTU_IGFEM
-
-#cmakedefine AKANTU_USE_CGAL
 #cmakedefine AKANTU_EMBEDDED
 
+// clang-format off
 // Debug tools
 //#cmakedefine AKANTU_NDEBUG
 #cmakedefine AKANTU_DEBUG_TOOLS
 #cmakedefine READLINK_COMMAND @READLINK_COMMAND@
 #cmakedefine ADDR2LINE_COMMAND @ADDR2LINE_COMMAND@
+// clang-format on
 
 #endif /* AKANTU_AKA_CONFIG_HH_ */
diff --git a/src/io/dumper/dumpable.cc b/src/io/dumper/dumpable.cc
index 36a184a3a..9944aa68e 100644
--- a/src/io/dumper/dumpable.cc
+++ b/src/io/dumper/dumpable.cc
@@ -1,279 +1,273 @@
 /**
  * @file   dumpable.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Fri Feb 28 2020
  *
  * @brief  Implementation of the dumpable interface
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumpable.hh"
 /* -------------------------------------------------------------------------- */
-
-#ifdef AKANTU_USE_IOHELPER
-
 #include <io_helper.hh>
 #include <utility>
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Dumpable::Dumpable() = default;
 
 /* -------------------------------------------------------------------------- */
 Dumpable::~Dumpable() = default;
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::registerExternalDumper(std::shared_ptr<DumperIOHelper> dumper,
                                       const std::string & dumper_name,
                                       const bool is_default) {
   this->dumpers[dumper_name] = std::move(dumper);
   if (is_default) {
     this->default_dumper = dumper_name;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpMesh(const Mesh & mesh, UInt spatial_dimension,
                            GhostType ghost_type, ElementKind element_kind) {
 
   this->addDumpMeshToDumper(this->default_dumper, mesh, spatial_dimension,
                             ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpMeshToDumper(const std::string & dumper_name,
                                    const Mesh & mesh, UInt spatial_dimension,
                                    GhostType ghost_type,
                                    ElementKind element_kind) {
 
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerMesh(mesh, spatial_dimension, ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFilteredMesh(
     const Mesh & mesh, const ElementTypeMapArray<UInt> & elements_filter,
     const Array<UInt> & nodes_filter, UInt spatial_dimension,
     GhostType ghost_type, ElementKind element_kind) {
   this->addDumpFilteredMeshToDumper(this->default_dumper, mesh, elements_filter,
                                     nodes_filter, spatial_dimension, ghost_type,
                                     element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFilteredMeshToDumper(
     const std::string & dumper_name, const Mesh & mesh,
     const ElementTypeMapArray<UInt> & elements_filter,
     const Array<UInt> & nodes_filter, UInt spatial_dimension,
     GhostType ghost_type, ElementKind element_kind) {
 
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerFilteredMesh(mesh, elements_filter, nodes_filter,
                               spatial_dimension, ghost_type, element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpField(const std::string & field_id) {
   this->addDumpFieldToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldToDumper(__attribute__((unused))
                                     const std::string & dumper_name,
                                     __attribute__((unused))
                                     const std::string & field_id) {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                     std::shared_ptr<dumpers::Field> field) {
   this->addDumpFieldExternalToDumper(this->default_dumper, field_id,
                                      std::move(field));
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldExternalToDumper(
     const std::string & dumper_name, const std::string & field_id,
     std::shared_ptr<dumpers::Field> field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, std::move(field));
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::removeDumpField(const std::string & field_id) {
   this->removeDumpFieldFromDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::removeDumpFieldFromDumper(const std::string & dumper_name,
                                          const std::string & field_id) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.unRegisterField(field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldVector(const std::string & field_id) {
   this->addDumpFieldVectorToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldVectorToDumper(const std::string & /*dumper_name*/,
                                           const std::string & /*field_id*/) {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldTensor(const std::string & field_id) {
   this->addDumpFieldTensorToDumper(this->default_dumper, field_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::addDumpFieldTensorToDumper(__attribute__((unused))
                                           const std::string & dumper_name,
                                           __attribute__((unused))
                                           const std::string & field_id) {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setDirectory(const std::string & directory) {
   this->setDirectoryToDumper(this->default_dumper, directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setDirectoryToDumper(const std::string & dumper_name,
                                     const std::string & directory) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setBaseName(const std::string & basename) {
   this->setBaseNameToDumper(this->default_dumper, basename);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setBaseNameToDumper(const std::string & dumper_name,
                                    const std::string & basename) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setBaseName(basename);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTimeStepToDumper(Real time_step) {
   this->setTimeStepToDumper(this->default_dumper, time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTimeStepToDumper(const std::string & dumper_name,
                                    Real time_step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.setTimeStep(time_step);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::setTextModeToDumper(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.getDumper().setMode(iohelper::TEXT);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::setTextModeToDumper() {
   DumperIOHelper & dumper = this->getDumper(this->default_dumper);
   dumper.getDumper().setMode(iohelper::TEXT);
 }
 
 /* -------------------------------------------------------------------------- */
 
 void Dumpable::dump(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump() { this->dump(this->default_dumper); }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(const std::string & dumper_name, UInt step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(UInt step) { this->dump(this->default_dumper, step); }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(const std::string & dumper_name, Real time, UInt step) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.dump(time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::dump(Real time, UInt step) {
   this->dump(this->default_dumper, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Dumpable::internalAddDumpFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     std::shared_ptr<dumpers::Field> field) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, std::move(field));
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Dumpable::getDumper() {
   return this->getDumper(this->default_dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Dumpable::getDumper(const std::string & dumper_name) {
 
   auto it = this->dumpers.find(dumper_name);
   auto end = this->dumpers.end();
 
   if (it == end) {
-    AKANTU_EXCEPTION("Dumper " << dumper_name
-                               << "has not been registered, yet.");
+    AKANTU_EXCEPTION("Dumper \"" << dumper_name
+                                 << "\" has not been registered, yet.");
   }
 
   return *(it->second);
 }
 
 /* -------------------------------------------------------------------------- */
-
 std::string Dumpable::getDefaultDumperName() const {
   return this->default_dumper;
 }
 
 } // namespace akantu
-
-#endif
diff --git a/src/io/dumper/dumpable.hh b/src/io/dumper/dumpable.hh
index cc09253b4..a2bff4891 100644
--- a/src/io/dumper/dumpable.hh
+++ b/src/io/dumper/dumpable.hh
@@ -1,48 +1,44 @@
 /**
  * @file   dumpable.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: Tue Oct 01 2019
  *
  * @brief  Interface for object who wants to dump themselves
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "element_type_map.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_DUMPABLE_HH_
 #define AKANTU_DUMPABLE_HH_
 
-#ifdef AKANTU_USE_IOHELPER
 #include "dumpable_iohelper.hh"
-#else
-#include "dumpable_dummy.hh"
-#endif // AKANTU_USE_IOHELPER
 
 #endif /* AKANTU_DUMPABLE_HH_ */
diff --git a/src/io/dumper/dumpable_inline_impl.hh b/src/io/dumper/dumpable_inline_impl.hh
index 3f36c0a0e..2aa99cabc 100644
--- a/src/io/dumper/dumpable_inline_impl.hh
+++ b/src/io/dumper/dumpable_inline_impl.hh
@@ -1,137 +1,134 @@
 /**
  * @file   dumpable_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Thu Feb 20 2020
  *
  * @brief  Implementation of the Dumpable class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef AKANTU_DUMPABLE_INLINE_IMPL_HH_
 #define AKANTU_DUMPABLE_INLINE_IMPL_HH_
 
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 #include "dumper_elemental_field.hh"
 #include "dumper_nodal_field.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class T>
 inline void Dumpable::registerDumper(const std::string & dumper_name,
                                      const std::string & file_name,
                                      const bool is_default) {
 
   if (this->dumpers.find(dumper_name) != this->dumpers.end()) {
     AKANTU_DEBUG_INFO("Dumper " + dumper_name + "is already registered.");
   }
 
   std::string name = file_name;
   if (name.empty()) {
     name = dumper_name;
   }
 
   this->dumpers[dumper_name] = std::make_shared<T>(name);
 
   if (is_default) {
     this->default_dumper = dumper_name;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                            const Array<T> & field) {
   this->addDumpFieldExternalToDumper<T>(this->default_dumper, field_id, field);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void
 Dumpable::addDumpFieldExternalToDumper(const std::string & dumper_name,
                                        const std::string & field_id,
                                        const Array<T> & field) {
   auto field_cont = std::make_shared<dumpers::NodalField<T>>(field);
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field_cont);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Dumpable::addDumpFieldExternal(const std::string & field_id,
                                            const ElementTypeMapArray<T> & field,
                                            UInt spatial_dimension,
                                            GhostType ghost_type,
                                            ElementKind element_kind) {
   this->addDumpFieldExternalToDumper(this->default_dumper, field_id, field,
                                      spatial_dimension, ghost_type,
                                      element_kind);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 inline void Dumpable::addDumpFieldExternalToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const ElementTypeMapArray<T> & field, UInt spatial_dimension,
     GhostType ghost_type, ElementKind element_kind) {
 
   std::shared_ptr<dumpers::Field> field_cont;
 #if defined(AKANTU_IGFEM)
   if (element_kind == _ek_igfem) {
     field_cont = std::make_shared<dumpers::IGFEMElementalField<T>>(
         field, spatial_dimension, ghost_type, element_kind);
   } else
 #endif
     field_cont = std::make_shared<dumpers::ElementalField<T>>(
         field, spatial_dimension, ghost_type, element_kind);
   DumperIOHelper & dumper = this->getDumper(dumper_name);
   dumper.registerField(field_id, field_cont);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class T>
 inline T & Dumpable::getDumper(const std::string & dumper_name) {
   DumperIOHelper & dumper = this->getDumper(dumper_name);
 
   try {
     auto & templated_dumper = aka::as_type<T>(dumper);
     return templated_dumper;
   } catch (std::bad_cast &) {
     AKANTU_EXCEPTION("Dumper " << dumper_name << " is not of type: "
                                << debug::demangle(typeid(T).name()));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
 
-#endif
-
 #endif /* AKANTU_DUMPABLE_INLINE_IMPL_HH_ */
diff --git a/src/io/dumper/dumper_field.hh b/src/io/dumper/dumper_field.hh
index ad0cadabf..ea9061dc5 100644
--- a/src/io/dumper/dumper_field.hh
+++ b/src/io/dumper/dumper_field.hh
@@ -1,149 +1,147 @@
 /**
  * @file   dumper_field.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Sep 02 2014
  * @date last modification: Fri Jul 24 2020
  *
  * @brief  Common interface for fields
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef AKANTU_DUMPER_FIELD_HH_
 #define AKANTU_DUMPER_FIELD_HH_
 /* -------------------------------------------------------------------------- */
 #include "dumper_iohelper.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 namespace dumpers {
   /* --------------------------------------------------------------------------
    */
   class FieldComputeProxy;
   class FieldComputeBaseInterface;
   class ComputeFunctorInterface;
   class HomogenizerProxy;
   /* --------------------------------------------------------------------------
    */
 
   /// Field interface
   class Field : public std::enable_shared_from_this<Field> {
     /* ------------------------------------------------------------------------
      */
     /* Constructors/Destructors */
     /* ------------------------------------------------------------------------
      */
   public:
     Field() = default;
     virtual ~Field() = default;
 
     /* ------------------------------------------------------------------------
      */
     /* Methods */
     /* ------------------------------------------------------------------------
      */
   public:
-#ifdef AKANTU_USE_IOHELPER
     /// register this to the provided dumper
     virtual void registerToDumper(const std::string & id,
                                   iohelper::Dumper & dumper) = 0;
-#endif
 
     /// set the number of data per item (used for elements fields at the moment)
     virtual void setNbData([[gnu::unused]] UInt nb_data) {
       AKANTU_TO_IMPLEMENT();
     };
 
     /// set the number of data per elem (used for elements fields at the moment)
     virtual void
     setNbDataPerElem([[gnu::unused]] const ElementTypeMap<UInt> & nb_data) {
       AKANTU_TO_IMPLEMENT();
     };
 
     /// set the number of data per elem (used for elements fields at the moment)
     virtual void setNbDataPerElem([[gnu::unused]] UInt nb_data) {
       AKANTU_TO_IMPLEMENT();
     };
 
     /// get the number of components of the hosted field
     virtual ElementTypeMap<UInt>
     getNbComponents([[gnu::unused]] UInt dim = _all_dimensions,
                     [[gnu::unused]] GhostType ghost_type = _not_ghost,
                     [[gnu::unused]] ElementKind kind = _ek_not_defined) {
       throw;
     };
 
     /// for connection to a FieldCompute
     inline virtual std::shared_ptr<Field>
     connect([[gnu::unused]] FieldComputeProxy & proxy) {
       throw;
     };
 
     /// for connection to a FieldCompute
     inline virtual std::unique_ptr<ComputeFunctorInterface>
     connect(HomogenizerProxy & /*proxy*/) {
       throw;
     };
 
     /// check if the same quantity of data for all element types
     virtual void checkHomogeneity() = 0;
 
     /// return the dumper name
     std::string getGroupName() { return group_name; };
 
     /// return the id of the field
     std::string getID() { return field_id; };
 
     /* ------------------------------------------------------------------------
      */
     /* Accessors */
     /* ------------------------------------------------------------------------
      */
   public:
     /// return the flag to know if the field is homogeneous/contiguous
     virtual bool isHomogeneous() { return homogeneous; }
 
     /* ------------------------------------------------------------------------
      */
     /* Class Members */
     /* ------------------------------------------------------------------------
      */
   protected:
     /// the flag to know if it is homogeneous
     bool homogeneous{false};
 
     /// the name of the group it was associated to
     std::string group_name;
 
     /// the name of the dumper it was associated to
     std::string field_id;
   };
 
   /* --------------------------------------------------------------------------
    */
 
 } // namespace dumpers
 } // namespace akantu
 
 #endif /* AKANTU_DUMPER_FIELD_HH_ */
diff --git a/src/mesh/element_group.cc b/src/mesh/element_group.cc
index 7260343bd..380d2a8cd 100644
--- a/src/mesh/element_group.cc
+++ b/src/mesh/element_group.cc
@@ -1,212 +1,209 @@
 /**
  * @file   element_group.cc
  *
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Wed Dec 09 2020
  *
  * @brief  Stores information relevent to the notion of domain boundary and
  * surfaces.
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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_csr.hh"
 #include "dumpable.hh"
 #include "dumpable_inline_impl.hh"
 #include "group_manager.hh"
 #include "group_manager_inline_impl.hh"
 #include "mesh.hh"
 #include "mesh_utils.hh"
 #include <algorithm>
 #include <iterator>
 #include <sstream>
 
 #include "element_group.hh"
-#if defined(AKANTU_USE_IOHELPER)
+/* -------------------------------------------------------------------------- */
 #include "dumper_iohelper_paraview.hh"
-#endif
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ElementGroup::ElementGroup(const std::string & group_name, const Mesh & mesh,
                            NodeGroup & node_group, UInt dimension,
                            const std::string & id)
     : mesh(mesh), name(group_name), elements("elements", id),
       node_group(node_group), dimension(dimension) {
   AKANTU_DEBUG_IN();
 
-#if defined(AKANTU_USE_IOHELPER)
   this->registerDumper<DumperParaview>("paraview_" + group_name, group_name,
                                        true);
   this->addDumpFilteredMesh(mesh, elements, node_group.getNodes(),
                             _all_dimensions);
-#endif
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementGroup::ElementGroup(const ElementGroup & /*other*/) = default;
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::clear() { elements.free(); }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::clear(ElementType type, GhostType ghost_type) {
   if (elements.exists(type, ghost_type)) {
     elements(type, ghost_type).clear();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 bool ElementGroup::empty() const { return elements.empty(); }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::append(const ElementGroup & other_group) {
   AKANTU_DEBUG_IN();
 
   node_group.append(other_group.node_group);
 
   /// loop on all element types in all dimensions
   for (auto ghost_type : ghost_types) {
     for (auto type : other_group.elementTypes(_ghost_type = ghost_type,
                      _element_kind = _ek_not_defined)) {
       const Array<UInt> & other_elem_list =
           other_group.elements(type, ghost_type);
       UInt nb_other_elem = other_elem_list.size();
 
       Array<UInt> * elem_list;
       UInt nb_elem = 0;
 
       /// create current type if doesn't exists, otherwise get information
       if (elements.exists(type, ghost_type)) {
         elem_list = &elements(type, ghost_type);
         nb_elem = elem_list->size();
       } else {
         elem_list = &(elements.alloc(0, 1, type, ghost_type));
       }
 
       /// append new elements to current list
       elem_list->resize(nb_elem + nb_other_elem);
       std::copy(other_elem_list.begin(), other_elem_list.end(),
                 elem_list->begin() + nb_elem);
 
       /// remove duplicates
       std::sort(elem_list->begin(), elem_list->end());
       Array<UInt>::iterator<> end =
           std::unique(elem_list->begin(), elem_list->end());
       elem_list->resize(end - elem_list->begin());
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::printself(std::ostream & stream, int indent) const {
   std::string space;
   for (Int i = 0; i < indent; i++, space += AKANTU_INDENT) {
     ;
   }
 
   stream << space << "ElementGroup [" << std::endl;
   stream << space << " + name: " << name << std::endl;
   stream << space << " + dimension: " << dimension << std::endl;
   elements.printself(stream, indent + 1);
   node_group.printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::optimize() {
   // increasing the locality of data when iterating on the element of a group
   for (auto ghost_type : ghost_types) {
     for (auto type : elements.elementTypes(_ghost_type = ghost_type)) {
       Array<UInt> & els = elements(type, ghost_type);
       std::sort(els.begin(), els.end());
 
       Array<UInt>::iterator<> end = std::unique(els.begin(), els.end());
       els.resize(end - els.begin());
     }
   }
 
   node_group.optimize();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::fillFromNodeGroup() {
   CSR<Element> node_to_elem;
   MeshUtils::buildNode2Elements(this->mesh, node_to_elem, this->dimension);
 
   std::set<Element> seen;
 
   Array<UInt>::const_iterator<> itn = this->node_group.begin();
   Array<UInt>::const_iterator<> endn = this->node_group.end();
   for (; itn != endn; ++itn) {
     CSR<Element>::iterator ite = node_to_elem.begin(*itn);
     CSR<Element>::iterator ende = node_to_elem.end(*itn);
     for (; ite != ende; ++ite) {
       const Element & elem = *ite;
       if (this->dimension != _all_dimensions &&
           this->dimension != Mesh::getSpatialDimension(elem.type)) {
         continue;
       }
       if (seen.find(elem) != seen.end()) {
         continue;
       }
 
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(elem.type);
       Array<UInt>::const_iterator<Vector<UInt>> conn_it =
           this->mesh.getConnectivity(elem.type, elem.ghost_type)
               .begin(nb_nodes_per_element);
       const Vector<UInt> & conn = conn_it[elem.element];
 
       UInt count = 0;
       for (UInt n = 0; n < conn.size(); ++n) {
         count +=
             (this->node_group.getNodes().find(conn(n)) != UInt(-1) ? 1 : 0);
       }
 
       if (count == nb_nodes_per_element) {
         this->add(elem);
       }
 
       seen.insert(elem);
     }
   }
 
   this->optimize();
 }
 
 /* -------------------------------------------------------------------------- */
 void ElementGroup::addDimension(UInt dimension) {
   this->dimension = std::max(dimension, this->dimension);
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/mesh/group_manager_inline_impl.hh b/src/mesh/group_manager_inline_impl.hh
index f6cc96643..583281cc8 100644
--- a/src/mesh/group_manager_inline_impl.hh
+++ b/src/mesh/group_manager_inline_impl.hh
@@ -1,198 +1,196 @@
 /**
  * @file   group_manager_inline_impl.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Dana Christen <dana.christen@gmail.com>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Tue Mar 03 2020
  *
  * @brief  Stores information relevent to the notion of domain boundary and
  * surfaces.
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_field.hh"
 #include "element_group.hh"
 #include "element_type_map_filter.hh"
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_nodal_field.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <bool> class dump_type>
 std::shared_ptr<dumpers::Field>
 GroupManager::createElementalField(const ElementTypeMapArray<T> & field,
                                    const std::string & group_name,
                                    UInt spatial_dimension, ElementKind kind,
                                    ElementTypeMap<UInt> nb_data_per_elem) {
 
   const ElementTypeMapArray<T> * field_ptr = &field;
   if (field_ptr == nullptr) {
     return nullptr;
   }
   if (group_name == "all") {
     return this->createElementalField<dump_type<false>>(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
   }
   return this->createElementalFilteredField<dump_type<true>>(
       field, group_name, spatial_dimension, kind, nb_data_per_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <class> class T2,
           template <class, template <class> class, bool> class dump_type>
 std::shared_ptr<dumpers::Field>
 GroupManager::createElementalField(const ElementTypeMapArray<T> & field,
                                    const std::string & group_name,
                                    UInt spatial_dimension, ElementKind kind,
                                    ElementTypeMap<UInt> nb_data_per_elem) {
 
   const ElementTypeMapArray<T> * field_ptr = &field;
   if (field_ptr == nullptr) {
     return nullptr;
   }
   if (group_name == "all") {
     return this->createElementalField<dump_type<T, T2, false>>(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
   }
   return this->createElementalFilteredField<dump_type<T, T2, true>>(
       field, group_name, spatial_dimension, kind, nb_data_per_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T, template <typename T2, bool filtered>
                       class dump_type> ///< type of InternalMaterialField
 std::shared_ptr<dumpers::Field>
 GroupManager::createElementalField(const ElementTypeMapArray<T> & field,
                                    const std::string & group_name,
                                    UInt spatial_dimension, ElementKind kind,
                                    ElementTypeMap<UInt> nb_data_per_elem) {
   const ElementTypeMapArray<T> * field_ptr = &field;
 
   if (field_ptr == nullptr) {
     return nullptr;
   }
   if (group_name == "all") {
     return this->createElementalField<dump_type<T, false>>(
         field, group_name, spatial_dimension, kind, nb_data_per_elem);
   }
   return this->createElementalFilteredField<dump_type<T, true>>(
       field, group_name, spatial_dimension, kind, nb_data_per_elem);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename dump_type, typename field_type>
 std::shared_ptr<dumpers::Field> GroupManager::createElementalField(
     const field_type & field, const std::string & group_name,
     UInt spatial_dimension, ElementKind kind,
     const ElementTypeMap<UInt> & nb_data_per_elem) {
   const field_type * field_ptr = &field;
   if (field_ptr == nullptr) {
     return nullptr;
   }
 
   if (group_name != "all") {
     throw;
   }
 
   auto dumper =
       std::make_shared<dump_type>(field, spatial_dimension, _not_ghost, kind);
   dumper->setNbDataPerElem(nb_data_per_elem);
   return dumper;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename dump_type, typename field_type>
 std::shared_ptr<dumpers::Field> GroupManager::createElementalFilteredField(
     const field_type & field, const std::string & group_name,
     UInt spatial_dimension, ElementKind kind,
     ElementTypeMap<UInt> nb_data_per_elem) {
 
   const field_type * field_ptr = &field;
   if (field_ptr == nullptr) {
     return nullptr;
   }
   if (group_name == "all") {
     throw;
   }
 
   using T = typename field_type::value_type;
   ElementGroup & group = this->getElementGroup(group_name);
   UInt dim = group.getDimension();
   if (dim != spatial_dimension) {
     throw;
   }
   const ElementTypeMapArray<UInt> & elemental_filter = group.getElements();
 
   auto * filtered = new ElementTypeMapArrayFilter<T>(field, elemental_filter,
                                                      nb_data_per_elem);
 
   auto dumper = std::make_shared<dump_type>(*filtered, dim, _not_ghost, kind);
   dumper->setNbDataPerElem(nb_data_per_elem);
 
   return dumper;
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename type, bool flag, template <class, bool> class ftype>
 std::shared_ptr<dumpers::Field>
 GroupManager::createNodalField(const ftype<type, flag> * field,
                                const std::string & group_name,
                                UInt padding_size) {
   return createStridedNodalField(field, group_name, 0, 0, padding_size);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename type, bool flag, template <class, bool> class ftype>
 std::shared_ptr<dumpers::Field>
 GroupManager::createStridedNodalField(const ftype<type, flag> * field,
                                       const std::string & group_name, UInt size,
                                       UInt stride, UInt padding_size) {
   if (not field) {
     return nullptr;
   }
 
   if (group_name == "all") {
     using DumpType = typename dumpers::NodalField<type, false>;
     auto dumper = std::make_shared<DumpType>(*field, size, stride);
     dumper->setPadding(padding_size);
     return dumper;
   }
 
   ElementGroup & group = this->getElementGroup(group_name);
   const Array<UInt> * nodal_filter = &(group.getNodeGroup().getNodes());
   using DumpType = typename dumpers::NodalField<type, true>;
   auto dumper = std::make_shared<DumpType>(*field, size, stride, nodal_filter);
   dumper->setPadding(padding_size);
   return dumper;
 }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
-
-#endif
diff --git a/src/mesh/mesh.cc b/src/mesh/mesh.cc
index 16f852a5a..267a8944b 100644
--- a/src/mesh/mesh.cc
+++ b/src/mesh/mesh.cc
@@ -1,661 +1,656 @@
 /**
  * @file   mesh.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Mohit Pundir <mohit.pundir@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: Tue Feb 09 2021
  *
  * @brief  class handling meshes
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_config.hh"
 /* -------------------------------------------------------------------------- */
 #include "element_class.hh"
 #include "group_manager_inline_impl.hh"
 #include "mesh.hh"
 #include "mesh_global_data_updater.hh"
 #include "mesh_io.hh"
 #include "mesh_iterators.hh"
 #include "mesh_utils.hh"
 /* -------------------------------------------------------------------------- */
 #include "communicator.hh"
 #include "element_synchronizer.hh"
 #include "facet_synchronizer.hh"
 #include "mesh_utils_distribution.hh"
 #include "node_synchronizer.hh"
 #include "periodic_node_synchronizer.hh"
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
-
-#ifdef AKANTU_USE_IOHELPER
 #include "dumper_field.hh"
 #include "dumper_internal_material_field.hh"
-#endif
 /* -------------------------------------------------------------------------- */
 #include <limits>
 #include <sstream>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id, Communicator & communicator)
     : GroupManager(*this, id + ":group_manager"), MeshData("mesh_data", id),
       id(id), connectivities("connectivities", id),
       ghosts_counters("ghosts_counters", id), normals("normals", id),
       spatial_dimension(spatial_dimension), size(spatial_dimension, 0.),
       bbox(spatial_dimension), bbox_local(spatial_dimension),
       communicator(&communicator) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, Communicator & communicator, const ID & id)
     : Mesh(spatial_dimension, id, communicator) {
   AKANTU_DEBUG_IN();
 
   this->nodes =
       std::make_shared<Array<Real>>(0, spatial_dimension, id + ":coordinates");
   this->nodes_flags = std::make_shared<Array<NodeFlag>>(0, 1, NodeFlag::_normal,
                                                         id + ":nodes_flags");
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const ID & id)
     : Mesh(spatial_dimension, Communicator::getStaticCommunicator(), id) {}
 
 /* -------------------------------------------------------------------------- */
 Mesh::Mesh(UInt spatial_dimension, const std::shared_ptr<Array<Real>> & nodes,
            const ID & id)
     : Mesh(spatial_dimension, id, Communicator::getStaticCommunicator()) {
   this->nodes = nodes;
 
   this->nb_global_nodes = this->nodes->size();
 
   this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getBarycenters(Array<Real> & barycenter, ElementType type,
                           GhostType ghost_type) const {
   barycenter.resize(getNbElement(type, ghost_type));
   for (auto && data : enumerate(make_view(barycenter, spatial_dimension))) {
     getBarycenter(Element{type, UInt(std::get<0>(data)), ghost_type},
                   std::get<1>(data));
   }
 }
 
 class FacetGlobalConnectivityAccessor : public DataAccessor<Element> {
 public:
   FacetGlobalConnectivityAccessor(Mesh & mesh)
       : global_connectivity("global_connectivity",
                             "facet_connectivity_synchronizer") {
     global_connectivity.initialize(
         mesh, _spatial_dimension = _all_dimensions, _with_nb_element = true,
         _with_nb_nodes_per_element = true, _element_kind = _ek_regular);
     mesh.getGlobalConnectivity(global_connectivity);
   }
 
   UInt getNbData(const Array<Element> & elements,
                  const SynchronizationTag & tag) const override {
     UInt size = 0;
     if (tag == SynchronizationTag::_smmc_facets_conn) {
       UInt nb_nodes = Mesh::getNbNodesPerElementList(elements);
       size += nb_nodes * sizeof(UInt);
     }
     return size;
   }
 
   void packData(CommunicationBuffer & buffer, const Array<Element> & elements,
                 const SynchronizationTag & tag) const override {
     if (tag == SynchronizationTag::_smmc_facets_conn) {
       for (const auto & element : elements) {
         const auto & conns =
             global_connectivity(element.type, element.ghost_type);
         for (auto n : arange(conns.getNbComponent())) {
           buffer << conns(element.element, n);
         }
       }
     }
   }
 
   void unpackData(CommunicationBuffer & buffer, const Array<Element> & elements,
                   const SynchronizationTag & tag) override {
     if (tag == SynchronizationTag::_smmc_facets_conn) {
       for (const auto & element : elements) {
         auto & conns = global_connectivity(element.type, element.ghost_type);
         for (auto n : arange(conns.getNbComponent())) {
           buffer >> conns(element.element, n);
         }
       }
     }
   }
 
   AKANTU_GET_MACRO(GlobalConnectivity, (global_connectivity), decltype(auto));
 
 protected:
   ElementTypeMapArray<UInt> global_connectivity;
 };
 
 /* -------------------------------------------------------------------------- */
 Mesh & Mesh::initMeshFacets(const ID & id) {
   AKANTU_DEBUG_IN();
 
   if (mesh_facets) {
     AKANTU_DEBUG_OUT();
     return *mesh_facets;
   }
 
   mesh_facets = std::make_unique<Mesh>(spatial_dimension, this->nodes,
                                        getID() + ":" + id);
 
   mesh_facets->mesh_parent = this;
   mesh_facets->is_mesh_facets = true;
   mesh_facets->nodes_flags = this->nodes_flags;
   mesh_facets->nodes_global_ids = this->nodes_global_ids;
 
   MeshUtils::buildAllFacets(*this, *mesh_facets, 0);
 
   if (mesh.isDistributed()) {
     mesh_facets->is_distributed = true;
     mesh_facets->element_synchronizer = std::make_unique<FacetSynchronizer>(
         *mesh_facets, mesh.getElementSynchronizer());
 
     FacetGlobalConnectivityAccessor data_accessor(*mesh_facets);
     /// communicate
     mesh_facets->element_synchronizer->synchronizeOnce(
         data_accessor, SynchronizationTag::_smmc_facets_conn);
 
     /// flip facets
     MeshUtils::flipFacets(*mesh_facets, data_accessor.getGlobalConnectivity(),
                           _ghost);
   }
 
   /// transfers the the mesh physical names to the mesh facets
   if (not this->hasData("physical_names")) {
     AKANTU_DEBUG_OUT();
     return *mesh_facets;
   }
 
   auto & mesh_phys_data = this->getData<std::string>("physical_names");
   auto & phys_data = mesh_facets->getData<std::string>("physical_names");
   phys_data.initialize(*mesh_facets, _spatial_dimension = spatial_dimension - 1,
                        _with_nb_element = true);
 
   ElementTypeMapArray<Real> barycenters(getID(), "temporary_barycenters");
   barycenters.initialize(*mesh_facets, _nb_component = spatial_dimension,
                          _spatial_dimension = spatial_dimension - 1,
                          _with_nb_element = true);
 
   for (auto && ghost_type : ghost_types) {
     for (auto && type :
          barycenters.elementTypes(spatial_dimension - 1, ghost_type)) {
       mesh_facets->getBarycenters(barycenters(type, ghost_type), type,
                                   ghost_type);
     }
   }
 
   for_each_element(
       mesh,
       [&](auto && element) {
         Vector<Real> barycenter(spatial_dimension);
         mesh.getBarycenter(element, barycenter);
         auto norm_barycenter = barycenter.norm();
         auto tolerance = Math::getTolerance();
         if (norm_barycenter > tolerance) {
           tolerance *= norm_barycenter;
         }
 
         Vector<Real> barycenter_facet(spatial_dimension);
 
         auto range = enumerate(make_view(
             barycenters(element.type, element.ghost_type), spatial_dimension));
 #ifndef AKANTU_NDEBUG
         auto min_dist = std::numeric_limits<Real>::max();
 #endif
         // this is a spacial search coded the most inefficient way.
         auto facet =
             std::find_if(range.begin(), range.end(), [&](auto && data) {
               auto norm_distance = barycenter.distance(std::get<1>(data));
 #ifndef AKANTU_NDEBUG
               min_dist = std::min(min_dist, norm_distance);
 #endif
               return (norm_distance < tolerance);
             });
 
         if (facet == range.end()) {
           AKANTU_DEBUG_INFO("The element "
                             << element
                             << " did not find its associated facet in the "
                                "mesh_facets! Try to decrease math tolerance. "
                                "The closest element was at a distance of "
                             << min_dist);
           return;
         }
 
         // set physical name
         auto && facet_element = Element{element.type, UInt(std::get<0>(*facet)),
                                         element.ghost_type};
         phys_data(facet_element) = mesh_phys_data(element);
       },
       _spatial_dimension = spatial_dimension - 1);
 
   mesh_facets->createGroupsFromMeshData<std::string>("physical_names");
 
   AKANTU_DEBUG_OUT();
   return *mesh_facets;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::defineMeshParent(const Mesh & mesh) {
   AKANTU_DEBUG_IN();
 
   this->mesh_parent = &mesh;
   this->is_mesh_facets = true;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Mesh::~Mesh() = default;
 
 /* -------------------------------------------------------------------------- */
 void Mesh::read(const std::string & filename, const MeshIOType & mesh_io_type) {
 
   AKANTU_DEBUG_ASSERT(not is_distributed,
                       "You cannot read a mesh that is already distributed");
 
   MeshIO::read(filename, *this, mesh_io_type);
 
   auto types =
       this->elementTypes(spatial_dimension, _not_ghost, _ek_not_defined);
   auto it = types.begin();
   auto last = types.end();
   if (it == last) {
     AKANTU_DEBUG_WARNING(
         "The mesh contained in the file "
         << filename << " does not seem to be of the good dimension."
         << " No element of dimension " << spatial_dimension << " were read.");
   }
 
   this->makeReady();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::write(const std::string & filename,
                  const MeshIOType & mesh_io_type) {
   MeshIO::write(filename, *this, mesh_io_type);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::makeReady() {
   this->nb_global_nodes = this->nodes->size();
   this->computeBoundingBox();
   this->nodes_flags->resize(nodes->size(), NodeFlag::_normal);
   this->nodes_to_elements.resize(nodes->size());
   for (auto & node_set : nodes_to_elements) {
     node_set = std::make_unique<std::set<Element>>();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::printself(std::ostream & stream, int indent) const {
   std::string space(indent, AKANTU_INDENT);
 
   stream << space << "Mesh [" << std::endl;
   stream << space << " + id                : " << getID() << std::endl;
   stream << space << " + spatial dimension : " << this->spatial_dimension
          << std::endl;
   stream << space << " + nodes [" << std::endl;
   nodes->printself(stream, indent + 2);
   stream << space << " + connectivities [" << std::endl;
   connectivities.printself(stream, indent + 2);
   stream << space << " ]" << std::endl;
 
   GroupManager::printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::computeBoundingBox() {
   AKANTU_DEBUG_IN();
 
   bbox_local.reset();
 
   for (auto & pos : make_view(*nodes, spatial_dimension)) {
     //    if(!isPureGhostNode(i))
     bbox_local += pos;
   }
 
   if (this->is_distributed) {
     bbox = bbox_local.allSum(*communicator);
   } else {
     bbox = bbox_local;
   }
 
   size = bbox.size();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::initNormals() {
   normals.initialize(*this, _nb_component = spatial_dimension,
                      _spatial_dimension = spatial_dimension,
                      _element_kind = _ek_not_defined);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getGlobalConnectivity(
     ElementTypeMapArray<UInt> & global_connectivity) {
   AKANTU_DEBUG_IN();
 
   for (auto && ghost_type : ghost_types) {
     for (auto type :
          global_connectivity.elementTypes(_spatial_dimension = _all_dimensions,
          _element_kind = _ek_not_defined, _ghost_type = ghost_type)) {
       if (not connectivities.exists(type, ghost_type)) {
         continue;
       }
 
       auto & local_conn = connectivities(type, ghost_type);
       auto & g_connectivity = global_connectivity(type, ghost_type);
 
       UInt nb_nodes = local_conn.size() * local_conn.getNbComponent();
 
       std::transform(local_conn.begin_reinterpret(nb_nodes),
                      local_conn.end_reinterpret(nb_nodes),
                      g_connectivity.begin_reinterpret(nb_nodes),
                      [&](UInt l) -> UInt { return this->getNodeGlobalId(l); });
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 DumperIOHelper & Mesh::getGroupDumper(const std::string & dumper_name,
                                       const std::string & group_name) {
   if (group_name == "all") {
     return this->getDumper(dumper_name);
   }
   return element_groups[group_name]->getDumper(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 ElementTypeMap<UInt> Mesh::getNbDataPerElem(ElementTypeMapArray<T> & arrays) {
   ElementTypeMap<UInt> nb_data_per_elem;
 
   for (auto type : arrays.elementTypes(_element_kind = _ek_not_defined)) {
     UInt nb_elements = this->getNbElement(type);
     auto & array = arrays(type);
 
     nb_data_per_elem(type) = array.getNbComponent() * array.size();
     nb_data_per_elem(type) /= nb_elements;
   }
 
   return nb_data_per_elem;
 }
 
 /* -------------------------------------------------------------------------- */
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<Real> & array);
 
 template ElementTypeMap<UInt>
 Mesh::getNbDataPerElem(ElementTypeMapArray<UInt> & array);
 
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 template <typename T>
 std::shared_ptr<dumpers::Field>
 Mesh::createFieldFromAttachedData(const std::string & field_id,
                                   const std::string & group_name,
                                   ElementKind element_kind) {
 
   std::shared_ptr<dumpers::Field> field;
   ElementTypeMapArray<T> * internal = nullptr;
   try {
     internal = &(this->getData<T>(field_id));
   } catch (...) {
     return nullptr;
   }
 
   ElementTypeMap<UInt> nb_data_per_elem = this->getNbDataPerElem(*internal);
 
   field = this->createElementalField<T, dumpers::InternalMaterialField>(
       *internal, group_name, this->spatial_dimension, element_kind,
       nb_data_per_elem);
 
   return field;
 }
 
 template std::shared_ptr<dumpers::Field>
 Mesh::createFieldFromAttachedData<Real>(const std::string & field_id,
                                         const std::string & group_name,
                                         ElementKind element_kind);
 
 template std::shared_ptr<dumpers::Field>
 Mesh::createFieldFromAttachedData<UInt>(const std::string & field_id,
                                         const std::string & group_name,
                                         ElementKind element_kind);
-#endif
 
 /* -------------------------------------------------------------------------- */
 void Mesh::distributeImpl(
     Communicator & communicator,
     const std::function<Int(const Element &, const Element &)> &
         edge_weight_function [[gnu::unused]],
     const std::function<Int(const Element &)> & vertex_weight_function
     [[gnu::unused]]) {
   AKANTU_DEBUG_ASSERT(is_distributed == false,
                       "This mesh is already distribute");
   this->communicator = &communicator;
 
   this->element_synchronizer = std::make_unique<ElementSynchronizer>(
       *this, this->getID() + ":element_synchronizer", true);
 
   this->node_synchronizer = std::make_unique<NodeSynchronizer>(
       *this, this->getID() + ":node_synchronizer", true);
 
   Int psize = this->communicator->getNbProc();
 
   if (psize > 1) {
 #ifdef AKANTU_USE_SCOTCH
     Int prank = this->communicator->whoAmI();
     if (prank == 0) {
       MeshPartitionScotch partition(*this, spatial_dimension);
       partition.partitionate(psize, edge_weight_function,
                              vertex_weight_function);
 
       MeshUtilsDistribution::distributeMeshCentralized(*this, 0, partition);
     } else {
       MeshUtilsDistribution::distributeMeshCentralized(*this, 0);
     }
 #else
     if (psize > 1) {
       AKANTU_ERROR("Cannot distribute a mesh without a partitioning tool");
     }
 #endif
   }
 
   // if (psize > 1)
   this->is_distributed = true;
 
   this->computeBoundingBox();
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getAssociatedElements(const Array<UInt> & node_list,
                                  Array<Element> & elements) const {
   for (const auto & node : node_list) {
     for (const auto & element : *nodes_to_elements[node]) {
       elements.push_back(element);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::getAssociatedElements(const UInt & node,
                                  Array<Element> & elements) const {
   for (const auto & element : *nodes_to_elements[node]) {
     elements.push_back(element);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::fillNodesToElements(UInt dimension) {
   Element e;
 
   UInt nb_nodes = nodes->size();
   this->nodes_to_elements.resize(nb_nodes);
 
   for (UInt n = 0; n < nb_nodes; ++n) {
     if (this->nodes_to_elements[n]) {
       this->nodes_to_elements[n]->clear();
     } else {
       this->nodes_to_elements[n] = std::make_unique<std::set<Element>>();
     }
   }
 
   for (auto ghost_type : ghost_types) {
     e.ghost_type = ghost_type;
     for (const auto & type :
          elementTypes(dimension, ghost_type, _ek_not_defined)) {
       e.type = type;
 
       UInt nb_element = this->getNbElement(type, ghost_type);
       auto connectivity = connectivities(type, ghost_type);
       auto conn_it = connectivity.begin(connectivity.getNbComponent());
 
       for (UInt el = 0; el < nb_element; ++el, ++conn_it) {
         e.element = el;
         const Vector<UInt> & conn = *conn_it;
         for (auto node : conn) {
           nodes_to_elements[node]->insert(e);
         }
       }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<UInt, UInt>
 Mesh::updateGlobalData(NewNodesEvent & nodes_event,
                        NewElementsEvent & elements_event) {
   if (global_data_updater) {
     return this->global_data_updater->updateData(nodes_event, elements_event);
   }
   return std::make_tuple(nodes_event.getList().size(),
                          elements_event.getList().size());
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::registerGlobalDataUpdater(
     std::unique_ptr<MeshGlobalDataUpdater> && global_data_updater) {
   this->global_data_updater = std::move(global_data_updater);
 }
 
 /* -------------------------------------------------------------------------- */
 void Mesh::eraseElements(const Array<Element> & elements) {
   ElementTypeMap<UInt> last_element;
 
   RemovedElementsEvent event(*this, "new_numbering", AKANTU_CURRENT_FUNCTION);
   auto & remove_list = event.getList();
   auto & new_numbering = event.getNewNumbering();
 
   for (auto && el : elements) {
     if (el.ghost_type != _not_ghost) {
       auto & count = ghosts_counters(el);
       --count;
       if (count > 0) {
         continue;
       }
     }
 
     remove_list.push_back(el);
     if (not new_numbering.exists(el.type, el.ghost_type)) {
       auto nb_element = mesh.getNbElement(el.type, el.ghost_type);
       auto & numbering =
           new_numbering.alloc(nb_element, 1, el.type, el.ghost_type);
       for (auto && pair : enumerate(numbering)) {
         std::get<1>(pair) = std::get<0>(pair);
       }
     }
 
     new_numbering(el) = UInt(-1);
   }
 
   auto find_last_not_deleted = [](auto && array, Int start) -> Int {
     do {
       --start;
     } while (start >= 0 and array[start] == UInt(-1));
 
     return start;
   };
 
   auto find_first_deleted = [](auto && array, Int start) -> Int {
     auto begin = array.begin();
     auto it = std::find_if(begin + start, array.end(),
                            [](auto & el) { return el == UInt(-1); });
     return Int(it - begin);
   };
 
   for (auto ghost_type : ghost_types) {
     for (auto type : new_numbering.elementTypes(_ghost_type = ghost_type)) {
       auto & numbering = new_numbering(type, ghost_type);
       auto last_not_delete = find_last_not_deleted(numbering, numbering.size());
 
       if (last_not_delete < 0) {
         continue;
       }
 
       auto pos = find_first_deleted(numbering, 0);
 
       while (pos < last_not_delete) {
         std::swap(numbering[pos], numbering[last_not_delete]);
         last_not_delete = find_last_not_deleted(numbering, last_not_delete);
         pos = find_first_deleted(numbering, pos + 1);
       }
     }
   }
   this->sendEvent(event);
 }
 
 } // namespace akantu
diff --git a/src/mesh/node_group.cc b/src/mesh/node_group.cc
index 8528232fa..b0057f248 100644
--- a/src/mesh/node_group.cc
+++ b/src/mesh/node_group.cc
@@ -1,98 +1,94 @@
 /**
  * @file   node_group.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Mar 04 2020
  *
  * @brief  Implementation of the node group
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "node_group.hh"
 #include "dumpable.hh"
 #include "dumpable_inline_impl.hh"
-#include "mesh.hh"
-#if defined(AKANTU_USE_IOHELPER)
 #include "dumper_iohelper_paraview.hh"
-#endif
+#include "mesh.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 NodeGroup::NodeGroup(const std::string & name, const Mesh & mesh,
                      const std::string & id)
     : name(name), node_group(0, 1, std::string(id + ":nodes")) {
-#if defined(AKANTU_USE_IOHELPER)
   this->registerDumper<DumperParaview>("paraview_" + name, name, true);
   auto field = std::make_shared<dumpers::NodalField<Real, true>>(
       mesh.getNodes(), 0, 0, &this->getNodes());
   this->getDumper().registerField("positions", field);
-#endif
 }
 
 /* -------------------------------------------------------------------------- */
 NodeGroup::~NodeGroup() = default;
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::clear() { node_group.resize(0); }
 /* -------------------------------------------------------------------------- */
 // bool NodeGroup::empty() { return node_group.empty(); }
 /* -------------------------------------------------------------------------- */
 void NodeGroup::optimize() {
   std::sort(node_group.begin(), node_group.end());
   Array<UInt>::iterator<> end =
       std::unique(node_group.begin(), node_group.end());
   node_group.resize(end - node_group.begin());
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::append(const NodeGroup & other_group) {
   AKANTU_DEBUG_IN();
 
   UInt nb_nodes = node_group.size();
 
   /// append new nodes to current list
   node_group.resize(nb_nodes + other_group.node_group.size());
   std::copy(other_group.node_group.begin(), other_group.node_group.end(),
             node_group.begin() + nb_nodes);
 
   optimize();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void NodeGroup::printself(std::ostream & stream, int indent) const {
   std::string space(indent, AKANTU_INDENT);
 
   stream << space << "NodeGroup [" << std::endl;
   stream << space << " + name: " << name << std::endl;
   node_group.printself(stream, indent + 1);
   stream << space << "]" << std::endl;
 }
 
 } // namespace akantu
diff --git a/src/model/common/dof_manager/dof_manager_default.cc b/src/model/common/dof_manager/dof_manager_default.cc
index 3d8ac5c87..8fe96c51f 100644
--- a/src/model/common/dof_manager/dof_manager_default.cc
+++ b/src/model/common/dof_manager/dof_manager_default.cc
@@ -1,489 +1,489 @@
 /**
  * @file   dof_manager_default.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Aug 18 2015
  * @date last modification: Tue Mar 30 2021
  *
  * @brief  Implementation of the default DOFManager
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager_default.hh"
 #include "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_group.hh"
 #include "non_linear_solver_default.hh"
 #include "periodic_node_synchronizer.hh"
 #include "solver_vector_default.hh"
 #include "solver_vector_distributed.hh"
 #include "sparse_matrix_aij.hh"
 #include "time_step_solver_default.hh"
 
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <unordered_map>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(const ID & id)
     : DOFManager(id), synchronizer(nullptr) {
   residual = std::make_unique<SolverVectorDefault>(
       *this, std::string(id + ":residual"));
   solution = std::make_unique<SolverVectorDefault>(
       *this, std::string(id + ":solution"));
   data_cache = std::make_unique<SolverVectorDefault>(
       *this, std::string(id + ":data_cache"));
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFManagerDefault(Mesh & mesh, const ID & id)
     : DOFManager(mesh, id), synchronizer(nullptr) {
   if (this->mesh->isDistributed()) {
     this->synchronizer = std::make_unique<DOFSynchronizer>(
         *this, this->id + ":dof_synchronizer");
     residual = std::make_unique<SolverVectorDistributed>(
         *this, std::string(id + ":residual"));
     solution = std::make_unique<SolverVectorDistributed>(
         *this, std::string(id + ":solution"));
     data_cache = std::make_unique<SolverVectorDistributed>(
         *this, std::string(id + ":data_cache"));
 
   } else {
     residual = std::make_unique<SolverVectorDefault>(
         *this, std::string(id + ":residual"));
     solution = std::make_unique<SolverVectorDefault>(
         *this, std::string(id + ":solution"));
     data_cache = std::make_unique<SolverVectorDefault>(
         *this, std::string(id + ":data_cache"));
   }
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::~DOFManagerDefault() = default;
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::makeConsistentForPeriodicity(const ID & dof_id,
                                                      SolverVector & array) {
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   if (dof_data.support_type != _dst_nodal) {
     return;
   }
 
   if (not mesh->isPeriodic()) {
     return;
   }
 
   this->mesh->getPeriodicNodeSynchronizer()
       .reduceSynchronizeWithPBCSlaves<AddOperation>(
           aka::as_type<SolverVectorDefault>(array).getVector());
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::assembleToGlobalArray(
     const ID & dof_id, const Array<T> & array_to_assemble,
     Array<T> & global_array, T scale_factor) {
   AKANTU_DEBUG_IN();
 
   auto & dof_data = this->getDOFDataTyped<DOFDataDefault>(dof_id);
   AKANTU_DEBUG_ASSERT(dof_data.local_equation_number.size() ==
                           array_to_assemble.size() *
                               array_to_assemble.getNbComponent(),
                       "The array to assemble does not have a correct size."
                           << " (" << array_to_assemble.getID() << ")");
 
   if (dof_data.support_type == _dst_nodal and mesh->isPeriodic()) {
     for (auto && data :
          zip(dof_data.local_equation_number, dof_data.associated_nodes,
              make_view(array_to_assemble))) {
       auto && equ_num = std::get<0>(data);
       // auto && node = std::get<1>(data);
       auto && arr = std::get<2>(data);
 
       // Guillaume to Nico:
       // This filter of periodic slave should not be.
       // Indeed you want to get the contribution even
       // from periodic slaves and cumulate to the right
       // equation number.
 
       global_array(equ_num) += scale_factor * (arr);
       // scale_factor * (arr) * (not this->mesh->isPeriodicSlave(node));
     }
   } else {
     for (auto && data :
          zip(dof_data.local_equation_number, make_view(array_to_assemble))) {
       auto && equ_num = std::get<0>(data);
       auto && arr = std::get<1>(data);
       global_array(equ_num) += scale_factor * (arr);
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleToGlobalArray(
     const ID & dof_id, const Array<Real> & array_to_assemble,
     SolverVector & global_array_v, Real scale_factor) {
 
   assembleToGlobalArray(
       dof_id, array_to_assemble,
       aka::as_type<SolverVectorDefault>(global_array_v).getVector(),
       scale_factor);
 }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerDefault::DOFDataDefault::DOFDataDefault(const ID & dof_id)
     : DOFData(dof_id) {}
 
 /* -------------------------------------------------------------------------- */
 auto DOFManagerDefault::getNewDOFData(const ID & dof_id)
     -> std::unique_ptr<DOFData> {
   return std::make_unique<DOFDataDefault>(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<UInt, UInt, UInt>
 DOFManagerDefault::registerDOFsInternal(const ID & dof_id,
                                         Array<Real> & dofs_array) {
   auto ret = DOFManager::registerDOFsInternal(dof_id, dofs_array);
 
   // update the synchronizer if needed
   if (this->synchronizer) {
     this->synchronizer->registerDOFs(dof_id);
   }
 
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const MatrixType & matrix_type) {
   return this->registerSparseMatrix<SparseMatrixAIJ>(*this, id, matrix_type);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerDefault::getNewMatrix(const ID & id,
                                                const ID & matrix_to_copy_id) {
   return this->registerSparseMatrix<SparseMatrixAIJ>(id, matrix_to_copy_id);
 }
 
 /* -------------------------------------------------------------------------- */
 SolverVector & DOFManagerDefault::getNewLumpedMatrix(const ID & id) {
   return this->registerLumpedMatrix<SolverVectorDefault>(*this, id);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixAIJ & DOFManagerDefault::getMatrix(const ID & id) {
   auto & matrix = DOFManager::getMatrix(id);
   return aka::as_type<SparseMatrixAIJ>(matrix);
 }
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver &
 DOFManagerDefault::getNewNonLinearSolver(const ID & id,
                                          const NonLinearSolverType & type) {
   switch (type) {
 #if defined(AKANTU_USE_MUMPS)
   case NonLinearSolverType::_newton_raphson:
     /* FALLTHRU */
     /* [[fallthrough]]; un-comment when compiler will get it */
   case NonLinearSolverType::_newton_raphson_contact:
   case NonLinearSolverType::_newton_raphson_modified: {
     return this->registerNonLinearSolver<NonLinearSolverNewtonRaphson>(
         *this, id, type);
   }
   case NonLinearSolverType::_linear: {
     return this->registerNonLinearSolver<NonLinearSolverLinear>(*this, id,
                                                                 type);
   }
 #endif
   case NonLinearSolverType::_lumped: {
     return this->registerNonLinearSolver<NonLinearSolverLumped>(*this, id,
                                                                 type);
   }
   default:
     AKANTU_EXCEPTION("The asked type of non linear solver is not supported by "
                      "this dof manager");
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManagerDefault::getNewTimeStepSolver(
     const ID & id, const TimeStepSolverType & type,
     NonLinearSolver & non_linear_solver, SolverCallback & solver_callback) {
   return this->registerTimeStepSolver<TimeStepSolverDefault>(
       *this, id, type, non_linear_solver, solver_callback);
 }
 
 /* -------------------------------------------------------------------------- */
 template <typename T>
 void DOFManagerDefault::getArrayPerDOFs(const ID & dof_id,
                                         const Array<T> & global_array,
                                         Array<T> & local_array) const {
   AKANTU_DEBUG_IN();
 
   const Array<Int> & equation_number = this->getLocalEquationsNumbers(dof_id);
 
   UInt nb_degree_of_freedoms = equation_number.size();
   local_array.resize(nb_degree_of_freedoms / local_array.getNbComponent());
 
   auto loc_it = local_array.begin_reinterpret(nb_degree_of_freedoms);
   auto equ_it = equation_number.begin();
 
   for (UInt d = 0; d < nb_degree_of_freedoms; ++d, ++loc_it, ++equ_it) {
     (*loc_it) = global_array(*equ_it);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::getArrayPerDOFs(const ID & dof_id,
                                         const SolverVector & global_array,
                                         Array<Real> & local_array) {
   getArrayPerDOFs(dof_id,
                   aka::as_type<SolverVectorDefault>(global_array).getVector(),
                   local_array);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleLumpedMatMulVectToResidual(
     const ID & dof_id, const ID & A_id, const Array<Real> & x,
     Real scale_factor) {
   const Array<Real> & A = this->getLumpedMatrix(A_id);
   auto & cache = aka::as_type<SolverVectorArray>(*this->data_cache);
 
   cache.zero();
   this->assembleToGlobalArray(dof_id, x, cache.getVector(), scale_factor);
 
   for (auto && data : zip(make_view(A), make_view(cache.getVector()),
                           make_view(this->getResidualArray()))) {
     const auto & A = std::get<0>(data);
     const auto & x = std::get<1>(data);
     auto & r = std::get<2>(data);
     r += A * x;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleElementalMatricesToMatrix(
     const ID & matrix_id, const ID & dof_id, const Array<Real> & elementary_mat,
     ElementType type, GhostType ghost_type,
     const MatrixType & elemental_matrix_type,
     const Array<UInt> & filter_elements) {
   this->addToProfile(matrix_id, dof_id, type, ghost_type);
   auto & A = getMatrix(matrix_id);
   DOFManager::assembleElementalMatricesToMatrix_(
       A, dof_id, elementary_mat, type, ghost_type, elemental_matrix_type,
       filter_elements);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assemblePreassembledMatrix(
     const ID & matrix_id, const TermsToAssemble & terms) {
   auto & A = getMatrix(matrix_id);
   DOFManager::assemblePreassembledMatrix_(A, terms);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::assembleMatMulVectToArray(const ID & dof_id,
                                                   const ID & A_id,
                                                   const Array<Real> & x,
                                                   Array<Real> & array,
                                                   Real scale_factor) {
   if (mesh->isDistributed()) {
     DOFManager::assembleMatMulVectToArray_<SolverVectorDistributed>(
         dof_id, A_id, x, array, scale_factor);
   } else {
     DOFManager::assembleMatMulVectToArray_<SolverVectorDefault>(
         dof_id, A_id, x, array, scale_factor);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::addToProfile(const ID & matrix_id, const ID & dof_id,
                                      ElementType type, GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   const auto & dof_data = this->getDOFData(dof_id);
 
   if (dof_data.support_type != _dst_nodal) {
     return;
   }
 
   auto mat_dof = std::make_pair(matrix_id, dof_id);
   auto type_pair = std::make_pair(type, ghost_type);
 
   auto prof_it = this->matrix_profiled_dofs.find(mat_dof);
   if (prof_it != this->matrix_profiled_dofs.end() &&
       std::find(prof_it->second.begin(), prof_it->second.end(), type_pair) !=
           prof_it->second.end()) {
     return;
   }
 
   auto nb_degree_of_freedom_per_node = dof_data.dof->getNbComponent();
 
   const auto & equation_number = this->getLocalEquationsNumbers(dof_id);
 
   auto & A = this->getMatrix(matrix_id);
   A.resize(system_size);
   auto size = A.size();
 
   auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
   const auto & connectivity = this->mesh->getConnectivity(type, ghost_type);
   auto cbegin = connectivity.begin(nb_nodes_per_element);
   auto cit = cbegin;
 
   auto nb_elements = connectivity.size();
   UInt * ge_it = nullptr;
   if (dof_data.group_support != "__mesh__") {
     const auto & group_elements =
         this->mesh->getElementGroup(dof_data.group_support)
             .getElements(type, ghost_type);
     ge_it = group_elements.storage();
     nb_elements = group_elements.size();
   }
 
   UInt size_mat = nb_nodes_per_element * nb_degree_of_freedom_per_node;
   Vector<Int> element_eq_nb(size_mat);
 
   for (UInt e = 0; e < nb_elements; ++e) {
     if (ge_it != nullptr) {
       cit = cbegin + *ge_it;
     }
 
     this->extractElementEquationNumber(
         equation_number, *cit, nb_degree_of_freedom_per_node, element_eq_nb);
     std::transform(
         element_eq_nb.storage(), element_eq_nb.storage() + element_eq_nb.size(),
         element_eq_nb.storage(),
         [&](auto & local) { return this->localToGlobalEquationNumber(local); });
 
     if (ge_it != nullptr) {
       ++ge_it;
     } else {
       ++cit;
     }
 
     for (UInt i = 0; i < size_mat; ++i) {
       UInt c_irn = element_eq_nb(i);
       if (c_irn < size) {
         for (UInt j = 0; j < size_mat; ++j) {
           UInt c_jcn = element_eq_nb(j);
           if (c_jcn < size) {
             A.add(c_irn, c_jcn);
           }
         }
       }
     }
   }
 
   this->matrix_profiled_dofs[mat_dof].push_back(type_pair);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & DOFManagerDefault::getSolutionArray() {
   return dynamic_cast<SolverVectorDefault *>(this->solution.get())->getVector();
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<Real> & DOFManagerDefault::getResidualArray() const {
   return dynamic_cast<SolverVectorDefault *>(this->residual.get())->getVector();
 }
 
 /* -------------------------------------------------------------------------- */
 Array<Real> & DOFManagerDefault::getResidualArray() {
   return dynamic_cast<SolverVectorDefault *>(this->residual.get())->getVector();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::onNodesAdded(const Array<UInt> & nodes_list,
                                      const NewNodesEvent & event) {
   DOFManager::onNodesAdded(nodes_list, event);
 
   if (this->synchronizer) {
     this->synchronizer->onNodesAdded(nodes_list);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::resizeGlobalArrays() {
   DOFManager::resizeGlobalArrays();
 
   this->global_blocked_dofs.resize(this->local_system_size, 1);
   this->previous_global_blocked_dofs.resize(this->local_system_size, 1);
 
   matrix_profiled_dofs.clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerDefault::updateGlobalBlockedDofs() {
   DOFManager::updateGlobalBlockedDofs();
 
   if (this->global_blocked_dofs_release ==
       this->previous_global_blocked_dofs_release) {
     return;
   }
 
   global_blocked_dofs_uint.resize(local_system_size);
   global_blocked_dofs_uint.set(false);
   for (const auto & dof : global_blocked_dofs) {
     global_blocked_dofs_uint[dof] = true;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Array<bool> & DOFManagerDefault::getBlockedDOFs() {
   return global_blocked_dofs_uint;
 }
 
 /* -------------------------------------------------------------------------- */
 const Array<bool> & DOFManagerDefault::getBlockedDOFs() const {
   return global_blocked_dofs_uint;
 }
 
 /* -------------------------------------------------------------------------- */
-static bool dof_manager_is_registered [[gnu::unused]] =
+static bool dof_manager_is_registered =
     DOFManagerFactory::getInstance().registerAllocator(
         "default",
         [](Mesh & mesh, const ID & id) -> std::unique_ptr<DOFManager> {
           return std::make_unique<DOFManagerDefault>(mesh, id);
         });
 
-static bool dof_manager_is_registered_mumps [[gnu::unused]] =
+static bool dof_manager_is_registered_mumps =
     DOFManagerFactory::getInstance().registerAllocator(
         "mumps", [](Mesh & mesh, const ID & id) -> std::unique_ptr<DOFManager> {
           return std::make_unique<DOFManagerDefault>(mesh, id);
         });
 
 } // namespace akantu
diff --git a/src/model/common/dof_manager/dof_manager_petsc.cc b/src/model/common/dof_manager/dof_manager_petsc.cc
index 2c096c15f..ae0177c43 100644
--- a/src/model/common/dof_manager/dof_manager_petsc.cc
+++ b/src/model/common/dof_manager/dof_manager_petsc.cc
@@ -1,300 +1,300 @@
 /**
  * @file   dof_manager_petsc.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Oct 07 2015
  * @date last modification: Fri Jul 24 2020
  *
  * @brief  DOFManaterPETSc is the PETSc implementation of the DOFManager
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "dof_manager_petsc.hh"
 #include "aka_iterators.hh"
 #include "communicator.hh"
 #include "cppargparse.hh"
 #include "non_linear_solver_petsc.hh"
 #include "solver_vector_petsc.hh"
 #include "sparse_matrix_petsc.hh"
 #include "time_step_solver_default.hh"
 #if defined(AKANTU_USE_MPI)
 #include "mpi_communicator_data.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 #include <petscis.h>
 #include <petscsys.h>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class PETScSingleton {
 private:
   PETScSingleton() {
     PETSc_call(PetscInitialized, &is_initialized);
 
     if (is_initialized == 0U) {
       cppargparse::ArgumentParser & argparser = getStaticArgumentParser();
       int & argc = argparser.getArgC();
       char **& argv = argparser.getArgV();
       PETSc_call(PetscInitialize, &argc, &argv, nullptr, nullptr);
       PETSc_call(
           PetscPopErrorHandler); // remove the default PETSc signal handler
       PETSc_call(PetscPushErrorHandler, PetscIgnoreErrorHandler, nullptr);
     }
   }
 
 public:
   PETScSingleton(const PETScSingleton &) = delete;
   PETScSingleton & operator=(const PETScSingleton &) = delete;
 
   ~PETScSingleton() {
     if (is_initialized == 0U) {
       PetscFinalize();
     }
   }
 
   static PETScSingleton & getInstance() {
     static PETScSingleton instance;
     return instance;
   }
 
 private:
   PetscBool is_initialized;
 };
 
 /* -------------------------------------------------------------------------- */
 DOFManagerPETSc::DOFDataPETSc::DOFDataPETSc(const ID & dof_id)
     : DOFData(dof_id) {}
 
 /* -------------------------------------------------------------------------- */
 DOFManagerPETSc::DOFManagerPETSc(const ID & id) : DOFManager(id) { init(); }
 
 /* -------------------------------------------------------------------------- */
 DOFManagerPETSc::DOFManagerPETSc(Mesh & mesh, const ID & id)
     : DOFManager(mesh, id) {
   init();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::init() {
   // check if the akantu types and PETSc one are consistant
   static_assert(sizeof(Int) == sizeof(PetscInt),
                 "The integer type of Akantu does not match the one from PETSc");
   static_assert(sizeof(Real) == sizeof(PetscReal),
                 "The integer type of Akantu does not match the one from PETSc");
 
 #if defined(AKANTU_USE_MPI)
 
   const auto & mpi_data =
       aka::as_type<MPICommunicatorData>(communicator.getCommunicatorData());
   MPI_Comm mpi_comm = mpi_data.getMPICommunicator();
   this->mpi_communicator = mpi_comm;
 #else
   this->mpi_communicator = PETSC_COMM_SELF;
 #endif
 
   PETScSingleton & instance [[gnu::unused]] = PETScSingleton::getInstance();
 }
 
 /* -------------------------------------------------------------------------- */
 auto DOFManagerPETSc::getNewDOFData(const ID & dof_id)
     -> std::unique_ptr<DOFData> {
   return std::make_unique<DOFDataPETSc>(dof_id);
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<UInt, UInt, UInt>
 DOFManagerPETSc::registerDOFsInternal(const ID & dof_id,
                                       Array<Real> & dofs_array) {
   dofs_ids.push_back(dof_id);
   auto ret = DOFManager::registerDOFsInternal(dof_id, dofs_array);
   UInt nb_dofs;
   UInt nb_pure_local_dofs;
   std::tie(nb_dofs, nb_pure_local_dofs, std::ignore) = ret;
 
   auto && vector = std::make_unique<SolverVectorPETSc>(*this, id + ":solution");
   auto * x = vector->getVec();
   PETSc_call(VecGetLocalToGlobalMapping, x, &is_ltog_map);
 
   // redoing the indexes based on the petsc numbering
   for (auto & dof_id : dofs_ids) {
     auto & dof_data = this->getDOFDataTyped<DOFDataPETSc>(dof_id);
 
     Array<PetscInt> gidx(dof_data.local_equation_number.size());
     for (auto && data : zip(dof_data.local_equation_number, gidx)) {
       std::get<1>(data) = localToGlobalEquationNumber(std::get<0>(data));
     }
 
     auto & lidx = dof_data.local_equation_number_petsc;
     if (is_ltog_map != nullptr) {
       lidx.resize(gidx.size());
 
       PetscInt n;
       PETSc_call(ISGlobalToLocalMappingApply, is_ltog_map, IS_GTOLM_MASK,
                  gidx.size(), gidx.storage(), &n, lidx.storage());
     }
   }
 
   residual = std::make_unique<SolverVectorPETSc>(*vector, id + ":residual");
   data_cache = std::make_unique<SolverVectorPETSc>(*vector, id + ":data_cache");
   solution = std::move(vector);
 
   for (auto & mat : matrices) {
     auto & A = this->getMatrix(mat.first);
     A.resize();
   }
 
   return ret;
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::assembleToGlobalArray(
     const ID & dof_id, const Array<Real> & array_to_assemble,
     SolverVector & global_array, Real scale_factor) {
   const auto & dof_data = getDOFDataTyped<DOFDataPETSc>(dof_id);
   auto & g = aka::as_type<SolverVectorPETSc>(global_array);
 
   AKANTU_DEBUG_ASSERT(array_to_assemble.size() *
                               array_to_assemble.getNbComponent() ==
                           dof_data.local_nb_dofs,
                       "The array to assemble does not have the proper size");
 
   g.addValuesLocal(dof_data.local_equation_number_petsc, array_to_assemble,
                    scale_factor);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::getArrayPerDOFs(const ID & dof_id,
                                       const SolverVector & global_array,
                                       Array<Real> & local) {
   const auto & dof_data = getDOFDataTyped<DOFDataPETSc>(dof_id);
   const auto & petsc_vector = aka::as_type<SolverVectorPETSc>(global_array);
 
   AKANTU_DEBUG_ASSERT(
       local.size() * local.getNbComponent() == dof_data.local_nb_dofs,
       "The array to get the values does not have the proper size");
 
   petsc_vector.getValuesLocal(dof_data.local_equation_number_petsc, local);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::assembleElementalMatricesToMatrix(
     const ID & matrix_id, const ID & dof_id, const Array<Real> & elementary_mat,
     ElementType type, GhostType ghost_type,
     const MatrixType & elemental_matrix_type,
     const Array<UInt> & filter_elements) {
   auto & A = getMatrix(matrix_id);
   DOFManager::assembleElementalMatricesToMatrix_(
       A, dof_id, elementary_mat, type, ghost_type, elemental_matrix_type,
       filter_elements);
 
   A.applyModifications();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::assemblePreassembledMatrix(
     const ID & matrix_id, const TermsToAssemble & terms) {
   auto & A = getMatrix(matrix_id);
   DOFManager::assemblePreassembledMatrix_(A, terms);
 
   A.applyModifications();
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::assembleMatMulVectToArray(const ID & dof_id,
                                                 const ID & A_id,
                                                 const Array<Real> & x,
                                                 Array<Real> & array,
                                                 Real scale_factor) {
   DOFManager::assembleMatMulVectToArray_<SolverVectorPETSc>(
       dof_id, A_id, x, array, scale_factor);
 }
 
 /* -------------------------------------------------------------------------- */
 void DOFManagerPETSc::makeConsistentForPeriodicity(const ID & /*dof_id*/,
                                                    SolverVector & /*array*/) {}
 
 /* -------------------------------------------------------------------------- */
 NonLinearSolver &
 DOFManagerPETSc::getNewNonLinearSolver(const ID & id,
                                        const NonLinearSolverType & type) {
   return this->registerNonLinearSolver<NonLinearSolverPETSc>(*this, id, type);
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolver & DOFManagerPETSc::getNewTimeStepSolver(
     const ID & id, const TimeStepSolverType & type,
     NonLinearSolver & non_linear_solver, SolverCallback & callback) {
   return this->registerTimeStepSolver<TimeStepSolverDefault>(
       *this, id, type, non_linear_solver, callback);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerPETSc::getNewMatrix(const ID & id,
                                              const MatrixType & matrix_type) {
   return this->registerSparseMatrix<SparseMatrixPETSc>(*this, id, matrix_type);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrix & DOFManagerPETSc::getNewMatrix(const ID & id,
                                              const ID & matrix_to_copy_id) {
   return this->registerSparseMatrix<SparseMatrixPETSc>(id, matrix_to_copy_id);
 }
 
 /* -------------------------------------------------------------------------- */
 SparseMatrixPETSc & DOFManagerPETSc::getMatrix(const ID & id) {
   auto & matrix = DOFManager::getMatrix(id);
   return aka::as_type<SparseMatrixPETSc>(matrix);
 }
 
 /* -------------------------------------------------------------------------- */
 SolverVector & DOFManagerPETSc::getNewLumpedMatrix(const ID & id) {
   return this->registerLumpedMatrix<SolverVectorPETSc>(*this, id);
 }
 
 /* -------------------------------------------------------------------------- */
 SolverVectorPETSc & DOFManagerPETSc::getSolution() {
   return aka::as_type<SolverVectorPETSc>(*this->solution);
 }
 
 const SolverVectorPETSc & DOFManagerPETSc::getSolution() const {
   return aka::as_type<SolverVectorPETSc>(*this->solution);
 }
 
 SolverVectorPETSc & DOFManagerPETSc::getResidual() {
   return aka::as_type<SolverVectorPETSc>(*this->residual);
 }
 
 const SolverVectorPETSc & DOFManagerPETSc::getResidual() const {
   return aka::as_type<SolverVectorPETSc>(*this->residual);
 }
 
 /* -------------------------------------------------------------------------- */
-static bool dof_manager_is_registered [[gnu::unused]] =
+static bool dof_manager_is_registered =
     DOFManagerFactory::getInstance().registerAllocator(
         "petsc", [](Mesh & mesh, const ID & id) -> std::unique_ptr<DOFManager> {
           return std::make_unique<DOFManagerPETSc>(mesh, id);
         });
 
 } // namespace akantu
diff --git a/src/model/contact_mechanics/contact_mechanics_model.cc b/src/model/contact_mechanics/contact_mechanics_model.cc
index 3b9b48f11..39ef230c1 100644
--- a/src/model/contact_mechanics/contact_mechanics_model.cc
+++ b/src/model/contact_mechanics/contact_mechanics_model.cc
@@ -1,713 +1,704 @@
 /**
  * @file   contact_mechanics_model.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Thu Feb 21 2013
  * @date last modification: Wed Jul 28 2021
  *
  * @brief  Contact mechanics model
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "contact_mechanics_model.hh"
 #include "boundary_condition_functor.hh"
 #include "dumpable_inline_impl.hh"
 #include "group_manager_inline_impl.hh"
 #include "integrator_gauss.hh"
 #include "shape_lagrange.hh"
-
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_iohelper_paraview.hh"
-#endif
-
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 ContactMechanicsModel::ContactMechanicsModel(
     Mesh & mesh, UInt dim, const ID & id,
     std::shared_ptr<DOFManager> dof_manager, const ModelType model_type)
     : Model(mesh, model_type, dof_manager, dim, id) {
 
   AKANTU_DEBUG_IN();
 
   this->registerFEEngineObject<MyFEEngineType>("ContactMechanicsModel", mesh,
                                                Model::spatial_dimension);
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("contact_mechanics", id, true);
   this->mesh.addDumpMeshToDumper("contact_mechanics", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_regular);
-#endif
 
   this->registerDataAccessor(*this);
 
   this->detector =
       std::make_unique<ContactDetector>(this->mesh, id + ":contact_detector");
 
   registerFEEngineObject<MyFEEngineType>("ContactFacetsFEEngine", mesh,
                                          Model::spatial_dimension - 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 ContactMechanicsModel::~ContactMechanicsModel() = default;
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initFullImpl(const ModelOptions & options) {
 
   Model::initFullImpl(options);
 
   // initalize the resolutions
   if (not this->parser.getLastParsedFile().empty()) {
     this->instantiateResolutions();
     this->initResolutions();
   }
 
   this->initBC(*this, *displacement, *displacement_increment, *external_force);
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::instantiateResolutions() {
   ParserSection model_section;
   bool is_empty;
   std::tie(model_section, is_empty) = this->getParserSection();
 
   if (not is_empty) {
     auto model_resolutions =
         model_section.getSubSections(ParserType::_contact_resolution);
     for (const auto & section : model_resolutions) {
       this->registerNewResolution(section);
     }
   }
 
   auto sub_sections =
       this->parser.getSubSections(ParserType::_contact_resolution);
   for (const auto & section : sub_sections) {
     this->registerNewResolution(section);
   }
 
   if (resolutions.empty()) {
     AKANTU_EXCEPTION("No contact resolutions where instantiated for the model"
                      << getID());
   }
   are_resolutions_instantiated = true;
 }
 
 /* -------------------------------------------------------------------------- */
 Resolution &
 ContactMechanicsModel::registerNewResolution(const ParserSection & section) {
   std::string res_name;
   std::string res_type = section.getName();
   std::string opt_param = section.getOption();
 
   try {
     std::string tmp = section.getParameter("name");
     res_name = tmp; /** this can seem weird, but there is an ambiguous operator
                      * overload that i couldn't solve. @todo remove the
                      * weirdness of this code
                      */
   } catch (debug::Exception &) {
     AKANTU_ERROR("A contact resolution of type \'"
                  << res_type
                  << "\' in the input file has been defined without a name!");
   }
   Resolution & res = this->registerNewResolution(res_name, res_type, opt_param);
 
   res.parseSection(section);
 
   return res;
 }
 
 /* -------------------------------------------------------------------------- */
 Resolution & ContactMechanicsModel::registerNewResolution(
     const ID & res_name, const ID & res_type, const ID & opt_param) {
   AKANTU_DEBUG_ASSERT(resolutions_names_to_id.find(res_name) ==
                           resolutions_names_to_id.end(),
                       "A resolution with this name '"
                           << res_name << "' has already been registered. "
                           << "Please use unique names for resolutions");
 
   UInt res_count = resolutions.size();
   resolutions_names_to_id[res_name] = res_count;
 
   std::stringstream sstr_res;
   sstr_res << this->id << ":" << res_count << ":" << res_type;
   ID res_id = sstr_res.str();
 
   std::unique_ptr<Resolution> resolution =
       ResolutionFactory::getInstance().allocate(res_type, spatial_dimension,
                                                 opt_param, *this, res_id);
 
   resolutions.push_back(std::move(resolution));
 
   return *(resolutions.back());
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initResolutions() {
   AKANTU_DEBUG_ASSERT(resolutions.size() != 0,
                       "No resolutions to initialize !");
 
   if (!are_resolutions_instantiated) {
     instantiateResolutions();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initModel() {
 
   AKANTU_DEBUG_IN();
 
   getFEEngine("ContactMechanicsModel").initShapeFunctions(_not_ghost);
   getFEEngine("ContactMechanicsModel").initShapeFunctions(_ghost);
 
   getFEEngine("ContactFacetsFEEngine").initShapeFunctions(_not_ghost);
   getFEEngine("ContactFacetsFEEngine").initShapeFunctions(_ghost);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & ContactMechanicsModel::getFEEngineBoundary(const ID & name) {
   return dynamic_cast<FEEngine &>(
       getFEEngineClassBoundary<MyFEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::initSolver(
     TimeStepSolverType /*time_step_solver_type*/,
     NonLinearSolverType /*unused*/) {
 
   // for alloc type of solvers
   this->allocNodalField(this->displacement, spatial_dimension, "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->normal_force, spatial_dimension, "normal_force");
   this->allocNodalField(this->tangential_force, spatial_dimension,
                         "tangential_force");
 
   this->allocNodalField(this->gaps, 1, "gaps");
   this->allocNodalField(this->nodal_area, 1, "areas");
   this->allocNodalField(this->blocked_dofs, 1, "blocked_dofs");
   this->allocNodalField(this->contact_state, 1, "contact_state");
   this->allocNodalField(this->previous_master_elements, 1,
                         "previous_master_elements");
 
   this->allocNodalField(this->normals, spatial_dimension, "normals");
 
   auto surface_dimension = spatial_dimension - 1;
   this->allocNodalField(this->tangents, surface_dimension * spatial_dimension,
                         "tangents");
   this->allocNodalField(this->projections, surface_dimension, "projections");
   this->allocNodalField(this->previous_projections, surface_dimension,
                         "previous_projections");
   this->allocNodalField(this->previous_tangents,
                         surface_dimension * spatial_dimension,
                         "previous_tangents");
   this->allocNodalField(this->tangential_tractions, surface_dimension,
                         "tangential_tractions");
   this->allocNodalField(this->previous_tangential_tractions, surface_dimension,
                         "previous_tangential_tractions");
 
   // todo register multipliers as dofs for lagrange multipliers
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 ContactMechanicsModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped",
                            TimeStepSolverType::_dynamic_lumped);
   }
   case _explicit_consistent_mass: {
     return std::make_tuple("explicit", TimeStepSolverType::_dynamic);
   }
   case _static: {
     return std::make_tuple("static", TimeStepSolverType::_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", TimeStepSolverType::_dynamic);
   }
   default:
     return std::make_tuple("unknown", TimeStepSolverType::_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions ContactMechanicsModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case TimeStepSolverType::_dynamic: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_dynamic_lumped: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_static: {
     options.non_linear_solver_type =
         NonLinearSolverType::_newton_raphson_contact;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
     break;
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   /* ------------------------------------------------------------------------ */
   // computes the internal forces
   this->assembleInternalForces();
 
   /* ------------------------------------------------------------------------ */
   this->getDOFManager().assembleToResidual("displacement",
                                            *this->internal_force, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the contact forces");
 
   UInt nb_nodes = mesh.getNbNodes();
   this->internal_force->clear();
   this->normal_force->clear();
   this->tangential_force->clear();
 
   internal_force->resize(nb_nodes, 0.);
   normal_force->resize(nb_nodes, 0.);
   tangential_force->resize(nb_nodes, 0.);
 
   // assemble the forces due to contact
   auto assemble = [&](auto && ghost_type) {
     for (auto & resolution : resolutions) {
       resolution->assembleInternalForces(ghost_type);
     }
   };
 
   AKANTU_DEBUG_INFO("Assemble residual for local elements");
   assemble(_not_ghost);
 
   // assemble the stresses due to ghost elements
   // AKANTU_DEBUG_INFO("Assemble residual for ghost elements");
   // assemble(_ghost);
 
   AKANTU_DEBUG_OUT();
 }
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::search() {
 
   // save the previous state
   this->savePreviousState();
 
   contact_elements.clear();
 
   // this needs to be resized if cohesive elements are added
   UInt nb_nodes = mesh.getNbNodes();
 
   auto resize_arrays = [&](auto & internal_array) {
     internal_array->resize(nb_nodes);
     internal_array->zero();
   };
 
   resize_arrays(gaps);
   resize_arrays(normals);
   resize_arrays(tangents);
   resize_arrays(projections);
   resize_arrays(tangential_tractions);
   resize_arrays(contact_state);
   resize_arrays(nodal_area);
   resize_arrays(external_force);
 
   this->detector->search(contact_elements, *gaps, *normals, *tangents,
                          *projections);
 
   // intepenetration value must be positive for contact mechanics
   // model to work by default the gap value from detector is negative
   std::for_each((*gaps).begin(), (*gaps).end(), [](Real & gap) { gap *= -1.; });
 
   if (!contact_elements.empty()) {
     this->computeNodalAreas();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::savePreviousState() {
 
   AKANTU_DEBUG_IN();
 
   // saving previous natural projections
   (*previous_projections).copy(*projections);
 
   // saving previous tangents
   (*previous_tangents).copy(*tangents);
 
   // saving previous tangential traction
   (*previous_tangential_tractions).copy(*tangential_tractions);
 
   previous_master_elements->clear();
   previous_master_elements->resize(projections->size());
   previous_master_elements->set(ElementNull);
   for (auto & element : contact_elements) {
     (*previous_master_elements)[element.slave] = element.master;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::computeNodalAreas(GhostType ghost_type) {
 
   UInt nb_nodes = mesh.getNbNodes();
 
   nodal_area->resize(nb_nodes);
   nodal_area->zero();
 
   external_force->resize(nb_nodes);
   external_force->zero();
 
   auto & fem_boundary =
       getFEEngineClassBoundary<MyFEEngineType>("ContactMechanicsModel");
 
   fem_boundary.initShapeFunctions(getPositions(), _not_ghost);
   fem_boundary.initShapeFunctions(getPositions(), _ghost);
 
   fem_boundary.computeNormalsOnIntegrationPoints(_not_ghost);
   fem_boundary.computeNormalsOnIntegrationPoints(_ghost);
 
   IntegrationPoint quad_point;
   quad_point.ghost_type = ghost_type;
 
   auto & group = mesh.getElementGroup("contact_surface");
   UInt nb_degree_of_freedom = external_force->getNbComponent();
 
   for (auto && type : group.elementTypes(spatial_dimension - 1, ghost_type)) {
     const auto & element_ids = group.getElements(type, ghost_type);
 
     UInt nb_quad_points = fem_boundary.getNbIntegrationPoints(type, ghost_type);
     UInt nb_elements = element_ids.size();
 
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
     Array<Real> dual_before_integ(nb_elements * nb_quad_points,
                                   nb_degree_of_freedom, 0.);
     Array<Real> quad_coords(nb_elements * nb_quad_points, spatial_dimension);
 
     const auto & normals_on_quad =
         fem_boundary.getNormalsOnIntegrationPoints(type, ghost_type);
 
     auto normals_begin = normals_on_quad.begin(spatial_dimension);
     decltype(normals_begin) normals_iter;
     auto quad_coords_iter = quad_coords.begin(spatial_dimension);
     auto dual_iter = dual_before_integ.begin(nb_degree_of_freedom);
 
     quad_point.type = type;
 
     Element subelement;
     subelement.type = type;
     subelement.ghost_type = ghost_type;
     for (auto el : element_ids) {
       subelement.element = el;
       const auto & element_to_subelement =
           mesh.getElementToSubelement(type)(el);
 
       Vector<Real> outside(spatial_dimension);
       mesh.getBarycenter(subelement, outside);
 
       Vector<Real> inside(spatial_dimension);
       if (mesh.isMeshFacets()) {
         mesh.getMeshParent().getBarycenter(element_to_subelement[0], inside);
       } else {
         mesh.getBarycenter(element_to_subelement[0], inside);
       }
 
       Vector<Real> inside_to_outside(spatial_dimension);
       inside_to_outside = outside - inside;
 
       normals_iter = normals_begin + el * nb_quad_points;
 
       quad_point.element = el;
       for (auto q : arange(nb_quad_points)) {
         quad_point.num_point = q;
         auto ddot = inside_to_outside.dot(*normals_iter);
         Vector<Real> normal(*normals_iter);
         if (ddot < 0) {
           normal *= -1.0;
         }
 
         (*dual_iter)
             .mul<false>(Matrix<Real>::eye(spatial_dimension, 1), normal);
         ++dual_iter;
         ++quad_coords_iter;
         ++normals_iter;
       }
     }
 
     Array<Real> dual_by_shapes(nb_elements * nb_quad_points,
                                nb_degree_of_freedom * nb_nodes_per_element);
 
     fem_boundary.computeNtb(dual_before_integ, dual_by_shapes, type, ghost_type,
                             element_ids);
 
     Array<Real> dual_by_shapes_integ(nb_elements, nb_degree_of_freedom *
                                                       nb_nodes_per_element);
     fem_boundary.integrate(dual_by_shapes, dual_by_shapes_integ,
                            nb_degree_of_freedom * nb_nodes_per_element, type,
                            ghost_type, element_ids);
 
     this->getDOFManager().assembleElementalArrayLocalArray(
         dual_by_shapes_integ, *external_force, type, ghost_type, 1.,
         element_ids);
   }
 
   for (auto && tuple :
        zip(*nodal_area, make_view(*external_force, spatial_dimension))) {
 
     auto & area = std::get<0>(tuple);
     Vector<Real> force(std::get<1>(tuple));
     area = force.norm();
   }
 
   this->external_force->clear();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::printself(std::ostream & stream, int indent) const {
   std::string space(indent, AKANTU_INDENT);
 
   stream << space << "Contact 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 << " + resolutions [" << std::endl;
   for (const auto & resolution : resolutions) {
     resolution->printself(stream, indent + 1);
   }
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType ContactMechanicsModel::getMatrixType(const ID & matrix_id) const {
   if (matrix_id == "K") {
     return _symmetric;
   }
 
   return _mt_not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleMatrix(const ID & matrix_id) {
   if (matrix_id == "K") {
     this->assembleStiffnessMatrix();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix");
 
   if (!this->getDOFManager().hasMatrix("K")) {
     this->getDOFManager().getNewMatrix("K", getMatrixType("K"));
   }
 
   for (auto & resolution : resolutions) {
     resolution->assembleStiffnessMatrix(_not_ghost);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::assembleLumpedMatrix(const ID & /*matrix_id*/) {
   AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::beforeSolveStep() {
   for (auto & resolution : resolutions) {
     resolution->beforeSolveStep();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::afterSolveStep(bool converged) {
   for (auto & resolution : resolutions) {
     resolution->afterSolveStep(converged);
   }
 }
 
-/* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
-
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 ContactMechanicsModel::createNodalFieldBool(const std::string & /*unused*/,
                                             const std::string & /*unused*/,
                                             bool /*unused*/) {
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 ContactMechanicsModel::createNodalFieldReal(const std::string & field_name,
                                             const std::string & group_name,
                                             bool padding_flag) {
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["contact_force"] = this->internal_force.get();
   real_nodal_fields["normal_force"] = this->normal_force.get();
   real_nodal_fields["tangential_force"] = this->tangential_force.get();
   real_nodal_fields["blocked_dofs"] = this->blocked_dofs.get();
   real_nodal_fields["normals"] = this->normals.get();
   real_nodal_fields["tangents"] = this->tangents.get();
   real_nodal_fields["gaps"] = this->gaps.get();
   real_nodal_fields["areas"] = this->nodal_area.get();
   real_nodal_fields["tangential_traction"] = this->tangential_tractions.get();
 
   std::shared_ptr<dumpers::Field> field;
   if (padding_flag) {
     field = this->mesh.createNodalField(real_nodal_fields[field_name],
                                         group_name, 3);
   } else {
     field =
         this->mesh.createNodalField(real_nodal_fields[field_name], group_name);
   }
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 ContactMechanicsModel::createNodalFieldUInt(const std::string & field_name,
                                             const std::string & group_name,
                                             bool /*padding_flag*/) {
   std::shared_ptr<dumpers::Field> field;
   if (field_name == "contact_state") {
     auto && func =
         std::make_unique<dumpers::ComputeUIntFromEnum<ContactState>>();
     field = mesh.createNodalField(this->contact_state.get(), group_name);
     field =
         dumpers::FieldComputeProxy::createFieldCompute(field, std::move(func));
   }
   return field;
 }
-#endif
 
 /* -------------------------------------------------------------------------- */
 UInt ContactMechanicsModel::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);
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::packData(CommunicationBuffer & /*buffer*/,
                                      const Array<Element> & /*elements*/,
                                      const SynchronizationTag & /*tag*/) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::unpackData(CommunicationBuffer & /*buffer*/,
                                        const Array<Element> & /*elements*/,
                                        const SynchronizationTag & /*tag*/) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 UInt ContactMechanicsModel::getNbData(
     const Array<UInt> & dofs, const SynchronizationTag & /*tag*/) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
 
   AKANTU_DEBUG_OUT();
   return size * dofs.size();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::packData(CommunicationBuffer & /*buffer*/,
                                      const Array<UInt> & /*dofs*/,
                                      const SynchronizationTag & /*tag*/) const {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void ContactMechanicsModel::unpackData(CommunicationBuffer & /*buffer*/,
                                        const Array<UInt> & /*dofs*/,
                                        const SynchronizationTag & /*tag*/) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/contact_mechanics/contact_mechanics_model.hh b/src/model/contact_mechanics/contact_mechanics_model.hh
index cecc2e64b..cddce2919 100644
--- a/src/model/contact_mechanics/contact_mechanics_model.hh
+++ b/src/model/contact_mechanics/contact_mechanics_model.hh
@@ -1,374 +1,372 @@
 /**
  * @file   contact_mechanics_model.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Thu Jun 24 2021
  *
  * @brief  Model of Contact Mechanics
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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 "contact_detector.hh"
 #include "data_accessor.hh"
 #include "fe_engine.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_CONTACT_MECHANICS_MODEL_HH__
 #define __AKANTU_CONTACT_MECHANICS_MODEL_HH__
 
 namespace akantu {
 class Resolution;
 template <ElementKind kind, class IntegrationOrderFunctor>
 class IntegratorGauss;
 template <ElementKind kind> class ShapeLagrange;
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 class ContactMechanicsModel : public Model,
                               public DataAccessor<Element>,
                               public DataAccessor<UInt>,
                               public BoundaryCondition<ContactMechanicsModel> {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 
   using MyFEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>;
 
 public:
   ContactMechanicsModel(
       Mesh & mesh, UInt dim = _all_dimensions,
       const ID & id = "contact_mechanics_model",
       std::shared_ptr<DOFManager> dof_manager = nullptr,
       ModelType model_type = ModelType::_contact_mechanics_model);
 
   ~ContactMechanicsModel() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   /// initialize completely the model
   void initFullImpl(const ModelOptions & options) override;
 
   /// allocate all vectors
   void initSolver(TimeStepSolverType /*unused*/,
                   NonLinearSolverType /*unused*/) override;
 
   /// initialize all internal arrays for resolutions
   void initResolutions();
 
   /// initialize the modelType
   void initModel() override;
 
   /// call back for the solver, computes the force residual
   void assembleResidual() override;
 
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID & matrix_id) const 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;
 
   /// get some default values for derived classes
   std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) override;
 
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const 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(bool converged = true) override;
 
   /// function to print the containt of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /* ------------------------------------------------------------------------ */
   /* Contact Detection                                                        */
   /* ------------------------------------------------------------------------ */
 public:
   void search();
 
   void computeNodalAreas(GhostType ghost_type = _not_ghost);
 
   /* ------------------------------------------------------------------------ */
   /* Contact Resolution                                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// register an empty contact resolution of a given type
   Resolution & registerNewResolution(const ID & res_name, const ID & res_type,
                                      const ID & opt_param);
 
 protected:
   /// register a resolution in the dynamic database
   Resolution & registerNewResolution(const ParserSection & res_section);
 
   /// read the resolution files to instantiate all the resolutions
   void instantiateResolutions();
 
   /// save the parameters from previous state
   void savePreviousState();
 
   /* ------------------------------------------------------------------------ */
   /* Solver Interface                                                         */
   /* ------------------------------------------------------------------------ */
 public:
   /// assembles the contact stiffness matrix
   virtual void assembleStiffnessMatrix();
 
   /// assembles the contant internal forces
   virtual void assembleInternalForces();
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   FEEngine & getFEEngineBoundary(const ID & name = "") override;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
-#if defined(AKANTU_USE_IOHELPER)
   std::shared_ptr<dumpers::Field>
   createNodalFieldReal(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createNodalFieldUInt(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createNodalFieldBool(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
-#endif
 
   /* ------------------------------------------------------------------------ */
   /* 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:
   /// contact detection class
   friend class ContactDetector;
 
   /// contact resolution class
   friend class Resolution;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the ContactMechanicsModel::displacement vector
   AKANTU_GET_MACRO(Displacement, *displacement, Array<Real> &);
 
   /// get  the ContactMechanicsModel::increment  vector \warn  only  consistent
   /// if ContactMechanicsModel::setIncrementFlagOn has been called before
   AKANTU_GET_MACRO(Increment, *displacement_increment, Array<Real> &);
 
   /// get the ContactMechanics::internal_force vector (internal forces)
   AKANTU_GET_MACRO(InternalForce, *internal_force, Array<Real> &);
 
   /// get the ContactMechanicsModel::external_force vector (external forces)
   AKANTU_GET_MACRO(ExternalForce, *external_force, Array<Real> &);
 
   /// get the ContactMechanics::normal_force vector (normal forces)
   AKANTU_GET_MACRO(NormalForce, *normal_force, Array<Real> &);
 
   /// get the ContactMechanics::tangential_force vector (friction forces)
   AKANTU_GET_MACRO(TangentialForce, *tangential_force, Array<Real> &);
 
   /// get the ContactMechanics::traction vector (friction traction)
   AKANTU_GET_MACRO(TangentialTractions, *tangential_tractions, Array<Real> &);
 
   /// get the ContactMechanics::previous_tangential_tractions vector
   AKANTU_GET_MACRO(PreviousTangentialTractions, *previous_tangential_tractions,
                    Array<Real> &);
 
   /// get the ContactMechanicsModel::force vector (external forces)
   Array<Real> & getForce() {
     AKANTU_DEBUG_WARNING("getForce was maintained for backward compatibility, "
                          "use getExternalForce instead");
     return *external_force;
   }
 
   /// get the ContactMechanics::blocked_dofs vector
   AKANTU_GET_MACRO(BlockedDOFs, *blocked_dofs, Array<Real> &);
 
   /// get the ContactMechanics::gaps (contact gaps)
   AKANTU_GET_MACRO(Gaps, *gaps, Array<Real> &);
 
   /// get the ContactMechanics::normals (normals on slave nodes)
   AKANTU_GET_MACRO(Normals, *normals, Array<Real> &);
 
   /// get the ContactMechanics::tangents (tangents on slave nodes)
   AKANTU_GET_MACRO(Tangents, *tangents, Array<Real> &);
 
   /// get the ContactMechanics::previous_tangents (tangents on slave nodes)
   AKANTU_GET_MACRO(PreviousTangents, *previous_tangents, Array<Real> &);
 
   /// get the ContactMechanics::areas (nodal areas)
   AKANTU_GET_MACRO(NodalArea, *nodal_area, Array<Real> &);
 
   /// get the ContactMechanics::previous_projections (previous_projections)
   AKANTU_GET_MACRO(PreviousProjections, *previous_projections, Array<Real> &);
 
   /// get the ContactMechanics::projections (projections)
   AKANTU_GET_MACRO(Projections, *projections, Array<Real> &);
 
   /// get the ContactMechanics::contact_state vector (no_contact/stick/slip
   /// state)
   AKANTU_GET_MACRO(ContactState, *contact_state, Array<ContactState> &);
 
   /// get the ContactMechanics::previous_master_elements
   AKANTU_GET_MACRO(PreviousMasterElements, *previous_master_elements,
                    Array<Element> &);
 
   /// get contact detector
   AKANTU_GET_MACRO_NOT_CONST(ContactDetector, *detector, ContactDetector &);
 
   /// get the contact elements
   inline const Array<ContactElement> & getContactElements() const {
     return contact_elements;
   }
 
   /// get the current positions of the nodes
   inline Array<Real> & getPositions() { return detector->getPositions(); }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   /// tells if the resolutions are instantiated
   bool are_resolutions_instantiated;
 
   /// displacements array
   std::unique_ptr<Array<Real>> displacement;
 
   /// increment of displacement
   std::unique_ptr<Array<Real>> displacement_increment;
 
   /// contact forces array
   std::unique_ptr<Array<Real>> internal_force;
 
   /// external forces array
   std::unique_ptr<Array<Real>> external_force;
 
   /// normal force array
   std::unique_ptr<Array<Real>> normal_force;
 
   /// friction force array
   std::unique_ptr<Array<Real>> tangential_force;
 
   /// friction traction array
   std::unique_ptr<Array<Real>> tangential_tractions;
 
   /// previous friction traction array
   std::unique_ptr<Array<Real>> previous_tangential_tractions;
 
   /// boundary vector
   std::unique_ptr<Array<Real>> blocked_dofs;
 
   /// array to store gap between slave and master
   std::unique_ptr<Array<Real>> gaps;
 
   /// array to store normals from master to slave
   std::unique_ptr<Array<Real>> normals;
 
   /// array to store tangents on the master element
   std::unique_ptr<Array<Real>> tangents;
 
   /// array to store previous tangents on the master element
   std::unique_ptr<Array<Real>> previous_tangents;
 
   /// array to store nodal areas
   std::unique_ptr<Array<Real>> nodal_area;
 
   /// array to store stick/slip state :
   std::unique_ptr<Array<ContactState>> contact_state;
 
   /// array to store previous projections in covariant basis
   std::unique_ptr<Array<Real>> previous_projections;
 
   // array to store projections in covariant basis
   std::unique_ptr<Array<Real>> projections;
 
   /// contact detection
   std::unique_ptr<ContactDetector> detector;
 
   /// list of contact resolutions
   std::vector<std::unique_ptr<Resolution>> resolutions;
 
   /// mapping between resolution name and resolution internal id
   std::map<std::string, UInt> resolutions_names_to_id;
 
   /// array to store contact elements
   Array<ContactElement> contact_elements;
 
   /// array to store previous master elements
   std::unique_ptr<Array<Element>> previous_master_elements;
 };
 
 } // namespace akantu
 
 /* ------------------------------------------------------------------------ */
 /* inline functions                                                         */
 /* ------------------------------------------------------------------------ */
 #include "parser.hh"
 #include "resolution.hh"
 /* ------------------------------------------------------------------------ */
 
 #endif /* __AKANTU_CONTACT_MECHANICS_MODEL_HH__ */
diff --git a/src/model/heat_transfer/heat_transfer_model.cc b/src/model/heat_transfer/heat_transfer_model.cc
index 2d9064dc5..d00ef47ff 100644
--- a/src/model/heat_transfer/heat_transfer_model.cc
+++ b/src/model/heat_transfer/heat_transfer_model.cc
@@ -1,919 +1,884 @@
 /**
  * @file   heat_transfer_model.cc
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Emil Gallyamov <emil.gallyamov@epfl.ch>
  * @author David Simon Kammer <david.kammer@epfl.ch>
  * @author Srinivasa Babu Ramisetti <srinivasa.ramisetti@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Rui Wang <rui.wang@epfl.ch>
  *
  * @date creation: Sun May 01 2011
  * @date last modification: Fri Apr 09 2021
  *
  * @brief  Implementation of HeatTransferModel class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "heat_transfer_model.hh"
 #include "dumpable_inline_impl.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine_template.hh"
 #include "generalized_trapezoidal.hh"
 #include "group_manager_inline_impl.hh"
 #include "integrator_gauss.hh"
 #include "mesh.hh"
 #include "parser.hh"
 #include "shape_lagrange.hh"
-
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_element_partition.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_internal_material_field.hh"
 #include "dumper_iohelper_paraview.hh"
-#endif
-
 /* -------------------------------------------------------------------------- */
+
 namespace akantu {
 
 namespace heat_transfer {
   namespace details {
     class ComputeRhoFunctor {
     public:
       ComputeRhoFunctor(const HeatTransferModel & model) : model(model){};
 
       void operator()(Matrix<Real> & rho, const Element & /*unused*/) {
         rho.set(model.getCapacity() * model.getDensity());
       }
 
     private:
       const HeatTransferModel & model;
     };
   } // namespace details
 } // namespace heat_transfer
 
 /* -------------------------------------------------------------------------- */
 HeatTransferModel::HeatTransferModel(Mesh & mesh, UInt dim, const ID & id,
                                      std::shared_ptr<DOFManager> dof_manager)
     : Model(mesh, ModelType::_heat_transfer_model, dof_manager, dim, id),
       temperature_gradient("temperature_gradient", id),
       temperature_on_qpoints("temperature_on_qpoints", id),
       conductivity_on_qpoints("conductivity_on_qpoints", id),
       k_gradt_on_qpoints("k_gradt_on_qpoints", id) {
   AKANTU_DEBUG_IN();
 
   conductivity = Matrix<Real>(this->spatial_dimension, this->spatial_dimension);
 
   this->registerDataAccessor(*this);
 
   if (this->mesh.isDistributed()) {
     auto & synchronizer = this->mesh.getElementSynchronizer();
     this->registerSynchronizer(synchronizer,
                                SynchronizationTag::_htm_temperature);
     this->registerSynchronizer(synchronizer,
                                SynchronizationTag::_htm_gradient_temperature);
   }
 
   registerFEEngineObject<FEEngineType>(id + ":fem", mesh, spatial_dimension);
 
-#ifdef AKANTU_USE_IOHELPER
   this->mesh.registerDumper<DumperParaview>("heat_transfer", id, true);
   this->mesh.addDumpMesh(mesh, spatial_dimension, _not_ghost, _ek_regular);
-#endif
 
   this->registerParam("conductivity", conductivity, _pat_parsmod);
   this->registerParam("conductivity_variation", conductivity_variation, 0.,
                       _pat_parsmod);
   this->registerParam("temperature_reference", T_ref, 0., _pat_parsmod);
   this->registerParam("capacity", capacity, _pat_parsmod);
   this->registerParam("density", density, _pat_parsmod);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initModel() {
   auto & fem = this->getFEEngine();
   fem.initShapeFunctions(_not_ghost);
   fem.initShapeFunctions(_ghost);
 
   temperature_on_qpoints.initialize(fem, _nb_component = 1);
   temperature_gradient.initialize(fem, _nb_component = spatial_dimension);
   conductivity_on_qpoints.initialize(fem, _nb_component = spatial_dimension *
                                                           spatial_dimension);
   k_gradt_on_qpoints.initialize(fem, _nb_component = spatial_dimension);
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & HeatTransferModel::getFEEngineBoundary(const ID & name) {
   return aka::as_type<FEEngine>(getFEEngineClassBoundary<FEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 HeatTransferModel::~HeatTransferModel() = default;
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacityLumped(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   auto & fem = getFEEngineClass<FEEngineType>();
   heat_transfer::details::ComputeRhoFunctor compute_rho(*this);
 
   for (auto && type :
        mesh.elementTypes(spatial_dimension, ghost_type, _ek_regular)) {
     fem.assembleFieldLumped(compute_rho, "M", "temperature",
                             this->getDOFManager(), type, ghost_type);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType HeatTransferModel::getMatrixType(const ID & matrix_id) const {
   if (matrix_id == "K" or matrix_id == "M") {
     return _symmetric;
   }
 
   return _mt_not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleMatrix(const ID & matrix_id) {
   if (matrix_id == "K") {
     this->assembleConductivityMatrix();
   } else if (matrix_id == "M" and need_to_reassemble_capacity) {
     this->assembleCapacity();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleLumpedMatrix(const ID & matrix_id) {
   if (matrix_id == "M" and need_to_reassemble_capacity) {
     this->assembleCapacityLumped();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   this->assembleInternalHeatRate();
 
   this->getDOFManager().assembleToResidual("temperature",
                                            *this->external_heat_rate, 1);
   this->getDOFManager().assembleToResidual("temperature",
                                            *this->internal_heat_rate, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::predictor() { ++temperature_release; }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacityLumped() {
   AKANTU_DEBUG_IN();
 
   if (!this->getDOFManager().hasLumpedMatrix("M")) {
     this->getDOFManager().getNewLumpedMatrix("M");
   }
 
   this->getDOFManager().zeroLumpedMatrix("M");
 
   assembleCapacityLumped(_not_ghost);
   assembleCapacityLumped(_ghost);
 
   need_to_reassemble_capacity_lumped = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initSolver(TimeStepSolverType time_step_solver_type,
                                    NonLinearSolverType /*unused*/) {
   DOFManager & dof_manager = this->getDOFManager();
 
   this->allocNodalField(this->temperature, 1, "temperature");
   this->allocNodalField(this->external_heat_rate, 1, "external_heat_rate");
   this->allocNodalField(this->internal_heat_rate, 1, "internal_heat_rate");
   this->allocNodalField(this->blocked_dofs, 1, "blocked_dofs");
 
   if (!dof_manager.hasDOFs("temperature")) {
     dof_manager.registerDOFs("temperature", *this->temperature, _dst_nodal);
     dof_manager.registerBlockedDOFs("temperature", *this->blocked_dofs);
   }
 
   if (time_step_solver_type == TimeStepSolverType::_dynamic ||
       time_step_solver_type == TimeStepSolverType::_dynamic_lumped) {
     this->allocNodalField(this->temperature_rate, 1, "temperature_rate");
 
     if (!dof_manager.hasDOFsDerivatives("temperature", 1)) {
       dof_manager.registerDOFsDerivative("temperature", 1,
                                          *this->temperature_rate);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 HeatTransferModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped",
                            TimeStepSolverType::_dynamic_lumped);
   }
   case _static: {
     return std::make_tuple("static", TimeStepSolverType::_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", TimeStepSolverType::_dynamic);
   }
   default:
     return std::make_tuple("unknown", TimeStepSolverType::_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions HeatTransferModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case TimeStepSolverType::_dynamic_lumped: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["temperature"] =
         IntegrationSchemeType::_forward_euler;
     options.solution_type["temperature"] = IntegrationScheme::_temperature_rate;
     break;
   }
   case TimeStepSolverType::_static: {
     options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
     options.integration_scheme_type["temperature"] =
         IntegrationSchemeType::_pseudo_time;
     options.solution_type["temperature"] = IntegrationScheme::_not_defined;
     break;
   }
   case TimeStepSolverType::_dynamic: {
     if (this->method == _explicit_consistent_mass) {
       options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
       options.integration_scheme_type["temperature"] =
           IntegrationSchemeType::_forward_euler;
       options.solution_type["temperature"] =
           IntegrationScheme::_temperature_rate;
     } else {
       options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
       options.integration_scheme_type["temperature"] =
           IntegrationSchemeType::_backward_euler;
       options.solution_type["temperature"] = IntegrationScheme::_temperature;
     }
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleConductivityMatrix() {
   AKANTU_DEBUG_IN();
 
   this->computeConductivityOnQuadPoints(_not_ghost);
 
   if (conductivity_release[_not_ghost] == conductivity_matrix_release) {
     return;
   }
 
   AKANTU_DEBUG_ASSERT(this->getDOFManager().hasMatrix("K"),
                       "The K matrix has not been initialized yet.");
 
   this->getDOFManager().zeroMatrix("K");
 
   auto & fem = this->getFEEngine();
 
   for (auto && type : mesh.elementTypes(spatial_dimension)) {
     auto nb_element = mesh.getNbElement(type);
     auto nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
     auto nb_quadrature_points = fem.getNbIntegrationPoints(type);
 
     auto bt_d_b = std::make_unique<Array<Real>>(
         nb_element * nb_quadrature_points,
         nb_nodes_per_element * nb_nodes_per_element, "B^t*D*B");
 
     fem.computeBtDB(conductivity_on_qpoints(type), *bt_d_b, 2, type);
 
     /// compute @f$ k_e = \int_e \mathbf{B}^t * \mathbf{D} * \mathbf{B}@f$
     auto K_e = std::make_unique<Array<Real>>(
         nb_element, nb_nodes_per_element * nb_nodes_per_element, "K_e");
 
     fem.integrate(*bt_d_b, *K_e, nb_nodes_per_element * nb_nodes_per_element,
                   type);
 
     this->getDOFManager().assembleElementalMatricesToMatrix(
         "K", "temperature", *K_e, type, _not_ghost, _symmetric);
   }
 
   conductivity_matrix_release = conductivity_release[_not_ghost];
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeConductivityOnQuadPoints(GhostType ghost_type) {
   // if already computed once check if need to compute
   if (not initial_conductivity[ghost_type]) {
     // if temperature did not change, conductivity will not vary
     if (temperature_release == conductivity_release[ghost_type]) {
       return;
     }
     // if conductivity_variation is 0 no need to recompute
     if (conductivity_variation == 0.) {
       return;
     }
   }
 
   for (auto && type :
        mesh.elementTypes(spatial_dimension, ghost_type, _ek_regular)) {
     auto & temperature_interpolated = temperature_on_qpoints(type, ghost_type);
 
     // compute the temperature on quadrature points
     this->getFEEngine().interpolateOnIntegrationPoints(
         *temperature, temperature_interpolated, 1, type, ghost_type);
 
     auto & cond = conductivity_on_qpoints(type, ghost_type);
     for (auto && tuple :
          zip(make_view(cond, spatial_dimension, spatial_dimension),
              temperature_interpolated)) {
       auto & C = std::get<0>(tuple);
       auto & T = std::get<1>(tuple);
       C = conductivity;
 
       Matrix<Real> variation(spatial_dimension, spatial_dimension,
                              conductivity_variation * (T - T_ref));
       // @TODO: Guillaume are you sure ? why due you compute variation then ?
       C += conductivity_variation;
     }
   }
 
   conductivity_release[ghost_type] = temperature_release;
   initial_conductivity[ghost_type] = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeKgradT(GhostType ghost_type) {
   computeConductivityOnQuadPoints(ghost_type);
 
   for (auto && type :
        mesh.elementTypes(spatial_dimension, ghost_type, _ek_regular)) {
     auto & gradient = temperature_gradient(type, ghost_type);
     this->getFEEngine().gradientOnIntegrationPoints(*temperature, gradient, 1,
                                                     type, ghost_type);
 
     for (auto && values :
          zip(make_view(conductivity_on_qpoints(type, ghost_type),
                        spatial_dimension, spatial_dimension),
              make_view(gradient, spatial_dimension),
              make_view(k_gradt_on_qpoints(type, ghost_type),
                        spatial_dimension))) {
       const auto & C = std::get<0>(values);
       const auto & BT = std::get<1>(values);
       auto & k_BT = std::get<2>(values);
 
       k_BT.mul<false>(C, BT);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleInternalHeatRate() {
   AKANTU_DEBUG_IN();
 
   this->internal_heat_rate->zero();
 
   this->synchronize(SynchronizationTag::_htm_temperature);
   auto & fem = this->getFEEngine();
 
   for (auto ghost_type : ghost_types) {
     // compute k \grad T
     computeKgradT(ghost_type);
 
     for (auto type :
          mesh.elementTypes(spatial_dimension, ghost_type, _ek_regular)) {
       UInt nb_nodes_per_element = Mesh::getNbNodesPerElement(type);
 
       auto & k_gradt_on_qpoints_vect = k_gradt_on_qpoints(type, ghost_type);
 
       UInt nb_quad_points = k_gradt_on_qpoints_vect.size();
       Array<Real> bt_k_gT(nb_quad_points, nb_nodes_per_element);
       fem.computeBtD(k_gradt_on_qpoints_vect, bt_k_gT, type, ghost_type);
 
       UInt nb_elements = mesh.getNbElement(type, ghost_type);
       Array<Real> int_bt_k_gT(nb_elements, nb_nodes_per_element);
 
       fem.integrate(bt_k_gT, int_bt_k_gT, nb_nodes_per_element, type,
                     ghost_type);
 
       this->getDOFManager().assembleElementalArrayLocalArray(
           int_bt_k_gT, *this->internal_heat_rate, type, ghost_type, -1);
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getStableTimeStep() {
   AKANTU_DEBUG_IN();
 
   Real el_size;
   Real min_el_size = std::numeric_limits<Real>::max();
   Real conductivitymax = conductivity(0, 0);
 
   // get the biggest parameter from k11 until k33//
   for (UInt i = 0; i < spatial_dimension; i++) {
     for (UInt j = 0; j < spatial_dimension; j++) {
       conductivitymax = std::max(conductivity(i, j), conductivitymax);
     }
   }
   for (auto && type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_regular)) {
 
     UInt nb_nodes_per_element = mesh.getNbNodesPerElement(type);
 
     Array<Real> coord(0, nb_nodes_per_element * spatial_dimension);
     FEEngine::extractNodalToElementField(mesh, mesh.getNodes(), coord, type,
                                          _not_ghost);
 
     auto el_coord = coord.begin(spatial_dimension, nb_nodes_per_element);
     UInt nb_element = mesh.getNbElement(type);
 
     for (UInt el = 0; el < nb_element; ++el, ++el_coord) {
       el_size = getFEEngine().getElementInradius(*el_coord, type);
       min_el_size = std::min(min_el_size, el_size);
     }
 
     AKANTU_DEBUG_INFO("The minimum element size : "
                       << min_el_size
                       << " and the max conductivity is : " << conductivitymax);
   }
 
   Real min_dt = 2. * min_el_size * min_el_size / 4. * density * capacity /
                 conductivitymax;
 
   mesh.getCommunicator().allReduce(min_dt, SynchronizerOperation::_min);
 
   AKANTU_DEBUG_OUT();
 
   return min_dt;
 }
 /* -------------------------------------------------------------------------- */
 
 void HeatTransferModel::setTimeStep(Real time_step, const ID & solver_id) {
   Model::setTimeStep(time_step, solver_id);
 
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper("heat_transfer").setTimeStep(time_step);
-#endif
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::readMaterials() {
   auto sect = this->getParserSection();
 
   if (not std::get<1>(sect)) {
     const auto & section = std::get<0>(sect);
     this->parseSection(section);
   }
 
   conductivity_on_qpoints.set(conductivity);
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::initFullImpl(const ModelOptions & options) {
   Model::initFullImpl(options);
 
   readMaterials();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::assembleCapacity() {
   AKANTU_DEBUG_IN();
   auto ghost_type = _not_ghost;
 
   this->getDOFManager().zeroMatrix("M");
 
   auto & fem = getFEEngineClass<FEEngineType>();
 
   heat_transfer::details::ComputeRhoFunctor rho_functor(*this);
 
   for (auto && type :
        mesh.elementTypes(spatial_dimension, ghost_type, _ek_regular)) {
     fem.assembleFieldMatrix(rho_functor, "M", "temperature",
                             this->getDOFManager(), type, ghost_type);
   }
 
   need_to_reassemble_capacity = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void HeatTransferModel::computeRho(Array<Real> & rho, ElementType type,
                                    GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   FEEngine & fem = this->getFEEngine();
   UInt nb_element = mesh.getNbElement(type, ghost_type);
   UInt nb_quadrature_points = fem.getNbIntegrationPoints(type, ghost_type);
 
   rho.resize(nb_element * nb_quadrature_points);
   rho.set(this->capacity);
 
   // Real * rho_1_val = rho.storage();
   // /// compute @f$ rho @f$ for each nodes of each element
   // for (UInt el = 0; el < nb_element; ++el) {
   //   for (UInt n = 0; n < nb_quadrature_points; ++n) {
   //     *rho_1_val++ = this->capacity;
   //   }
   // }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::computeThermalEnergyByNode() {
   AKANTU_DEBUG_IN();
 
   Real ethermal = 0.;
 
   for (auto && pair : enumerate(make_view(
            *internal_heat_rate, internal_heat_rate->getNbComponent()))) {
     auto n = std::get<0>(pair);
     auto & heat_rate = std::get<1>(pair);
 
     Real heat = 0.;
     bool is_local_node = mesh.isLocalOrMasterNode(n);
     bool count_node = is_local_node;
 
     for (UInt i = 0; i < heat_rate.size(); ++i) {
       if (count_node) {
         heat += heat_rate[i] * time_step;
       }
     }
     ethermal += heat;
   }
 
   mesh.getCommunicator().allReduce(ethermal, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return ethermal;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class iterator>
 void HeatTransferModel::getThermalEnergy(
     iterator Eth, Array<Real>::const_iterator<Real> T_it,
     const Array<Real>::const_iterator<Real> & T_end) const {
   for (; T_it != T_end; ++T_it, ++Eth) {
     *Eth = capacity * density * *T_it;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getThermalEnergy(ElementType type, UInt index) {
   AKANTU_DEBUG_IN();
 
   UInt nb_quadrature_points = getFEEngine().getNbIntegrationPoints(type);
   Vector<Real> Eth_on_quarature_points(nb_quadrature_points);
 
   auto T_it = this->temperature_on_qpoints(type).begin();
   T_it += index * nb_quadrature_points;
 
   auto T_end = T_it + nb_quadrature_points;
 
   getThermalEnergy(Eth_on_quarature_points.storage(), T_it, T_end);
 
   return getFEEngine().integrate(Eth_on_quarature_points, type, index);
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getThermalEnergy() {
   Real Eth = 0;
 
   auto & fem = getFEEngine();
 
   for (auto && type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_regular)) {
     auto nb_element = mesh.getNbElement(type, _not_ghost);
     auto nb_quadrature_points = fem.getNbIntegrationPoints(type, _not_ghost);
     Array<Real> Eth_per_quad(nb_element * nb_quadrature_points, 1);
 
     auto & temperature_interpolated = temperature_on_qpoints(type);
 
     // compute the temperature on quadrature points
     this->getFEEngine().interpolateOnIntegrationPoints(
         *temperature, temperature_interpolated, 1, type);
 
     auto T_it = temperature_interpolated.begin();
     auto T_end = temperature_interpolated.end();
     getThermalEnergy(Eth_per_quad.begin(), T_it, T_end);
 
     Eth += fem.integrate(Eth_per_quad, type);
   }
 
   return Eth;
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getEnergy(const std::string & id) {
   AKANTU_DEBUG_IN();
   Real energy = 0;
 
   if (id == "thermal") {
     energy = getThermalEnergy();
   }
   // reduction sum over all processors
   mesh.getCommunicator().allReduce(energy, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 Real HeatTransferModel::getEnergy(const std::string & id, ElementType type,
                                   UInt index) {
   AKANTU_DEBUG_IN();
 
   Real energy = 0.;
 
   if (id == "thermal") {
     energy = getThermalEnergy(type, index);
   }
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
-/* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
-
 std::shared_ptr<dumpers::Field> HeatTransferModel::createNodalFieldBool(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs.get();
 
   auto field = mesh.createNodalField(uint_nodal_fields[field_name], group_name);
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field> HeatTransferModel::createNodalFieldReal(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   if (field_name == "capacity_lumped") {
     AKANTU_EXCEPTION(
         "Capacity lumped is a nodal field now stored in the DOF manager."
         "Therefore it cannot be used by a dumper anymore");
   }
 
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["temperature"] = temperature.get();
   real_nodal_fields["temperature_rate"] = temperature_rate.get();
   real_nodal_fields["external_heat_rate"] = external_heat_rate.get();
   real_nodal_fields["internal_heat_rate"] = internal_heat_rate.get();
   real_nodal_fields["increment"] = increment.get();
 
   std::shared_ptr<dumpers::Field> field =
       mesh.createNodalField(real_nodal_fields[field_name], group_name);
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field> HeatTransferModel::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool /*padding_flag*/, UInt /*spatial_dimension*/,
     ElementKind element_kind) {
 
   std::shared_ptr<dumpers::Field> field;
 
   if (field_name == "partitions") {
     field = mesh.createElementalField<UInt, dumpers::ElementPartitionField>(
         mesh.getConnectivities(), group_name, this->spatial_dimension,
         element_kind);
   } else if (field_name == "temperature_gradient") {
     ElementTypeMap<UInt> nb_data_per_elem =
         this->mesh.getNbDataPerElem(temperature_gradient);
 
     field = mesh.createElementalField<Real, dumpers::InternalMaterialField>(
         temperature_gradient, group_name, this->spatial_dimension, element_kind,
         nb_data_per_elem);
   } else if (field_name == "conductivity") {
     ElementTypeMap<UInt> nb_data_per_elem =
         this->mesh.getNbDataPerElem(conductivity_on_qpoints);
 
     field = mesh.createElementalField<Real, dumpers::InternalMaterialField>(
         conductivity_on_qpoints, group_name, this->spatial_dimension,
         element_kind, nb_data_per_elem);
   }
 
   return field;
 }
 
-/* -------------------------------------------------------------------------- */
-#else
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field> HeatTransferModel::createElementalField(
-    const std::string & /* field_name*/, const std::string & /*group_name*/,
-    bool /*padding_flag*/, ElementKind /*element_kind*/) {
-  return nullptr;
-}
-
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field>
-HeatTransferModel::createNodalFieldBool(const std::string & /*field_name*/,
-                                        const std::string & /*group_name*/,
-                                        bool /*padding_flag*/) {
-  return nullptr;
-}
-
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field>
-HeatTransferModel::createNodalFieldReal(const std::string & /*field_name*/,
-                                        const std::string & /*group_name*/,
-                                        bool /*padding_flag*/) {
-  return nullptr;
-}
-#endif
-
 /* -------------------------------------------------------------------------- */
 inline UInt HeatTransferModel::getNbData(const Array<UInt> & indexes,
                                          const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes = indexes.size();
 
   switch (tag) {
   case SynchronizationTag::_htm_temperature: {
     size += nb_nodes * sizeof(Real);
     break;
   }
   default: {
     AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::packData(CommunicationBuffer & buffer,
                                         const Array<UInt> & indexes,
                                         const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   for (auto index : indexes) {
     switch (tag) {
     case SynchronizationTag::_htm_temperature: {
       buffer << (*temperature)(index);
       break;
     }
     default: {
       AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
     }
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::unpackData(CommunicationBuffer & buffer,
                                           const Array<UInt> & indexes,
                                           const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   for (auto index : indexes) {
     switch (tag) {
     case SynchronizationTag::_htm_temperature: {
       buffer >> (*temperature)(index);
       break;
     }
     default: {
       AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
     }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 inline UInt HeatTransferModel::getNbData(const Array<Element> & elements,
                                          const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   UInt size = 0;
   UInt nb_nodes_per_element = 0;
   Array<Element>::const_iterator<Element> it = elements.begin();
   Array<Element>::const_iterator<Element> end = elements.end();
   for (; it != end; ++it) {
     const Element & el = *it;
     nb_nodes_per_element += Mesh::getNbNodesPerElement(el.type);
   }
 
   switch (tag) {
   case SynchronizationTag::_htm_temperature: {
     size += nb_nodes_per_element * sizeof(Real); // temperature
     break;
   }
   case SynchronizationTag::_htm_gradient_temperature: {
     // temperature gradient
     size += getNbIntegrationPoints(elements) * spatial_dimension * sizeof(Real);
     size += nb_nodes_per_element * sizeof(Real); // nodal temperatures
     break;
   }
   default: {
     AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::packData(CommunicationBuffer & buffer,
                                         const Array<Element> & elements,
                                         const SynchronizationTag & tag) const {
   switch (tag) {
   case SynchronizationTag::_htm_temperature: {
     packNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   case SynchronizationTag::_htm_gradient_temperature: {
     packElementalDataHelper(temperature_gradient, buffer, elements, true,
                             getFEEngine());
     packNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   default: {
     AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 inline void HeatTransferModel::unpackData(CommunicationBuffer & buffer,
                                           const Array<Element> & elements,
                                           const SynchronizationTag & tag) {
   switch (tag) {
   case SynchronizationTag::_htm_temperature: {
     unpackNodalDataHelper(*temperature, buffer, elements, mesh);
     break;
   }
   case SynchronizationTag::_htm_gradient_temperature: {
     unpackElementalDataHelper(temperature_gradient, buffer, elements, true,
                               getFEEngine());
     unpackNodalDataHelper(*temperature, buffer, elements, mesh);
 
     break;
   }
   default: {
     AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 } // namespace akantu
diff --git a/src/model/model.cc b/src/model/model.cc
index e90d3cf35..71f166251 100644
--- a/src/model/model.cc
+++ b/src/model/model.cc
@@ -1,367 +1,362 @@
 /**
  * @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: Fri Apr 09 2021
  *
  * @brief  implementation of model common parts
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "model.hh"
 #include "communicator.hh"
 #include "data_accessor.hh"
 #include "element_group.hh"
 #include "element_synchronizer.hh"
 #include "synchronizer_registry.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 Model::Model(Mesh & mesh, const ModelType & type,
              std::shared_ptr<DOFManager> dof_manager, UInt dim, const ID & id)
     : ModelSolver(mesh, type, id, std::move(dof_manager)), mesh(mesh),
       spatial_dimension(dim == _all_dimensions ? mesh.getSpatialDimension()
                                                : dim),
       parser(getStaticParser()) {
   this->mesh.registerEventHandler(*this, _ehp_model);
 }
 
 /* -------------------------------------------------------------------------- */
 Model::Model(Mesh & mesh, const ModelType & type, UInt dim, const ID & id)
     : ModelSolver(mesh, type, id), mesh(mesh),
       spatial_dimension(dim == _all_dimensions ? mesh.getSpatialDimension()
                                                : dim),
       parser(getStaticParser()) {
   this->mesh.registerEventHandler(*this, _ehp_model);
 }
 
 /* -------------------------------------------------------------------------- */
 Model::~Model() = default;
 
 /* -------------------------------------------------------------------------- */
 void Model::initFullImpl(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
   method = options.analysis_method;
   if (!this->hasDefaultSolver()) {
     this->initNewSolver(this->method);
   }
 
   initModel();
 
   initFEEngineBoundary();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::initNewSolver(const AnalysisMethod & method) {
   ID solver_name;
   TimeStepSolverType tss_type;
   std::tie(solver_name, tss_type) = this->getDefaultSolverID(method);
 
   if (not this->hasSolver(solver_name)) {
     ModelSolverOptions options = this->getDefaultSolverOptions(tss_type);
     this->getNewSolver(solver_name, tss_type, options.non_linear_solver_type);
 
     for (auto && is_type : options.integration_scheme_type) {
       if (!this->hasIntegrationScheme(solver_name, is_type.first)) {
         this->setIntegrationScheme(solver_name, is_type.first, is_type.second,
                                    options.solution_type[is_type.first]);
       }
     }
   }
 
   this->method = method;
   this->setDefaultSolver(solver_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::initFEEngineBoundary() {
   try {
     FEEngine & fem_boundary = getFEEngineBoundary();
     fem_boundary.initShapeFunctions(_not_ghost);
     fem_boundary.initShapeFunctions(_ghost);
 
     fem_boundary.computeNormalsOnIntegrationPoints(_not_ghost);
     fem_boundary.computeNormalsOnIntegrationPoints(_ghost);
   } catch (debug::Exception & /*e*/) {
   }
 }
 
 /* -------------------------------------------------------------------------- */
 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() {
   for (auto & group : mesh.iterateElementGroups()) {
     group.dump();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setGroupDirectory(const std::string & directory) {
   for (auto & group : mesh.iterateElementGroups()) {
     group.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,
                                       std::shared_ptr<dumpers::Field> field,
                                       DumperIOHelper & dumper) {
-#ifdef AKANTU_USE_IOHELPER
   dumper.registerField(field_id, std::move(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",
                                   dumper_default_element_kind, 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, dumper_default_element_kind,
                                   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",
                                   dumper_default_element_kind, true);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldVector(const std::string & field_id,
                                     const std::string & group_name) {
   ElementGroup & group = mesh.getElementGroup(group_name);
   this->addDumpGroupFieldVectorToDumper(group.getDefaultDumperName(), field_id,
                                         group_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldVectorToDumper(const std::string & dumper_name,
                                             const std::string & field_id,
                                             const std::string & group_name) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, group_name,
                                   dumper_default_element_kind, true);
 }
 /* -------------------------------------------------------------------------- */
 
 void Model::addDumpFieldTensorToDumper(const std::string & dumper_name,
                                        const std::string & field_id) {
   this->addDumpGroupFieldToDumper(dumper_name, field_id, "all",
                                   dumper_default_element_kind, true);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::addDumpGroupFieldToDumper(const std::string & dumper_name,
                                       const std::string & field_id,
                                       const std::string & group_name,
                                       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,
                                       ElementKind element_kind,
                                       bool padding_flag) {
-#ifdef AKANTU_USE_IOHELPER
   std::shared_ptr<dumpers::Field> field;
 
   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);
   }
 
 #ifndef AKANTU_NDEBUG
   if (!field) {
     AKANTU_DEBUG_WARNING("No field could be found based on name: " << field_id);
   }
 #endif
   if (field) {
     DumperIOHelper & dumper = mesh.getGroupDumper(dumper_name, group_name);
     this->addDumpGroupFieldToDumper(field_id, field, dumper);
   }
-
-#endif
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dump(const std::string & dumper_name) { mesh.dump(dumper_name); }
 
 /* -------------------------------------------------------------------------- */
 void Model::dump(const std::string & dumper_name, UInt step) {
   mesh.dump(dumper_name, step);
 }
 
 /* ------------------------------------------------------------------------- */
 void Model::dump(const std::string & dumper_name, Real time, UInt step) {
   mesh.dump(dumper_name, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dump() {
   auto default_dumper = mesh.getDefaultDumperName();
   this->dump(default_dumper);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dump(UInt step) {
   auto default_dumper = mesh.getDefaultDumperName();
   this->dump(default_dumper, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::dump(Real time, UInt step) {
   auto default_dumper = mesh.getDefaultDumperName();
   this->dump(default_dumper, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setDirectory(const std::string & directory) {
   mesh.setDirectory(directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setDirectoryToDumper(const std::string & dumper_name,
                                  const std::string & directory) {
   mesh.setDirectoryToDumper(dumper_name, directory);
 }
 
 /* -------------------------------------------------------------------------- */
 void Model::setTextModeToDumper() { mesh.setTextModeToDumper(); }
 
 /* -------------------------------------------------------------------------- */
 
 } // namespace akantu
diff --git a/src/model/model_couplers/coupler_solid_cohesive_contact.cc b/src/model/model_couplers/coupler_solid_cohesive_contact.cc
index aca99f73f..68d0f9f81 100644
--- a/src/model/model_couplers/coupler_solid_cohesive_contact.cc
+++ b/src/model/model_couplers/coupler_solid_cohesive_contact.cc
@@ -1,78 +1,76 @@
 /**
  * @file   coupler_solid_cohesive_contact.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jan 21 2019
  * @date last modification: Wed Jun 23 2021
  *
  * @brief  class for coupling of solid mechanics cohesive and conatct mechanics
  * model
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "coupler_solid_cohesive_contact.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template <>
 CouplerSolidContactTemplate<SolidMechanicsModelCohesive>::
     CouplerSolidContactTemplate(Mesh & mesh, UInt dim, const ID & id,
                                 std::shared_ptr<DOFManager> dof_manager,
                                 ModelType model_type)
     : Model(mesh, model_type, dof_manager, dim, id) {
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("coupler_solid_cohesive_contact",
                                             id, true);
   this->mesh.addDumpMeshToDumper("coupler_solid_cohesive_contact", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_cohesive);
-#endif
 
   this->registerDataAccessor(*this);
 
   solid = std::make_unique<SolidMechanicsModelCohesive>(
       mesh, Model::spatial_dimension, "solid_mechanics_model_cohesive",
       this->dof_manager);
   contact = std::make_unique<ContactMechanicsModel>(mesh.getMeshFacets(),
                                                     Model::spatial_dimension,
                                                     "contact_mechanics_model");
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void CouplerSolidContactTemplate<SolidMechanicsModelCohesive>::initFullImpl(
     const ModelOptions & options) {
   Model::initFullImpl(options);
 
   const auto & cscc_options =
       aka::as_type<CouplerSolidCohesiveContactOptions>(options);
 
   solid->initFull(_analysis_method = cscc_options.analysis_method,
                   _is_extrinsic = cscc_options.is_extrinsic);
   contact->initFull(_analysis_method = cscc_options.analysis_method);
 }
 
 } // namespace akantu
diff --git a/src/model/model_couplers/coupler_solid_contact.cc b/src/model/model_couplers/coupler_solid_contact.cc
index 8cc5a5c5b..5dbedb121 100644
--- a/src/model/model_couplers/coupler_solid_contact.cc
+++ b/src/model/model_couplers/coupler_solid_contact.cc
@@ -1,71 +1,69 @@
 /**
  * @file   coupler_solid_contact.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jan 21 2019
  * @date last modification: Wed Jun 23 2021
  *
  * @brief  class for coupling of solid mechanics and conatct mechanics
  * model
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "coupler_solid_contact.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 template <>
 CouplerSolidContactTemplate<SolidMechanicsModel>::CouplerSolidContactTemplate(
     Mesh & mesh, UInt dim, const ID & id,
     std::shared_ptr<DOFManager> dof_manager, ModelType model_type)
     : Model(mesh, model_type, dof_manager, dim, id) {
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("coupler_solid_contact", id, true);
   this->mesh.addDumpMeshToDumper("coupler_solid_contact", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_regular);
-#endif
   this->registerDataAccessor(*this);
 
   solid = std::make_unique<SolidMechanicsModel>(mesh, Model::spatial_dimension,
                                                 "solid_mechanics_model",
                                                 this->dof_manager);
   contact = std::make_unique<ContactMechanicsModel>(
       mesh, Model::spatial_dimension, "contact_mechanics_model",
       this->dof_manager);
 }
 
 /* -------------------------------------------------------------------------- */
 template <>
 void CouplerSolidContactTemplate<SolidMechanicsModel>::initFullImpl(
     const ModelOptions & options) {
   Model::initFullImpl(options);
 
   solid->initFull(_analysis_method = this->method);
   contact->initFull(_analysis_method = this->method);
 }
 
 } // namespace akantu
diff --git a/src/model/model_couplers/coupler_solid_contact.hh b/src/model/model_couplers/coupler_solid_contact.hh
index 2744a5562..d82ffbec3 100644
--- a/src/model/model_couplers/coupler_solid_contact.hh
+++ b/src/model/model_couplers/coupler_solid_contact.hh
@@ -1,282 +1,280 @@
 /**
  * @file   coupler_solid_contact.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Sat Jun 26 2021
  *
  * @brief  class for coupling of solid mechanics and conatct mechanics
  * model in explicit
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "contact_mechanics_model.hh"
 #include "solid_mechanics_model.hh"
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "solid_mechanics_model_cohesive.hh"
 #endif
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_COUPLER_SOLID_CONTACT_HH__
 #define __AKANTU_COUPLER_SOLID_CONTACT_HH__
 
 /* ------------------------------------------------------------------------ */
 /* Coupling : Solid Mechanics / Contact Mechanics                           */
 /* ------------------------------------------------------------------------ */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 class CouplerSolidContactTemplate : public Model,
                                     public DataAccessor<Element>,
                                     public DataAccessor<UInt> {
   static_assert(
       std::is_base_of<SolidMechanicsModel, SolidMechanicsModelType>::value,
       "SolidMechanicsModelType should be derived from SolidMechanicsModel");
   /* ------------------------------------------------------------------------ */
   /* Constructor/Destructor                                                   */
   /* ------------------------------------------------------------------------ */
 public:
   CouplerSolidContactTemplate(
       Mesh & mesh, UInt dim = _all_dimensions,
       const ID & id = "coupler_solid_contact",
       std::shared_ptr<DOFManager> dof_manager = nullptr,
       ModelType model_type = std::is_same<SolidMechanicsModelType,
                                           SolidMechanicsModelCohesive>::value
                                  ? ModelType::_coupler_solid_cohesive_contact
                                  : ModelType::_coupler_solid_contact);
 
   ~CouplerSolidContactTemplate() override;
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   /// initialize completely the model
   void initFullImpl(const ModelOptions & options) override;
 
   /// get some default values for derived classes
   std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) override;
 
   /* ------------------------------------------------------------------------ */
   /* Solver Interface                                                         */
   /* ------------------------------------------------------------------------ */
 public:
   /// assembles the contact stiffness matrix
   virtual void assembleStiffnessMatrix();
 
   /// assembles the contant internal forces
   virtual void assembleInternalForces();
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
   template <class Model_ = SolidMechanicsModelType,
             std::enable_if_t<std::is_same<
                 Model_, SolidMechanicsModelCohesive>::value> * = nullptr>
   UInt checkCohesiveStress() {
     return solid->checkCohesiveStress();
   }
 #endif
 
   template <typename FunctorType>
   inline void applyBC(const FunctorType & func) {
     solid->applyBC(func);
   }
 
   template <class FunctorType>
   inline void applyBC(const FunctorType & func,
                       const std::string & group_name) {
     solid->applyBC(func, group_name);
   }
 
   template <class FunctorType>
   inline void applyBC(const FunctorType & func,
                       const ElementGroup & element_group) {
     solid->applyBC(func, element_group);
   }
 
 protected:
   /// callback for the solver, this adds f_{ext} - f_{int} to the residual
   void assembleResidual() override;
 
   /// callback for the solver, this adds f_{ext} or  f_{int} to the residual
   void assembleResidual(const ID & residual_part) override;
   bool canSplitResidual() const override { return true; }
 
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID & matrix_id) const 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(bool converged = true) override;
 
   /// callback for the model to instantiate the matricess when needed
   void initSolver(TimeStepSolverType time_step_solver_type,
                   NonLinearSolverType non_linear_solver_type) override;
 
   /* ------------------------------------------------------------------------ */
   /* Mass matrix for solid mechanics model                                    */
   /* ------------------------------------------------------------------------ */
 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);
 
 protected:
   /* ------------------------------------------------------------------------ */
   TimeStepSolverType getDefaultSolverType() const override;
   /* ------------------------------------------------------------------------ */
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const override;
 
 public:
   bool isDefaultSolverExplicit() { return method == _explicit_lumped_mass; }
 
   /* ------------------------------------------------------------------------ */
 public:
   // DataAccessor<Element>
   UInt getNbData(const Array<Element> & /*elements*/,
                  const SynchronizationTag & /*tag*/) const override {
     return 0;
   }
   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 {}
 
   // DataAccessor<UInt> nodes
   UInt getNbData(const Array<UInt> & /*nodes*/,
                  const SynchronizationTag & /*tag*/) const override {
     return 0;
   }
   void packData(CommunicationBuffer & /*buffer*/, const Array<UInt> & /*nodes*/,
                 const SynchronizationTag & /*tag*/) const override {}
   void unpackData(CommunicationBuffer & /*buffer*/,
                   const Array<UInt> & /*nodes*/,
                   const SynchronizationTag & /*tag*/) override {}
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   /// get the solid mechanics model
 #if defined(AKANTU_COHESIVE_ELEMENT)
   template <class Model_ = SolidMechanicsModelType,
             std::enable_if_t<std::is_same<
                 Model_, SolidMechanicsModelCohesive>::value> * = nullptr>
   SolidMechanicsModelCohesive & getSolidMechanicsModelCohesive() {
     return *solid;
   }
 #endif
   template <class Model_ = SolidMechanicsModelType,
             std::enable_if_t<
                 std::is_same<Model_, SolidMechanicsModel>::value> * = nullptr>
   SolidMechanicsModelType & getSolidMechanicsModel() {
     return *solid;
   }
 
   /// get the contact mechanics model
   AKANTU_GET_MACRO(ContactMechanicsModel, *contact, ContactMechanicsModel &)
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
-#if defined(AKANTU_USE_IOHELPER)
   std::shared_ptr<dumpers::Field>
   createNodalFieldReal(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createNodalFieldUInt(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createNodalFieldBool(const std::string & field_name,
                        const std::string & group_name,
                        bool padding_flag) override;
 
   std::shared_ptr<dumpers::Field>
   createElementalField(const std::string & field_name,
                        const std::string & group_name, bool padding_flag,
                        UInt spatial_dimension, ElementKind kind) override;
-#endif
 
   void dump(const std::string & dumper_name) override;
   void dump(const std::string & dumper_name, UInt step) override;
   void dump(const std::string & dumper_name, Real time, UInt step) override;
 
   void dump() override;
 
   void dump(UInt step) override;
   void dump(Real time, UInt step) override;
 
   /* ------------------------------------------------------------------------ */
   /* Members                                                                  */
   /* ------------------------------------------------------------------------ */
 private:
   /// solid mechanics model
   std::unique_ptr<SolidMechanicsModelType> solid;
 
   /// contact mechanics model
   std::unique_ptr<ContactMechanicsModel> contact;
 
   UInt step;
 };
 
 using CouplerSolidContact = CouplerSolidContactTemplate<SolidMechanicsModel>;
 
 } // namespace akantu
 
 #include "coupler_solid_contact_tmpl.hh"
 
 #endif /* __COUPLER_SOLID_CONTACT_HH__  */
diff --git a/src/model/model_couplers/coupler_solid_contact_tmpl.hh b/src/model/model_couplers/coupler_solid_contact_tmpl.hh
index 496c37caf..5bfe1a59f 100644
--- a/src/model/model_couplers/coupler_solid_contact_tmpl.hh
+++ b/src/model/model_couplers/coupler_solid_contact_tmpl.hh
@@ -1,401 +1,396 @@
 /**
  * @file   coupler_solid_contact_tmpl.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Jan 21 2019
  * @date last modification: Wed Jun 23 2021
  *
  * @brief  class for coupling of solid mechanics and conatct mechanics
  * model
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "coupler_solid_contact.hh"
 #include "dumpable_inline_impl.hh"
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_iohelper_paraview.hh"
-#endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 CouplerSolidContactTemplate<
     SolidMechanicsModelType>::~CouplerSolidContactTemplate() = default;
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::initSolver(
     TimeStepSolverType time_step_solver_type,
     NonLinearSolverType non_linear_solver_type) {
   auto & solid_model_solver = aka::as_type<ModelSolver>(*solid);
   solid_model_solver.initSolver(time_step_solver_type, non_linear_solver_type);
 
   auto & contact_model_solver = aka::as_type<ModelSolver>(*contact);
   contact_model_solver.initSolver(time_step_solver_type,
                                   non_linear_solver_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 std::tuple<ID, TimeStepSolverType>
 CouplerSolidContactTemplate<SolidMechanicsModelType>::getDefaultSolverID(
     const AnalysisMethod & method) {
   return solid->getDefaultSolverID(method);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 TimeStepSolverType
 CouplerSolidContactTemplate<SolidMechanicsModelType>::getDefaultSolverType()
     const {
   return solid->getDefaultSolverType();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 ModelSolverOptions
 CouplerSolidContactTemplate<SolidMechanicsModelType>::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   return solid->getDefaultSolverOptions(type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::assembleResidual() {
   // computes the internal forces
   switch (method) {
   case _explicit_lumped_mass: {
     auto & current_positions = contact->getContactDetector().getPositions();
     current_positions.copy(solid->getCurrentPosition());
     contact->search();
     break;
   }
   default:
     break;
   }
 
   this->assembleInternalForces();
 
   auto & internal_force = solid->getInternalForce();
   auto & external_force = solid->getExternalForce();
 
   auto & contact_force = contact->getInternalForce();
 
   /* ------------------------------------------------------------------------ */
   this->getDOFManager().assembleToResidual("displacement", external_force, 1);
   this->getDOFManager().assembleToResidual("displacement", internal_force, 1);
   this->getDOFManager().assembleToResidual("displacement", contact_force, 1);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::assembleResidual(
     const ID & residual_part) {
   AKANTU_DEBUG_IN();
 
   // contact->assembleInternalForces();
 
   auto & internal_force = solid->getInternalForce();
   auto & external_force = solid->getExternalForce();
   auto & contact_force = contact->getInternalForce();
 
   if ("external" == residual_part) {
     this->getDOFManager().assembleToResidual("displacement", external_force, 1);
     this->getDOFManager().assembleToResidual("displacement", contact_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   if ("internal" == residual_part) {
     this->getDOFManager().assembleToResidual("displacement", internal_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   AKANTU_CUSTOM_EXCEPTION(
       debug::SolverCallbackResidualPartUnknown(residual_part));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::predictor() {
   auto & solid_model_solver = aka::as_type<ModelSolver>(*solid);
   solid_model_solver.predictor();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::corrector() {
   auto & solid_model_solver = aka::as_type<ModelSolver>(*solid);
   solid_model_solver.corrector();
 
   switch (method) {
   case _static:
   case _implicit_dynamic: {
     auto & current_positions = contact->getContactDetector().getPositions();
     current_positions.copy(solid->getCurrentPosition());
     contact->search();
     break;
   }
   default:
     break;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 MatrixType CouplerSolidContactTemplate<SolidMechanicsModelType>::getMatrixType(
     const ID & matrix_id) const {
   if (matrix_id == "K") {
     return _symmetric;
   }
   if (matrix_id == "M") {
     return _symmetric;
   }
   return _mt_not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::assembleMatrix(
     const ID & matrix_id) {
   if (matrix_id == "K") {
     this->assembleStiffnessMatrix();
   } else if (matrix_id == "M") {
     solid->assembleMass();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::assembleLumpedMatrix(
     const ID & matrix_id) {
   if (matrix_id == "M") {
     solid->assembleMassLumped();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::beforeSolveStep() {
   auto & solid_solver_callback = aka::as_type<SolverCallback>(*solid);
   solid_solver_callback.beforeSolveStep();
 
   auto & contact_solver_callback = aka::as_type<SolverCallback>(*contact);
   contact_solver_callback.beforeSolveStep();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::afterSolveStep(
     bool converged) {
   auto & solid_solver_callback = aka::as_type<SolverCallback>(*solid);
   solid_solver_callback.afterSolveStep(converged);
 
   auto & contact_solver_callback = aka::as_type<SolverCallback>(*contact);
   contact_solver_callback.afterSolveStep(converged);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<
     SolidMechanicsModelType>::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the internal forces");
 
   solid->assembleInternalForces();
   contact->assembleInternalForces();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<
     SolidMechanicsModelType>::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix");
 
   solid->assembleStiffnessMatrix(true);
 
   switch (method) {
   case _static:
   case _implicit_dynamic: {
     contact->assembleStiffnessMatrix();
     break;
   }
   default:
     break;
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<
     SolidMechanicsModelType>::assembleMassLumped() {
   solid->assembleMassLumped();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::assembleMass() {
   solid->assembleMass();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::assembleMassLumped(
     GhostType ghost_type) {
   solid->assembleMassLumped(ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::assembleMass(
     GhostType ghost_type) {
   solid->assembleMass(ghost_type);
 }
 
-/* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 std::shared_ptr<dumpers::Field>
 CouplerSolidContactTemplate<SolidMechanicsModelType>::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag, UInt spatial_dimension, ElementKind kind) {
 
   std::shared_ptr<dumpers::Field> field;
   field = contact->createElementalField(field_name, group_name, padding_flag,
                                         spatial_dimension, kind);
   if (not field) {
     field = solid->createElementalField(field_name, group_name, padding_flag,
                                         spatial_dimension, kind);
   }
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 std::shared_ptr<dumpers::Field>
 CouplerSolidContactTemplate<SolidMechanicsModelType>::createNodalFieldReal(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag) {
 
   std::shared_ptr<dumpers::Field> field;
   field = contact->createNodalFieldReal(field_name, group_name, padding_flag);
   if (not field) {
     field = solid->createNodalFieldReal(field_name, group_name, padding_flag);
   }
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 std::shared_ptr<dumpers::Field>
 CouplerSolidContactTemplate<SolidMechanicsModelType>::createNodalFieldUInt(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag) {
   std::shared_ptr<dumpers::Field> field;
   field = contact->createNodalFieldUInt(field_name, group_name, padding_flag);
   if (not field) {
     field = solid->createNodalFieldUInt(field_name, group_name, padding_flag);
   }
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 std::shared_ptr<dumpers::Field>
 CouplerSolidContactTemplate<SolidMechanicsModelType>::createNodalFieldBool(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag) {
   std::shared_ptr<dumpers::Field> field;
   field = contact->createNodalFieldBool(field_name, group_name, padding_flag);
   if (not field) {
     field = solid->createNodalFieldBool(field_name, group_name, padding_flag);
   }
   return field;
 }
 
-#endif
-
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::dump(
     const std::string & dumper_name) {
   solid->onDump();
   Model::dump(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::dump(
     const std::string & dumper_name, UInt step) {
   solid->onDump();
   Model::dump(dumper_name, step);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::dump(
     const std::string & dumper_name, Real time, UInt step) {
   solid->onDump();
   Model::dump(dumper_name, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::dump() {
   solid->onDump();
   Model::dump();
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::dump(UInt step) {
   solid->onDump();
   Model::dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class SolidMechanicsModelType>
 void CouplerSolidContactTemplate<SolidMechanicsModelType>::dump(Real time,
                                                                 UInt step) {
   solid->onDump();
   Model::dump(time, step);
 }
 
 } // namespace akantu
diff --git a/src/model/model_couplers/coupler_solid_phasefield.cc b/src/model/model_couplers/coupler_solid_phasefield.cc
index 2f3810470..7efe6a986 100644
--- a/src/model/model_couplers/coupler_solid_phasefield.cc
+++ b/src/model/model_couplers/coupler_solid_phasefield.cc
@@ -1,630 +1,599 @@
 /**
  * @file   coupler_solid_phasefield.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Mon Jun 24 2019
  * @date last modification: Fri Apr 02 2021
  *
  * @brief  class for coupling of solid mechancis and phase model
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "coupler_solid_phasefield.hh"
 #include "dumpable_inline_impl.hh"
 #include "element_synchronizer.hh"
 #include "integrator_gauss.hh"
 #include "shape_lagrange.hh"
-
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_iohelper_paraview.hh"
-#endif
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 CouplerSolidPhaseField::CouplerSolidPhaseField(Mesh & mesh, UInt dim,
                                                const ID & id,
                                                const ModelType model_type)
     : Model(mesh, model_type, dim, id) {
 
   AKANTU_DEBUG_IN();
 
   this->registerFEEngineObject<MyFEEngineType>("CouplerSolidPhaseField", mesh,
                                                Model::spatial_dimension);
 
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("coupler_solid_phasefield", id,
                                             true);
   this->mesh.addDumpMeshToDumper("coupler_solid_phasefield", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_regular);
-#endif
 
   this->registerDataAccessor(*this);
 
   solid = new SolidMechanicsModel(mesh, Model::spatial_dimension,
                                   "solid_mechanics_model");
   phase =
       new PhaseFieldModel(mesh, Model::spatial_dimension, "phase_field_model");
 
   if (this->mesh.isDistributed()) {
     auto & synchronizer = this->mesh.getElementSynchronizer();
     this->registerSynchronizer(synchronizer, SynchronizationTag::_csp_damage);
     this->registerSynchronizer(synchronizer, SynchronizationTag::_csp_strain);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 CouplerSolidPhaseField::~CouplerSolidPhaseField() = default;
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::initFullImpl(const ModelOptions & options) {
 
   Model::initFullImpl(options);
 
   this->initBC(*this, *displacement, *displacement_increment, *external_force);
   solid->initFull(_analysis_method = this->method);
   phase->initFull(_analysis_method = this->method);
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::initModel() {
 
   getFEEngine().initShapeFunctions(_not_ghost);
   getFEEngine().initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & CouplerSolidPhaseField::getFEEngineBoundary(const ID & name) {
   return dynamic_cast<FEEngine &>(
       getFEEngineClassBoundary<MyFEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::initSolver(
     TimeStepSolverType time_step_solver_type,
     NonLinearSolverType non_linear_solver_type) {
 
   auto & solid_model_solver = aka::as_type<ModelSolver>(*solid);
   solid_model_solver.initSolver(time_step_solver_type, non_linear_solver_type);
 
   auto & phase_model_solver = aka::as_type<ModelSolver>(*phase);
   phase_model_solver.initSolver(time_step_solver_type, non_linear_solver_type);
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 CouplerSolidPhaseField::getDefaultSolverID(const AnalysisMethod & method) {
 
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped",
                            TimeStepSolverType::_dynamic_lumped);
   }
   case _explicit_consistent_mass: {
     return std::make_tuple("explicit", TimeStepSolverType::_dynamic);
   }
   case _static: {
     return std::make_tuple("static", TimeStepSolverType::_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", TimeStepSolverType::_dynamic);
   }
   default:
     return std::make_tuple("unknown", TimeStepSolverType::_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverType CouplerSolidPhaseField::getDefaultSolverType() const {
   return TimeStepSolverType::_dynamic_lumped;
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions CouplerSolidPhaseField::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case TimeStepSolverType::_dynamic_lumped: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_dynamic: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_static: {
     options.non_linear_solver_type = NonLinearSolverType::_linear;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
     break;
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleResidual() {
 
   // computes the internal forces
   this->assembleInternalForces();
 
   auto & solid_internal_force = solid->getInternalForce();
   auto & solid_external_force = solid->getExternalForce();
 
   auto & phasefield_internal_force = phase->getInternalForce();
   auto & phasefield_external_force = phase->getExternalForce();
 
   /* ------------------------------------------------------------------------ */
   this->getDOFManager().assembleToResidual("displacement", solid_external_force,
                                            1);
   this->getDOFManager().assembleToResidual("displacement", solid_internal_force,
                                            1);
   this->getDOFManager().assembleToResidual("damage", phasefield_external_force,
                                            1);
   this->getDOFManager().assembleToResidual("damage", phasefield_internal_force,
                                            1);
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleResidual(const ID & residual_part) {
   AKANTU_DEBUG_IN();
 
   auto & solid_internal_force = solid->getInternalForce();
   auto & solid_external_force = solid->getExternalForce();
 
   auto & phasefield_internal_force = phase->getInternalForce();
   auto & phasefield_external_force = phase->getExternalForce();
 
   if ("external" == residual_part) {
     this->getDOFManager().assembleToResidual("displacement",
                                              solid_external_force, 1);
     this->getDOFManager().assembleToResidual("displacement",
                                              solid_internal_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   if ("internal" == residual_part) {
     this->getDOFManager().assembleToResidual("damage",
                                              phasefield_external_force, 1);
     this->getDOFManager().assembleToResidual("damage",
                                              phasefield_internal_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   AKANTU_CUSTOM_EXCEPTION(
       debug::SolverCallbackResidualPartUnknown(residual_part));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::predictor() {
 
   auto & solid_model_solver = aka::as_type<ModelSolver>(*solid);
   solid_model_solver.predictor();
 
   auto & phase_model_solver = aka::as_type<ModelSolver>(*phase);
   phase_model_solver.predictor();
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::corrector() {
 
   auto & solid_model_solver = aka::as_type<ModelSolver>(*solid);
   solid_model_solver.corrector();
 
   auto & phase_model_solver = aka::as_type<ModelSolver>(*phase);
   phase_model_solver.corrector();
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType CouplerSolidPhaseField::getMatrixType(const ID & matrix_id) const {
 
   if (matrix_id == "K") {
     return _symmetric;
   }
   if (matrix_id == "M") {
     return _symmetric;
   }
   return _mt_not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleMatrix(const ID & matrix_id) {
 
   if (matrix_id == "K") {
     this->assembleStiffnessMatrix();
   } else if (matrix_id == "M") {
     solid->assembleMass();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleLumpedMatrix(const ID & matrix_id) {
   if (matrix_id == "M") {
     solid->assembleMassLumped();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::beforeSolveStep() {
   auto & solid_solver_callback = aka::as_type<SolverCallback>(*solid);
   solid_solver_callback.beforeSolveStep();
 
   auto & phase_solver_callback = aka::as_type<SolverCallback>(*phase);
   phase_solver_callback.beforeSolveStep();
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::afterSolveStep(bool converged) {
   auto & solid_solver_callback = aka::as_type<SolverCallback>(*solid);
   solid_solver_callback.afterSolveStep(converged);
 
   auto & phase_solver_callback = aka::as_type<SolverCallback>(*phase);
   phase_solver_callback.afterSolveStep(converged);
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the internal forces");
 
   solid->assembleInternalForces();
   phase->assembleInternalForces();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix");
 
   solid->assembleStiffnessMatrix();
   phase->assembleStiffnessMatrix();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleMassLumped() {
   solid->assembleMassLumped();
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleMass() { solid->assembleMass(); }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleMassLumped(GhostType ghost_type) {
   solid->assembleMassLumped(ghost_type);
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::assembleMass(GhostType ghost_type) {
   solid->assembleMass(ghost_type);
 }
 
 /* ------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::computeDamageOnQuadPoints(
     const GhostType & ghost_type) {
 
   AKANTU_DEBUG_IN();
 
   auto & fem = phase->getFEEngine();
   auto & mesh = phase->getMesh();
 
   auto nb_materials = solid->getNbMaterials();
   auto nb_phasefields = phase->getNbPhaseFields();
 
   AKANTU_DEBUG_ASSERT(
       nb_phasefields == nb_materials,
       "The number of phasefields and materials should be equal");
 
   for (auto index : arange(nb_materials)) {
     auto & material = solid->getMaterial(index);
 
     for (auto index2 : arange(nb_phasefields)) {
       auto & phasefield = phase->getPhaseField(index2);
 
       if (phasefield.getName() == material.getName()) {
 
         switch (spatial_dimension) {
         case 1: {
           auto & mat = static_cast<MaterialPhaseField<1> &>(material);
           auto & damage = mat.getDamage();
           for (const auto & type :
                mesh.elementTypes(Model::spatial_dimension, ghost_type)) {
             auto & damage_on_qpoints_vect = damage(type, ghost_type);
             fem.interpolateOnIntegrationPoints(phase->getDamage(),
                                                damage_on_qpoints_vect, 1, type,
                                                ghost_type);
           }
           break;
         }
 
         case 2: {
           auto & mat = static_cast<MaterialPhaseField<2> &>(material);
           auto & damage = mat.getDamage();
 
           for (const auto & type :
                mesh.elementTypes(Model::spatial_dimension, ghost_type)) {
             auto & damage_on_qpoints_vect = damage(type, ghost_type);
             fem.interpolateOnIntegrationPoints(phase->getDamage(),
                                                damage_on_qpoints_vect, 1, type,
                                                ghost_type);
           }
           break;
         }
         default:
           auto & mat = static_cast<MaterialPhaseField<3> &>(material);
           auto & damage = mat.getDamage();
 
           for (const auto & type :
                mesh.elementTypes(Model::spatial_dimension, ghost_type)) {
             auto & damage_on_qpoints_vect = damage(type, ghost_type);
             fem.interpolateOnIntegrationPoints(phase->getDamage(),
                                                damage_on_qpoints_vect, 1, type,
                                                ghost_type);
           }
           break;
         }
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* ------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::computeStrainOnQuadPoints(
     const GhostType & ghost_type) {
   AKANTU_DEBUG_IN();
 
   auto & mesh = solid->getMesh();
 
   auto nb_materials = solid->getNbMaterials();
   auto nb_phasefields = phase->getNbPhaseFields();
 
   AKANTU_DEBUG_ASSERT(
       nb_phasefields == nb_materials,
       "The number of phasefields and materials should be equal");
 
   for (auto index : arange(nb_materials)) {
     auto & material = solid->getMaterial(index);
 
     for (auto index2 : arange(nb_phasefields)) {
       auto & phasefield = phase->getPhaseField(index2);
 
       if (phasefield.getName() == material.getName()) {
 
         auto & strain_on_qpoints = phasefield.getStrain();
         const auto & gradu_on_qpoints = material.getGradU();
 
         for (const auto & type :
              mesh.elementTypes(spatial_dimension, ghost_type)) {
           auto & strain_on_qpoints_vect = strain_on_qpoints(type, ghost_type);
           const auto & gradu_on_qpoints_vect =
               gradu_on_qpoints(type, ghost_type);
           for (auto && values :
                zip(make_view(strain_on_qpoints_vect, spatial_dimension,
                              spatial_dimension),
                    make_view(gradu_on_qpoints_vect, spatial_dimension,
                              spatial_dimension))) {
             auto & strain = std::get<0>(values);
             const auto & grad_u = std::get<1>(values);
             gradUToEpsilon(grad_u, strain);
           }
         }
 
         break;
       }
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* ------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::solve(const ID & solid_solver_id,
                                    const ID & phase_solver_id) {
 
   solid->solveStep(solid_solver_id);
   this->computeStrainOnQuadPoints(_not_ghost);
 
   phase->solveStep(phase_solver_id);
   this->computeDamageOnQuadPoints(_not_ghost);
 
   solid->assembleInternalForces();
 }
 
 /* ------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::gradUToEpsilon(const Matrix<Real> & grad_u,
                                             Matrix<Real> & epsilon) {
   for (UInt i = 0; i < Model::spatial_dimension; ++i) {
     for (UInt j = 0; j < Model::spatial_dimension; ++j) {
       epsilon(i, j) = 0.5 * (grad_u(i, j) + grad_u(j, i));
     }
   }
 }
 
 /* ------------------------------------------------------------------------- */
 bool CouplerSolidPhaseField::checkConvergence(Array<Real> & u_new,
                                               Array<Real> & u_old,
                                               Array<Real> & d_new,
                                               Array<Real> & d_old) {
 
   const Array<bool> & blocked_dofs = solid->getBlockedDOFs();
   UInt nb_degree_of_freedom = u_new.size();
 
   auto u_n_it = u_new.begin();
   auto u_o_it = u_old.begin();
   auto bld_it = blocked_dofs.begin();
 
   Real norm = 0;
   for (UInt n = 0; n < nb_degree_of_freedom;
        ++n, ++u_n_it, ++u_o_it, ++bld_it) {
     if ((!*bld_it)) {
       norm += (*u_n_it - *u_o_it) * (*u_n_it - *u_o_it);
     }
   }
 
   norm = std::sqrt(norm);
 
   auto d_n_it = d_new.begin();
   auto d_o_it = d_old.begin();
   nb_degree_of_freedom = d_new.size();
 
   Real norm2 = 0;
   for (UInt i = 0; i < nb_degree_of_freedom; ++i) {
     norm2 += (*d_n_it - *d_o_it);
   }
 
   norm2 = std::sqrt(norm2);
 
   Real error = std::max(norm, norm2);
 
   Real tolerance = 1e-8;
   return error < tolerance;
 }
 
-/* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
-
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field> CouplerSolidPhaseField::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag, UInt spatial_dimension, ElementKind kind) {
 
   return solid->createElementalField(field_name, group_name, padding_flag,
                                      spatial_dimension, kind);
 
   std::shared_ptr<dumpers::Field> field;
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 CouplerSolidPhaseField::createNodalFieldReal(const std::string & field_name,
                                              const std::string & group_name,
                                              bool padding_flag) {
 
   return solid->createNodalFieldReal(field_name, group_name, padding_flag);
 
   std::shared_ptr<dumpers::Field> field;
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 CouplerSolidPhaseField::createNodalFieldBool(const std::string & field_name,
                                              const std::string & group_name,
                                              bool padding_flag) {
 
   return solid->createNodalFieldBool(field_name, group_name, padding_flag);
 
   std::shared_ptr<dumpers::Field> field;
   return field;
 }
 
-#else
-
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field> CouplerSolidPhaseField::createElementalField(
-    const std::string &, const std::string &, bool, UInt, ElementKind) {
-  return nullptr;
-}
-
-/* ----------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field>
-CouplerSolidPhaseField::createNodalFieldReal(const std::string &,
-                                             const std::string &, bool) {
-  return nullptr;
-}
-
-/*-------------------------------------------------------------------*/
-std::shared_ptr<dumpers::Field>
-CouplerSolidPhaseField::createNodalFieldBool(const std::string &,
-                                             const std::string &, bool) {
-  return nullptr;
-}
-
-#endif
-
 /* -----------------------------------------------------------------------*/
 void CouplerSolidPhaseField::dump(const std::string & dumper_name) {
   solid->onDump();
   mesh.dump(dumper_name);
 }
 
 /* ------------------------------------------------------------------------*/
 void CouplerSolidPhaseField::dump(const std::string & dumper_name, UInt step) {
   solid->onDump();
   mesh.dump(dumper_name, step);
 }
 
 /* ----------------------------------------------------------------------- */
 void CouplerSolidPhaseField::dump(const std::string & dumper_name, Real time,
                                   UInt step) {
   solid->onDump();
   mesh.dump(dumper_name, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::dump() {
   solid->onDump();
   mesh.dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::dump(UInt step) {
   solid->onDump();
   mesh.dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 void CouplerSolidPhaseField::dump(Real time, UInt step) {
   solid->onDump();
   mesh.dump(time, step);
 }
 
 } // namespace akantu
diff --git a/src/model/phase_field/phase_field_model.cc b/src/model/phase_field/phase_field_model.cc
index 84e0a8418..ae8ec98d6 100644
--- a/src/model/phase_field/phase_field_model.cc
+++ b/src/model/phase_field/phase_field_model.cc
@@ -1,635 +1,602 @@
 /**
  * @file   phase_field_model.cc
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  *
  * @date creation: Tue Sep 04 2018
  * @date last modification: Wed Jun 23 2021
  *
  * @brief  Implementation of PhaseFieldModel class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "phase_field_model.hh"
 #include "dumpable_inline_impl.hh"
 #include "element_synchronizer.hh"
 #include "fe_engine_template.hh"
 #include "generalized_trapezoidal.hh"
 #include "group_manager_inline_impl.hh"
 #include "integrator_gauss.hh"
 #include "mesh.hh"
 #include "parser.hh"
 #include "shape_lagrange.hh"
-
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_element_partition.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_internal_material_field.hh"
 #include "dumper_iohelper_paraview.hh"
-#endif
-
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 PhaseFieldModel::PhaseFieldModel(Mesh & mesh, UInt dim, const ID & id,
                                  ModelType model_type)
     : Model(mesh, model_type, dim, id),
       phasefield_index("phasefield index", id),
       phasefield_local_numbering("phasefield local numbering", id) {
 
   AKANTU_DEBUG_IN();
 
   this->registerFEEngineObject<FEEngineType>("PhaseFieldFEEngine", mesh,
                                              Model::spatial_dimension);
 
-#ifdef AKANTU_USE_IOHELPER
   this->mesh.registerDumper<DumperParaview>("phase_field", id, true);
   this->mesh.addDumpMesh(mesh, Model::spatial_dimension, _not_ghost,
                          _ek_regular);
-#endif // AKANTU_USE_IOHELPER
 
   phasefield_selector =
       std::make_shared<DefaultPhaseFieldSelector>(phasefield_index);
 
   this->initDOFManager();
 
   this->registerDataAccessor(*this);
 
   if (this->mesh.isDistributed()) {
     auto & synchronizer = this->mesh.getElementSynchronizer();
     this->registerSynchronizer(synchronizer, SynchronizationTag::_pfm_damage);
     this->registerSynchronizer(synchronizer, SynchronizationTag::_pfm_driving);
     this->registerSynchronizer(synchronizer, SynchronizationTag::_pfm_history);
     this->registerSynchronizer(synchronizer, SynchronizationTag::_pfm_energy);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 PhaseFieldModel::~PhaseFieldModel() = default;
 
 /* -------------------------------------------------------------------------- */
 MatrixType PhaseFieldModel::getMatrixType(const ID & matrix_id) const {
   if (matrix_id == "K") {
     return _symmetric;
   }
   return _mt_not_defined;
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::initModel() {
   auto & fem = this->getFEEngine();
   fem.initShapeFunctions(_not_ghost);
   fem.initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::initFullImpl(const ModelOptions & options) {
   phasefield_index.initialize(mesh, _element_kind = _ek_not_defined,
                               _default_value = UInt(-1),
                               _with_nb_element = true);
   phasefield_local_numbering.initialize(mesh, _element_kind = _ek_not_defined,
                                         _with_nb_element = true);
 
   Model::initFullImpl(options);
 
   // initialize the phasefields
   if (!this->parser.getLastParsedFile().empty()) {
     this->instantiatePhaseFields();
     this->initPhaseFields();
   }
 
   this->initBC(*this, *damage, *external_force);
 }
 
 /* -------------------------------------------------------------------------- */
 PhaseField &
 PhaseFieldModel::registerNewPhaseField(const ParserSection & section) {
   std::string phase_name;
   std::string phase_type = section.getName();
   std::string opt_param = section.getOption();
 
   try {
     std::string tmp = section.getParameter("name");
     phase_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_ERROR("A phasefield of type \'"
                  << phase_type
                  << "\' in the input file has been defined without a name!");
   }
   PhaseField & phase =
       this->registerNewPhaseField(phase_name, phase_type, opt_param);
 
   phase.parseSection(section);
 
   return phase;
 }
 
 /* -------------------------------------------------------------------------- */
 PhaseField & PhaseFieldModel::registerNewPhaseField(const ID & phase_name,
                                                     const ID & phase_type,
                                                     const ID & opt_param) {
   AKANTU_DEBUG_ASSERT(phasefields_names_to_id.find(phase_name) ==
                           phasefields_names_to_id.end(),
                       "A phasefield with this name '"
                           << phase_name << "' has already been registered. "
                           << "Please use unique names for phasefields");
 
   UInt phase_count = phasefields.size();
   phasefields_names_to_id[phase_name] = phase_count;
 
   std::stringstream sstr_phase;
   sstr_phase << this->id << ":" << phase_count << ":" << phase_type;
   ID mat_id = sstr_phase.str();
 
   std::unique_ptr<PhaseField> phase = PhaseFieldFactory::getInstance().allocate(
       phase_type, opt_param, *this, mat_id);
 
   phasefields.push_back(std::move(phase));
 
   return *(phasefields.back());
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::instantiatePhaseFields() {
 
   ParserSection model_section;
   bool is_empty;
   std::tie(model_section, is_empty) = this->getParserSection();
 
   if (not is_empty) {
     auto model_phasefields =
         model_section.getSubSections(ParserType::_phasefield);
     for (const auto & section : model_phasefields) {
       this->registerNewPhaseField(section);
     }
   }
 
   auto sub_sections = this->parser.getSubSections(ParserType::_phasefield);
   for (const auto & section : sub_sections) {
     this->registerNewPhaseField(section);
   }
 
   if (phasefields.empty()) {
     AKANTU_EXCEPTION("No phasefields where instantiated for the model"
                      << getID());
   }
   are_phasefields_instantiated = true;
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::initPhaseFields() {
   AKANTU_DEBUG_ASSERT(phasefields.size() != 0, "No phasefield to initialize !");
 
   if (!are_phasefields_instantiated) {
     instantiatePhaseFields();
   }
 
   this->assignPhaseFieldToElements();
 
   for (auto & phasefield : phasefields) {
     /// init internals properties
     phasefield->initPhaseField();
   }
 
   this->synchronize(SynchronizationTag::_smm_init_mat);
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::assignPhaseFieldToElements(
     const ElementTypeMapArray<UInt> * filter) {
 
   for_each_element(
       mesh,
       [&](auto && element) {
         UInt phase_index = (*phasefield_selector)(element);
         AKANTU_DEBUG_ASSERT(
             phase_index < phasefields.size(),
             "The phasefield selector returned an index that does not exists");
         phasefield_index(element) = phase_index;
       },
       _element_filter = filter, _ghost_type = _not_ghost);
 
   for_each_element(
       mesh,
       [&](auto && element) {
         auto phase_index = phasefield_index(element);
         auto index = phasefields[phase_index]->addElement(element);
         phasefield_local_numbering(element) = index;
       },
       _element_filter = filter, _ghost_type = _not_ghost);
 
   // synchronize the element phasefield arrays
   this->synchronize(SynchronizationTag::_material_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::assembleMatrix(const ID & matrix_id) {
 
   if (matrix_id == "K") {
     this->assembleStiffnessMatrix();
   } else {
     AKANTU_ERROR("Unknown Matrix ID for PhaseFieldModel : " << matrix_id);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::predictor() {
   // AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::corrector() {
   // AKANTU_TO_IMPLEMENT();
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::initSolver(TimeStepSolverType time_step_solver_type,
                                  NonLinearSolverType /*unused*/) {
   DOFManager & dof_manager = this->getDOFManager();
 
   this->allocNodalField(this->damage, 1, "damage");
   this->allocNodalField(this->external_force, 1, "external_force");
   this->allocNodalField(this->internal_force, 1, "internal_force");
   this->allocNodalField(this->blocked_dofs, 1, "blocked_dofs");
   this->allocNodalField(this->previous_damage, 1, "previous_damage");
 
   if (!dof_manager.hasDOFs("damage")) {
     dof_manager.registerDOFs("damage", *this->damage, _dst_nodal);
     dof_manager.registerBlockedDOFs("damage", *this->blocked_dofs);
     dof_manager.registerDOFsPrevious("damage", *this->previous_damage);
   }
 
   if (time_step_solver_type == TimeStepSolverType::_dynamic) {
     AKANTU_TO_IMPLEMENT();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & PhaseFieldModel::getFEEngineBoundary(const ID & name) {
   return dynamic_cast<FEEngine &>(getFEEngineClassBoundary<FEEngineType>(name));
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 PhaseFieldModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped",
                            TimeStepSolverType::_dynamic_lumped);
   }
   case _explicit_consistent_mass: {
     return std::make_tuple("explicit", TimeStepSolverType::_dynamic);
   }
   case _static: {
     return std::make_tuple("static", TimeStepSolverType::_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", TimeStepSolverType::_dynamic);
   }
   default:
     return std::make_tuple("unknown", TimeStepSolverType::_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions PhaseFieldModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case TimeStepSolverType::_dynamic_lumped: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["damage"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["damage"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_static: {
     options.non_linear_solver_type = NonLinearSolverType::_linear;
     options.integration_scheme_type["damage"] =
         IntegrationSchemeType::_pseudo_time;
     options.solution_type["damage"] = IntegrationScheme::_not_defined;
     break;
   }
   case TimeStepSolverType::_dynamic: {
     options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
     options.integration_scheme_type["damage"] =
         IntegrationSchemeType::_backward_euler;
     options.solution_type["damage"] = IntegrationScheme::_damage;
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::beforeSolveStep() {
   for (auto & phasefield : phasefields) {
     phasefield->beforeSolveStep();
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::afterSolveStep(bool converged) {
   if (not converged) {
     return;
   }
 
   for (auto && values : zip(*damage, *previous_damage)) {
     auto & dam = std::get<0>(values);
     auto & prev_dam = std::get<1>(values);
 
     dam -= prev_dam;
     prev_dam = dam;
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix");
 
   if (!this->getDOFManager().hasMatrix("K")) {
     this->getDOFManager().getNewMatrix("K", getMatrixType("K"));
   }
 
   this->getDOFManager().zeroMatrix("K");
 
   for (auto & phasefield : phasefields) {
     phasefield->assembleStiffnessMatrix(_not_ghost);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::assembleResidual() {
   this->assembleInternalForces();
 
   this->getDOFManager().assembleToResidual("damage", *this->external_force, 1);
   this->getDOFManager().assembleToResidual("damage", *this->internal_force, 1);
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::assembleInternalForces() {
   AKANTU_DEBUG_INFO("Assemble the internal forces");
 
   this->internal_force->zero();
 
   // communicate the driving forces
   AKANTU_DEBUG_INFO("Send data for residual assembly");
   this->asynchronousSynchronize(SynchronizationTag::_pfm_driving);
 
   // assemble the forces due to local driving forces
   AKANTU_DEBUG_INFO("Assemble residual for local elements");
   for (auto & phasefield : phasefields) {
     phasefield->assembleInternalForces(_not_ghost);
   }
 
   // finalize communications
   AKANTU_DEBUG_INFO("Wait distant driving forces");
   this->waitEndSynchronize(SynchronizationTag::_pfm_driving);
 
   // assemble the residual due to ghost elements
   AKANTU_DEBUG_INFO("Assemble residual for ghost elements");
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::assembleLumpedMatrix(const ID & /*matrix_id*/) {}
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::setTimeStep(Real time_step, const ID & solver_id) {
   Model::setTimeStep(time_step, solver_id);
 
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper("phase_field").setTimeStep(time_step);
-#endif
 }
 
 /* -------------------------------------------------------------------------- */
 UInt PhaseFieldModel::getNbData(const Array<Element> & elements,
                                 const SynchronizationTag & tag) const {
   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 SynchronizationTag::_pfm_damage: {
     size += nb_nodes_per_element * sizeof(Real); // damage
     break;
   }
   case SynchronizationTag::_pfm_driving: {
     size += getNbIntegrationPoints(elements) * sizeof(Real);
     break;
   }
   case SynchronizationTag::_pfm_history: {
     size += getNbIntegrationPoints(elements) * sizeof(Real);
     break;
   }
   case SynchronizationTag::_pfm_energy: {
     size += getNbIntegrationPoints(elements) * sizeof(Real);
     break;
   }
   default: {
     AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::packData(__attribute__((unused))
                                CommunicationBuffer & buffer,
                                __attribute__((unused))
                                const Array<Element> & elements,
                                __attribute__((unused))
                                const SynchronizationTag & tag) const {}
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::unpackData(__attribute__((unused))
                                  CommunicationBuffer & buffer,
                                  __attribute__((unused))
                                  const Array<Element> & elements,
                                  __attribute__((unused))
                                  const SynchronizationTag & tag) {}
 
 /* -------------------------------------------------------------------------- */
 UInt PhaseFieldModel::getNbData(const Array<UInt> & indexes,
                                 const SynchronizationTag & tag) const {
   UInt size = 0;
   UInt nb_nodes = indexes.size();
 
   switch (tag) {
   case SynchronizationTag::_pfm_damage: {
     size += nb_nodes * sizeof(Real);
     break;
   }
   default: {
     AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::packData(CommunicationBuffer & buffer,
                                const Array<UInt> & indexes,
                                const SynchronizationTag & tag) const {
   for (auto index : indexes) {
     switch (tag) {
     case SynchronizationTag::_pfm_damage: {
       buffer << (*damage)(index);
       break;
     }
     default: {
       AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
     }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::unpackData(CommunicationBuffer & buffer,
                                  const Array<UInt> & indexes,
                                  const SynchronizationTag & tag) {
   for (auto index : indexes) {
     switch (tag) {
     case SynchronizationTag::_pfm_damage: {
       buffer >> (*damage)(index);
       break;
     }
     default: {
       AKANTU_ERROR("Unknown ghost synchronization tag : " << tag);
     }
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
-
 std::shared_ptr<dumpers::Field>
 PhaseFieldModel::createNodalFieldBool(const std::string & field_name,
                                       const std::string & group_name,
                                       bool /*unused*/) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs.get();
 
   return mesh.createNodalField(uint_nodal_fields[field_name], group_name);
 
   std::shared_ptr<dumpers::Field> field;
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 PhaseFieldModel::createNodalFieldReal(const std::string & field_name,
                                       const std::string & group_name,
                                       bool /*unused*/) {
 
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["damage"] = damage.get();
   real_nodal_fields["external_force"] = external_force.get();
   real_nodal_fields["internal_force"] = internal_force.get();
 
   return mesh.createNodalField(real_nodal_fields[field_name], group_name);
 
   std::shared_ptr<dumpers::Field> field;
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field> PhaseFieldModel::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool /*unused*/, UInt /*unused*/, ElementKind element_kind) {
 
   if (field_name == "partitions") {
     return mesh.createElementalField<UInt, dumpers::ElementPartitionField>(
         mesh.getConnectivities(), group_name, this->spatial_dimension,
         element_kind);
   }
 
   std::shared_ptr<dumpers::Field> field;
   return field;
 }
 
-/* -------------------------------------------------------------------------- */
-#else
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field>
-PhaseFieldModel::createElementalField(const std::string &, const std::string &,
-                                      bool, const UInt &, ElementKind) {
-  return nullptr;
-}
-
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field>
-PhaseFieldModel::createNodalFieldReal(const std::string &, const std::string &,
-                                      bool) {
-  return nullptr;
-}
-
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field>
-PhaseFieldModel::createNodalFieldBool(const std::string &, const std::string &,
-                                      bool) {
-  return nullptr;
-}
-#endif
-
 /* -------------------------------------------------------------------------- */
 void PhaseFieldModel::printself(std::ostream & stream, int indent) const {
   std::string space(indent, AKANTU_INDENT);
 
   stream << space << "Phase Field 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;
   damage->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 << " + phasefield information [" << std::endl;
   stream << space << AKANTU_INDENT << "]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/material.hh b/src/model/solid_mechanics/material.hh
index ae028bb11..339932e55 100644
--- a/src/model/solid_mechanics/material.hh
+++ b/src/model/solid_mechanics/material.hh
@@ -1,713 +1,713 @@
 /**
  * @file   material.hh
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Enrico Milanese <enrico.milanese@epfl.ch>
  * @author Daniel Pino Muñoz <daniel.pinomunoz@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Fri Apr 09 2021
  *
  * @brief  Mother class for all materials
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_factory.hh"
 #include "aka_voigthelper.hh"
 #include "data_accessor.hh"
 #include "integration_point.hh"
 #include "parsable.hh"
 #include "parser.hh"
 /* -------------------------------------------------------------------------- */
 #include "internal_field.hh"
 #include "random_internal_field.hh"
 /* -------------------------------------------------------------------------- */
 #include "mesh_events.hh"
 #include "solid_mechanics_model_event_handler.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_MATERIAL_HH_
 #define AKANTU_MATERIAL_HH_
 
 /* -------------------------------------------------------------------------- */
 namespace akantu {
 class Model;
 class SolidMechanicsModel;
 class Material;
 } // namespace akantu
 
 namespace akantu {
 
 using MaterialFactory =
     Factory<Material, ID, UInt, const ID &, SolidMechanicsModel &, const ID &>;
 
 /**
  * Interface of all materials
  * Prerequisites for a new material
  * - inherit from this class
  * - implement the following methods:
  * \code
  *  virtual Real getStableTimeStep(Real h, const Element & element =
  * ElementNull);
  *
  *  virtual void computeStress(ElementType el_type,
  *                             GhostType ghost_type = _not_ghost);
  *
  *  virtual void computeTangentStiffness(ElementType el_type,
  *                                       Array<Real> & tangent_matrix,
  *                                       GhostType ghost_type = _not_ghost);
  * \endcode
  *
  */
 class Material : public DataAccessor<Element>,
                  public Parsable,
                  public MeshEventHandler,
                  protected SolidMechanicsModelEventHandler {
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   Material(const Material & mat) = delete;
   Material & operator=(const Material & mat) = delete;
 
   /// Initialize material with defaults
   Material(SolidMechanicsModel & model, const ID & id = "");
 
   /// Initialize material with custom mesh & fe_engine
   Material(SolidMechanicsModel & model, UInt dim, const Mesh & mesh,
            FEEngine & fe_engine, const ID & id = "");
 
   /// Destructor
   ~Material() override;
 
 protected:
   void initialize();
 
   /* ------------------------------------------------------------------------ */
   /* Function that materials can/should reimplement                           */
   /* ------------------------------------------------------------------------ */
 protected:
   /// constitutive law
   virtual void computeStress(ElementType /* el_type */,
                              GhostType /* ghost_type */ = _not_ghost) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the tangent stiffness matrix
   virtual void computeTangentModuli(ElementType /*el_type*/,
                                     Array<Real> & /*tangent_matrix*/,
                                     GhostType /*ghost_type*/ = _not_ghost) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the potential energy
   virtual void computePotentialEnergy(ElementType el_type);
 
   /// compute the potential energy for an element
   virtual void
   computePotentialEnergyByElement(ElementType /*type*/, UInt /*index*/,
                                   Vector<Real> & /*epot_on_quad_points*/) {
     AKANTU_TO_IMPLEMENT();
   }
 
   virtual void updateEnergies(ElementType /*el_type*/) {}
 
   virtual void updateEnergiesAfterDamage(ElementType /*el_type*/) {}
 
   /// set the material to steady state (to be implemented for materials that
   /// need it)
   virtual void setToSteadyState(ElementType /*el_type*/,
                                 GhostType /*ghost_type*/ = _not_ghost) {}
 
   /// function called to update the internal parameters when the modifiable
   /// parameters are modified
   virtual void updateInternalParameters() {}
 
 public:
   /// extrapolate internal values
   virtual void extrapolateInternal(const ID & id, const Element & element,
                                    const Matrix<Real> & points,
                                    Matrix<Real> & extrapolated);
 
   /// compute the p-wave speed in the material
   virtual Real getPushWaveSpeed(const Element & /*element*/) const {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// compute the s-wave speed in the material
   virtual Real getShearWaveSpeed(const Element & /*element*/) const {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// get a material celerity to compute the stable time step (default: is the
   /// push wave speed)
   virtual Real getCelerity(const Element & element) const {
     return getPushWaveSpeed(element);
   }
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 public:
   template <typename T> void registerInternal(InternalField<T> & /*vect*/) {
     AKANTU_TO_IMPLEMENT();
   }
 
   template <typename T> void unregisterInternal(InternalField<T> & /*vect*/) {
     AKANTU_TO_IMPLEMENT();
   }
 
   /// initialize the material computed parameter
   virtual void initMaterial();
 
   /// compute the residual for this material
   //  virtual void updateResidual(GhostType ghost_type = _not_ghost);
 
   /// assemble the residual for this material
   virtual void assembleInternalForces(GhostType ghost_type);
 
   /// save the stress in the previous_stress if needed
   virtual void savePreviousState();
 
   /// restore the stress from previous_stress if needed
   virtual void restorePreviousState();
 
   /// compute the stresses for this material
   virtual void computeAllStresses(GhostType ghost_type = _not_ghost);
   // virtual void
   // computeAllStressesFromTangentModuli(GhostType ghost_type = _not_ghost);
   virtual void computeAllCauchyStresses(GhostType ghost_type = _not_ghost);
 
   /// set material to steady state
   void setToSteadyState(GhostType ghost_type = _not_ghost);
 
   /// compute the stiffness matrix
   virtual void assembleStiffnessMatrix(GhostType ghost_type);
 
   /// add an element to the local mesh filter
   inline UInt addElement(ElementType type, UInt element, GhostType ghost_type);
   inline UInt addElement(const Element & element);
 
   /// add many elements at once
   void addElements(const Array<Element> & elements_to_add);
 
   /// remove many element at once
   void removeElements(const Array<Element> & elements_to_remove);
 
   /// function to print the contain of the class
   void printself(std::ostream & stream, int indent = 0) const override;
 
   /**
    * interpolate stress on given positions for each element by means
    * of a geometrical interpolation on quadrature points
    */
   void interpolateStress(ElementTypeMapArray<Real> & result,
                          GhostType ghost_type = _not_ghost);
 
   /**
    * interpolate stress on given positions for each element by means
    * of a geometrical interpolation on quadrature points and store the
    * results per facet
    */
   void interpolateStressOnFacets(ElementTypeMapArray<Real> & result,
                                  ElementTypeMapArray<Real> & by_elem_result,
                                  GhostType ghost_type = _not_ghost);
 
   /**
    * function to initialize the elemental field interpolation
    * function by inverting the quadrature points' coordinates
    */
   void initElementalFieldInterpolation(
       const ElementTypeMapArray<Real> & interpolation_points_coordinates);
 
   /* ------------------------------------------------------------------------ */
   /* Common part                                                              */
   /* ------------------------------------------------------------------------ */
 protected:
   /* ------------------------------------------------------------------------ */
   static inline UInt getTangentStiffnessVoigtSize(UInt dim);
 
   /// compute the potential energy by element
   void computePotentialEnergyByElements();
 
   /// resize the intenals arrays
   virtual void resizeInternals();
 
   /* ------------------------------------------------------------------------ */
   /* Finite deformation functions                                             */
   /* This functions area implementing what is described in the paper of Bathe */
   /* et al, in IJNME, Finite Element Formulations For Large Deformation       */
   /* Dynamic Analysis, Vol 9, 353-386, 1975                                   */
   /* ------------------------------------------------------------------------ */
 protected:
   /// assemble the residual
   template <UInt dim> void assembleInternalForces(GhostType ghost_type);
 
   template <UInt dim>
   void computeAllStressesFromTangentModuli(ElementType type,
                                            GhostType ghost_type);
 
   template <UInt dim>
   void assembleStiffnessMatrix(ElementType type, GhostType ghost_type);
 
   /// assembling in finite deformation
   template <UInt dim>
   void assembleStiffnessMatrixNL(ElementType type, GhostType ghost_type);
 
   template <UInt dim>
   void assembleStiffnessMatrixL2(ElementType type, GhostType ghost_type);
 
   /* ------------------------------------------------------------------------ */
   /* Conversion functions                                                     */
   /* ------------------------------------------------------------------------ */
 public:
   /// Size of the Stress matrix for the case of finite deformation see: Bathe et
   /// al, IJNME, Vol 9, 353-386, 1975
   static inline UInt getCauchyStressMatrixSize(UInt dim);
 
   /// Sets the stress matrix according to Bathe et al, IJNME, Vol 9, 353-386,
   /// 1975
   template <UInt dim>
   static inline void setCauchyStressMatrix(const Matrix<Real> & S_t,
                                            Matrix<Real> & sigma);
 
   /// write the stress tensor in the Voigt notation.
   template <UInt dim>
   static inline decltype(auto) stressToVoigt(const Matrix<Real> & stress) {
     return VoigtHelper<dim>::matrixToVoigt(stress);
   }
 
   /// write the strain tensor in the Voigt notation.
   template <UInt dim>
   static inline decltype(auto) strainToVoigt(const Matrix<Real> & strain) {
     return VoigtHelper<dim>::matrixToVoigtWithFactors(strain);
   }
 
   /// write a voigt vector to stress
   template <UInt dim>
   static inline void voigtToStress(const Vector<Real> & voigt,
                                    Matrix<Real> & stress) {
     VoigtHelper<dim>::voigtToMatrix(voigt, stress);
   }
 
   /// Computation of Cauchy stress tensor in the case of finite deformation from
   /// the 2nd Piola-Kirchhoff for a given element type
   template <UInt dim>
   void StoCauchy(ElementType el_type, GhostType ghost_type = _not_ghost);
 
   /// Computation the Cauchy stress the 2nd Piola-Kirchhoff and the deformation
   /// gradient
   template <UInt dim>
   inline void StoCauchy(const Matrix<Real> & F, const Matrix<Real> & S,
                         Matrix<Real> & sigma, const Real & C33 = 1.0) const;
 
   template <UInt dim>
   static inline void gradUToF(const Matrix<Real> & grad_u, Matrix<Real> & F);
 
   template <UInt dim>
   static inline decltype(auto) gradUToF(const Matrix<Real> & grad_u);
 
   static inline void rightCauchy(const Matrix<Real> & F, Matrix<Real> & C);
   static inline void leftCauchy(const Matrix<Real> & F, Matrix<Real> & B);
 
   template <UInt dim>
   static inline void gradUToEpsilon(const Matrix<Real> & grad_u,
                                     Matrix<Real> & epsilon);
   template <UInt dim>
   static inline decltype(auto) gradUToEpsilon(const Matrix<Real> & grad_u);
 
   template <UInt dim>
   static inline void gradUToE(const Matrix<Real> & grad_u,
                               Matrix<Real> & epsilon);
 
   template <UInt dim>
   static inline decltype(auto) gradUToE(const Matrix<Real> & grad_u);
 
   static inline Real stressToVonMises(const Matrix<Real> & stress);
 
 protected:
   /// converts global element to local element
   inline Element convertToLocalElement(const Element & global_element) const;
   /// converts local element to global element
   inline Element convertToGlobalElement(const Element & local_element) const;
 
   /// converts global quadrature point to local quadrature point
   inline IntegrationPoint
   convertToLocalPoint(const IntegrationPoint & global_point) const;
   /// converts local quadrature point to global quadrature point
   inline IntegrationPoint
   convertToGlobalPoint(const IntegrationPoint & local_point) const;
 
   /* ------------------------------------------------------------------------ */
   /* DataAccessor inherited members                                           */
   /* ------------------------------------------------------------------------ */
 public:
   inline UInt getNbData(const Array<Element> & elements,
                         const SynchronizationTag & tag) const override;
 
   inline void packData(CommunicationBuffer & buffer,
                        const Array<Element> & elements,
                        const SynchronizationTag & tag) const override;
 
   inline void unpackData(CommunicationBuffer & buffer,
                          const Array<Element> & elements,
                          const SynchronizationTag & tag) override;
 
   template <typename T>
   inline void packElementDataHelper(const ElementTypeMapArray<T> & data_to_pack,
                                     CommunicationBuffer & buffer,
                                     const Array<Element> & elements,
                                     const ID & fem_id = ID()) const;
 
   template <typename T>
   inline void unpackElementDataHelper(ElementTypeMapArray<T> & data_to_unpack,
                                       CommunicationBuffer & buffer,
                                       const Array<Element> & elements,
                                       const ID & fem_id = ID());
 
   /* ------------------------------------------------------------------------ */
   /* MeshEventHandler inherited members                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /* ------------------------------------------------------------------------ */
   void onNodesAdded(const Array<UInt> & /*unused*/,
                     const NewNodesEvent & /*unused*/) override{};
   void onNodesRemoved(const Array<UInt> & /*unused*/,
                       const Array<UInt> & /*unused*/,
                       const RemovedNodesEvent & /*unused*/) override{};
   void onElementsAdded(const Array<Element> & element_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> & /*unused*/,
                          const Array<Element> & /*unused*/,
                          const ElementTypeMapArray<UInt> & /*unused*/,
                          const ChangedElementsEvent & /*unused*/) override{};
 
   /* ------------------------------------------------------------------------ */
   /* SolidMechanicsModelEventHandler inherited members                        */
   /* ------------------------------------------------------------------------ */
 public:
   virtual void beforeSolveStep();
   virtual void afterSolveStep(bool converged = true);
 
   void onDamageIteration() override;
   void onDamageUpdate() override;
   void onDump() override;
 
   /* ------------------------------------------------------------------------ */
   /* Accessors                                                                */
   /* ------------------------------------------------------------------------ */
 public:
   AKANTU_GET_MACRO(Name, name, const std::string &);
 
   AKANTU_GET_MACRO(Model, model, const SolidMechanicsModel &)
 
   AKANTU_GET_MACRO(ID, id, const ID &);
   AKANTU_GET_MACRO(Rho, rho, Real);
   AKANTU_SET_MACRO(Rho, rho, Real);
 
   AKANTU_GET_MACRO(SpatialDimension, spatial_dimension, UInt);
 
   /// return the potential energy for the subset of elements contained by the
   /// material
   Real getPotentialEnergy();
   /// return the potential energy for the provided element
   Real getPotentialEnergy(ElementType & type, UInt index);
 
   /// return the energy (identified by id) for the subset of elements contained
   /// by the material
   virtual Real getEnergy(const std::string & type);
   /// return the energy (identified by id) for the provided element
   virtual Real getEnergy(const std::string & energy_id, ElementType type,
                          UInt index);
 
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ElementFilter, element_filter, UInt);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(GradU, gradu, Real);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Stress, stress, Real);
   AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(PotentialEnergy, potential_energy,
                                          Real);
   AKANTU_GET_MACRO(GradU, gradu, const ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO(Stress, stress, const ElementTypeMapArray<Real> &);
   AKANTU_GET_MACRO(ElementFilter, element_filter,
                    const ElementTypeMapArray<UInt> &);
   AKANTU_GET_MACRO(FEEngine, fem, FEEngine &);
 
   bool isNonLocal() const { return is_non_local; }
 
   template <typename T>
   const Array<T> & getArray(const ID & id, ElementType type,
                             GhostType ghost_type = _not_ghost) const;
   template <typename T>
   Array<T> & getArray(const ID & id, ElementType type,
                       GhostType ghost_type = _not_ghost);
 
   template <typename T>
   const InternalField<T> & getInternal(const ID & id) const;
   template <typename T> InternalField<T> & getInternal(const ID & id);
 
   template <typename T>
   inline bool isInternal(const ID & id, ElementKind element_kind) const;
 
   template <typename T>
   ElementTypeMap<UInt> getInternalDataPerElem(const ID & id,
                                               ElementKind element_kind) const;
 
   bool isFiniteDeformation() const { return finite_deformation; }
   bool isInelasticDeformation() const { return inelastic_deformation; }
 
   template <typename T> inline void setParam(const ID & param, T value);
   inline const Parameter & getParam(const ID & param) const;
 
   template <typename T>
   void flattenInternal(const std::string & field_id,
                        ElementTypeMapArray<T> & internal_flat,
                        GhostType ghost_type = _not_ghost,
                        ElementKind element_kind = _ek_not_defined) const;
 
   /// apply a constant eigengrad_u everywhere in the material
   virtual void applyEigenGradU(const Matrix<Real> & prescribed_eigen_grad_u,
                                GhostType /*ghost_type*/ = _not_ghost);
 
   bool hasMatrixChanged(const ID & id) {
     if (id == "K") {
       return hasStiffnessMatrixChanged() or finite_deformation;
     }
 
     return true;
   }
 
   MatrixType getMatrixType(const ID & id) {
     if (id == "K") {
       return getTangentType();
     }
 
     if (id == "M") {
       return _symmetric;
     }
 
     return _mt_not_defined;
   }
 
   /// specify if the matrix need to be recomputed for this material
   virtual bool hasStiffnessMatrixChanged() { return true; }
 
   /// specify the type of matrix, if not overloaded the material is not valid
   /// for static or implicit computations
   virtual MatrixType getTangentType() { return _mt_not_defined; }
 
   /// static method to reteive the material factory
   static MaterialFactory & getFactory();
 
 protected:
   bool isInit() const { return is_init; }
 
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 protected:
   /// boolean to know if the material has been initialized
   bool is_init{false};
 
   std::map<ID, InternalField<Real> *> internal_vectors_real;
   std::map<ID, InternalField<UInt> *> internal_vectors_uint;
   std::map<ID, InternalField<bool> *> internal_vectors_bool;
 
 protected:
   ID id;
 
   /// Link to the fem object in the model
   FEEngine & fem;
 
   /// Finite deformation
   bool finite_deformation{false};
 
   /// Finite deformation
   bool inelastic_deformation{false};
 
   /// material name
   std::string name;
 
   /// The model to witch the material belong
   SolidMechanicsModel & model;
 
   /// density : rho
   Real rho{0.};
 
   /// spatial dimension
   UInt spatial_dimension;
 
   /// list of element handled by the material
   ElementTypeMapArray<UInt> element_filter;
 
   /// stresses arrays ordered by element types
   InternalField<Real> stress;
 
   /// eigengrad_u arrays ordered by element types
   InternalField<Real> eigengradu;
 
   /// grad_u arrays ordered by element types
   InternalField<Real> gradu;
 
   /// Green Lagrange strain (Finite deformation)
   InternalField<Real> green_strain;
 
   /// Second Piola-Kirchhoff stress tensor arrays ordered by element types
   /// (Finite deformation)
   InternalField<Real> piola_kirchhoff_2;
 
   /// potential energy by element
   InternalField<Real> potential_energy;
 
   /// tell if using in non local mode or not
   bool is_non_local{false};
 
   /// tell if the material need the previous stress state
   bool use_previous_stress{false};
 
   /// tell if the material need the previous strain state
   bool use_previous_gradu{false};
 
   /// elemental field interpolation coordinates
   InternalField<Real> interpolation_inverse_coordinates;
 
   /// elemental field interpolation points
   InternalField<Real> interpolation_points_matrices;
 
   /// vector that contains the names of all the internals that need to
   /// be transferred when material interfaces move
   std::vector<ID> internals_to_transfer;
 
 private:
   /// eigen_grad_u for the parser
   Matrix<Real> eigen_grad_u;
 };
 
 /// standard output stream operator
 inline std::ostream & operator<<(std::ostream & stream,
                                  const Material & _this) {
   _this.printself(stream);
   return stream;
 }
 
 } // namespace akantu
 
 #include "material_inline_impl.hh"
 
 #include "internal_field_tmpl.hh"
 #include "random_internal_field_tmpl.hh"
 
 /* -------------------------------------------------------------------------- */
 /* Auto loop                                                                  */
 /* -------------------------------------------------------------------------- */
 /// This can be used to automatically write the loop on quadrature points in
 /// functions such as computeStress. This macro in addition to write the loop
 /// provides two tensors (matrices) sigma and grad_u
 #define MATERIAL_STRESS_QUADRATURE_POINT_LOOP_BEGIN(el_type, ghost_type)       \
   auto && grad_u_view =                                                        \
       make_view(this->gradu(el_type, ghost_type), this->spatial_dimension,     \
                 this->spatial_dimension);                                      \
                                                                                \
   auto stress_view =                                                           \
       make_view(this->stress(el_type, ghost_type), this->spatial_dimension,    \
                 this->spatial_dimension);                                      \
                                                                                \
   if (this->isFiniteDeformation()) {                                           \
     stress_view = make_view(this->piola_kirchhoff_2(el_type, ghost_type),      \
                             this->spatial_dimension, this->spatial_dimension); \
   }                                                                            \
                                                                                \
   for (auto && data : zip(grad_u_view, stress_view)) {                         \
     [[gnu::unused]] Matrix<Real> & grad_u = std::get<0>(data);                 \
     [[gnu::unused]] Matrix<Real> & sigma = std::get<1>(data)
 
 #define MATERIAL_STRESS_QUADRATURE_POINT_LOOP_END }
 
 /// This can be used to automatically write the loop on quadrature points in
 /// functions such as computeTangentModuli. This macro in addition to write the
 /// loop provides two tensors (matrices) sigma_tensor, grad_u, and a matrix
 /// where the elemental tangent moduli should be stored in Voigt Notation
 #define MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_BEGIN(tangent_mat)              \
   auto && grad_u_view =                                                        \
       make_view(this->gradu(el_type, ghost_type), this->spatial_dimension,     \
                 this->spatial_dimension);                                      \
                                                                                \
   auto && stress_view =                                                        \
       make_view(this->stress(el_type, ghost_type), this->spatial_dimension,    \
                 this->spatial_dimension);                                      \
                                                                                \
   auto tangent_size =                                                          \
       this->getTangentStiffnessVoigtSize(this->spatial_dimension);             \
                                                                                \
   auto && tangent_view = make_view(tangent_mat, tangent_size, tangent_size);   \
                                                                                \
   for (auto && data : zip(grad_u_view, stress_view, tangent_view)) {           \
     [[gnu::unused]] Matrix<Real> & grad_u = std::get<0>(data);                 \
     [[gnu::unused]] Matrix<Real> & sigma = std::get<1>(data);                  \
     Matrix<Real> & tangent = std::get<2>(data);
 
 #define MATERIAL_TANGENT_QUADRATURE_POINT_LOOP_END }
 
 /* -------------------------------------------------------------------------- */
 
 #define INSTANTIATE_MATERIAL_ONLY(mat_name)                                    \
   template class mat_name<1>; /* NOLINT */                                     \
   template class mat_name<2>; /* NOLINT */                                     \
   template class mat_name<3>  /* NOLINT */
 
 #define MATERIAL_DEFAULT_PER_DIM_ALLOCATOR(id, mat_name)                       \
   [](UInt dim, const ID &, SolidMechanicsModel & model,                        \
      const ID & id) /* NOLINT */                                               \
       -> std::unique_ptr<                                                      \
           Material> { /* NOLINT */                                             \
                       switch (dim) {                                           \
                       case 1:                                                  \
                         return std::make_unique<mat_name<1>>(/* NOLINT */      \
                                                              model, id);       \
                       case 2:                                                  \
                         return std::make_unique<mat_name<2>>(/* NOLINT */      \
                                                              model, id);       \
                       case 3:                                                  \
                         return std::make_unique<mat_name<3>>(/* NOLINT */      \
                                                              model, id);       \
                       default:                                                 \
                         AKANTU_EXCEPTION(                                      \
                             "The dimension "                                   \
                             << dim                                             \
                             << "is not a valid dimension for the material "    \
                             << #id);                                           \
                       }                                                        \
   }
 
 #define INSTANTIATE_MATERIAL(id, mat_name)                                     \
   INSTANTIATE_MATERIAL_ONLY(mat_name);                                         \
-  static bool material_is_alocated_##id [[gnu::unused]] =                      \
+  static bool material_is_alocated_##id =                                      \
       MaterialFactory::getInstance().registerAllocator(                        \
           #id, MATERIAL_DEFAULT_PER_DIM_ALLOCATOR(id, mat_name))
 
 #endif /* AKANTU_MATERIAL_HH_ */
diff --git a/src/model/solid_mechanics/solid_mechanics_model.cc b/src/model/solid_mechanics/solid_mechanics_model.cc
index cd6d345fb..21dc28321 100644
--- a/src/model/solid_mechanics/solid_mechanics_model.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model.cc
@@ -1,1255 +1,1250 @@
 /**
  * @file   solid_mechanics_model.cc
  *
  * @author Ramin Aghababaei <ramin.aghababaei@epfl.ch>
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  * @author Mauro Corrado <mauro.corrado@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: Fri Apr 09 2021
  *
  * @brief  Implementation of the SolidMechanicsModel class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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 "solid_mechanics_model_tmpl.hh"
 
 #include "communicator.hh"
 #include "element_synchronizer.hh"
 #include "sparse_matrix.hh"
 #include "synchronizer_registry.hh"
 
 #include "dumpable_inline_impl.hh"
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_iohelper_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
  * @param model_type this is an internal parameter for inheritance purposes
  */
 
 SolidMechanicsModel::SolidMechanicsModel(
     Mesh & mesh, UInt dim, const ID & id,
     std::shared_ptr<DOFManager> dof_manager, const ModelType model_type)
     : Model(mesh, model_type, std::move(dof_manager), dim, id),
       material_index("material index", id),
       material_local_numbering("material local numbering", id) {
   AKANTU_DEBUG_IN();
 
   this->registerFEEngineObject<MyFEEngineType>("SolidMechanicsFEEngine", mesh,
                                                Model::spatial_dimension);
 
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("solid_mechanics_model", id, true);
   this->mesh.addDumpMesh(mesh, Model::spatial_dimension, _not_ghost,
                          _ek_regular);
-#endif
 
   material_selector = std::make_shared<DefaultMaterialSelector>(material_index);
 
   this->registerDataAccessor(*this);
 
   if (this->mesh.isDistributed()) {
     auto & synchronizer = this->mesh.getElementSynchronizer();
     this->registerSynchronizer(synchronizer, SynchronizationTag::_material_id);
     this->registerSynchronizer(synchronizer, SynchronizationTag::_smm_mass);
     this->registerSynchronizer(synchronizer, SynchronizationTag::_smm_stress);
     this->registerSynchronizer(synchronizer, SynchronizationTag::_for_dump);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModel::~SolidMechanicsModel() = default;
 
 /* -------------------------------------------------------------------------- */
 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 options
  * \parblock
  * contains the different options to initialize the model
  * \li \c analysis_method specify the type of solver to use
  * \endparblock
  */
 void SolidMechanicsModel::initFullImpl(const ModelOptions & options) {
   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);
 
   Model::initFullImpl(options);
 
   // initialize the materials
   if (not this->parser.getLastParsedFile().empty()) {
     this->instantiateMaterials();
     this->initMaterials();
   }
 
   this->initBC(*this, *displacement, *displacement_increment, *external_force);
 }
 
 /* -------------------------------------------------------------------------- */
 TimeStepSolverType SolidMechanicsModel::getDefaultSolverType() const {
   return TimeStepSolverType::_dynamic_lumped;
 }
 
 /* -------------------------------------------------------------------------- */
 ModelSolverOptions SolidMechanicsModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case TimeStepSolverType::_dynamic_lumped: {
     options.non_linear_solver_type = NonLinearSolverType::_lumped;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_central_difference;
     options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     break;
   }
   case TimeStepSolverType::_static: {
     options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   case TimeStepSolverType::_dynamic: {
     if (this->method == _explicit_consistent_mass) {
       options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
       options.integration_scheme_type["displacement"] =
           IntegrationSchemeType::_central_difference;
       options.solution_type["displacement"] = IntegrationScheme::_acceleration;
     } else {
       options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
       options.integration_scheme_type["displacement"] =
           IntegrationSchemeType::_trapezoidal_rule_2;
       options.solution_type["displacement"] = IntegrationScheme::_displacement;
     }
     break;
   }
   default:
     AKANTU_EXCEPTION(type << " is not a valid time step solver type");
   }
 
   return options;
 }
 
 /* -------------------------------------------------------------------------- */
 std::tuple<ID, TimeStepSolverType>
 SolidMechanicsModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _explicit_lumped_mass: {
     return std::make_tuple("explicit_lumped",
                            TimeStepSolverType::_dynamic_lumped);
   }
   case _explicit_consistent_mass: {
     return std::make_tuple("explicit", TimeStepSolverType::_dynamic);
   }
   case _static: {
     return std::make_tuple("static", TimeStepSolverType::_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", TimeStepSolverType::_dynamic);
   }
   default:
     return std::make_tuple("unknown", TimeStepSolverType::_not_defined);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initSolver(TimeStepSolverType time_step_solver_type,
                                      NonLinearSolverType /*unused*/) {
   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 == TimeStepSolverType::_dynamic ||
       time_step_solver_type == TimeStepSolverType::_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);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 /**
  * 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();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::assembleResidual(const ID & residual_part) {
   AKANTU_DEBUG_IN();
 
   if ("external" == residual_part) {
     this->getDOFManager().assembleToResidual("displacement",
                                              *this->external_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   if ("internal" == residual_part) {
     this->assembleInternalForces();
     this->getDOFManager().assembleToResidual("displacement",
                                              *this->internal_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   AKANTU_CUSTOM_EXCEPTION(
       debug::SolverCallbackResidualPartUnknown(residual_part));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 MatrixType SolidMechanicsModel::getMatrixType(const ID & matrix_id) const {
   // \TODO check the materials to know what is the correct answer
   if (matrix_id == "C") {
     return _mt_not_defined;
   }
 
   if (matrix_id == "K") {
     auto matrix_type = _unsymmetric;
 
     for (auto & material : materials) {
       matrix_type = std::max(matrix_type, material->getMatrixType(matrix_id));
     }
   }
   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(bool converged) {
   for (auto & material : materials) {
     material->afterSolveStep(converged);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::predictor() { ++displacement_release; }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::corrector() { ++displacement_release; }
 
 /* -------------------------------------------------------------------------- */
 /**
  * This function computes the internal forces as \f$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->zero();
 
   // 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(SynchronizationTag::_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(SynchronizationTag::_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(bool need_to_reassemble) {
   AKANTU_DEBUG_IN();
 
   AKANTU_DEBUG_INFO("Assemble the new stiffness matrix.");
 
   // Check if materials need to recompute the matrix
   for (auto & material : materials) {
     need_to_reassemble |= material->hasMatrixChanged("K");
   }
 
   if (need_to_reassemble) {
     this->getDOFManager().getMatrix("K").zero();
 
     // 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
   mesh.getCommunicator().allReduce(min_dt, SynchronizerOperation::_min);
 
   AKANTU_DEBUG_OUT();
   return min_dt;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getStableTimeStep(GhostType ghost_type) {
   AKANTU_DEBUG_IN();
 
   Real min_dt = std::numeric_limits<Real>::max();
 
   this->updateCurrentPosition();
 
   Element elem;
   elem.ghost_type = ghost_type;
 
   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 auto & v = *v_it;
       const auto & m = *m_it;
 
       Real mv2 = 0.;
       auto is_local_node = mesh.isLocalOrMasterNode(n);
       // bool is_not_pbc_slave_node = !isPBCSlaveNode(n);
       auto 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().assembleMatMulVectToArray("displacement", "M",
                                                     *this->velocity, Mv);
 
     for (auto && data : zip(arange(nb_nodes), make_view(Mv, spatial_dimension),
                             make_view(*this->velocity, spatial_dimension))) {
       ekin += std::get<2>(data).dot(std::get<1>(data)) *
               static_cast<Real>(mesh.isLocalOrMasterNode(std::get<0>(data)));
     }
   } else {
     AKANTU_ERROR("No function called to assemble the mass matrix.");
   }
 
   mesh.getCommunicator().allReduce(ekin, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return ekin * .5;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getKineticEnergy(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);
 
   auto vit = vel_on_quad.begin(Model::spatial_dimension);
   auto 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 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);
 
   decltype(ext_force_it) incr_or_velo_it;
   if (this->method == _static) {
     incr_or_velo_it =
         this->displacement_increment->begin(Model::spatial_dimension);
   } else {
     incr_or_velo_it = this->velocity->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);
         }
       }
     }
   }
 
   mesh.getCommunicator().allReduce(work, SynchronizerOperation::_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();
   }
 
   if (energy_id == "external work") {
     return getExternalWork();
   }
 
   Real energy = 0.;
   for (auto & material : materials) {
     energy += material->getEnergy(energy_id);
   }
 
   /// reduction sum over all processors
   mesh.getCommunicator().allReduce(energy, SynchronizerOperation::_sum);
 
   AKANTU_DEBUG_OUT();
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getEnergy(const std::string & energy_id,
                                     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;
 }
 
 /* -------------------------------------------------------------------------- */
 Real SolidMechanicsModel::getEnergy(const ID & energy_id, const ID & group_id) {
   auto && group = mesh.getElementGroup(group_id);
   auto energy = 0.;
   for (auto && type : group.elementTypes()) {
     for (auto el : group.getElementsIterable(type)) {
       energy += getEnergy(energy_id, el);
     }
   }
 
   /// reduction sum over all processors
   mesh.getCommunicator().allReduce(energy, SynchronizerOperation::_sum);
 
   return energy;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onElementsAdded(const Array<Element> & element_list,
                                           const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   this->material_index.initialize(mesh, _element_kind = _ek_not_defined,
                                   _with_nb_element = true,
                                   _default_value = UInt(-1));
   this->material_local_numbering.initialize(
       mesh, _element_kind = _ek_not_defined, _with_nb_element = true,
       _default_value = UInt(-1));
 
   ElementTypeMapArray<UInt> filter("new_element_filter", this->getID());
 
   for (const auto & elem : element_list) {
     if (mesh.getSpatialDimension(elem.type) != spatial_dimension) {
       continue;
     }
 
     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 fails in parallel if the event is sent on facet between constructor
   // and initFull \todo: to debug...
   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) {
   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, false);
   }
   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(const Array<UInt> & /*element_list*/,
                                          const Array<UInt> & new_numbering,
                                          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);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::printself(std::ostream & stream, int indent) const {
   std::string space(indent, 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 << " ]" << std::endl;
 
   stream << space << " + nodals information [" << std::endl;
   displacement->printself(stream, indent + 2);
   if (velocity) {
     velocity->printself(stream, indent + 2);
   }
   if (acceleration) {
     acceleration->printself(stream, indent + 2);
   }
   if (mass) {
     mass->printself(stream, indent + 2);
   }
   external_force->printself(stream, indent + 2);
   internal_force->printself(stream, indent + 2);
   blocked_dofs->printself(stream, indent + 2);
   stream << space << " ]" << std::endl;
 
   stream << space << " + material information [" << std::endl;
   material_index.printself(stream, indent + 2);
   stream << space << " ]" << std::endl;
 
   stream << space << " + materials [" << std::endl;
   for (const auto & material : materials) {
     material->printself(stream, indent + 2);
   }
   stream << space << " ]" << std::endl;
 
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::initializeNonLocal() {
   this->non_local_manager->synchronize(*this, SynchronizationTag::_material_id);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::insertIntegrationPointsInNeighborhoods(
     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);
     quadrature_points_coordinates.initialize(this->getFEEngine(),
                                              _nb_component = spatial_dimension,
                                              _ghost_type = ghost_type);
 
     for (const 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(GhostType ghost_type) {
   for (auto & mat : materials) {
     if (not aka::is_of_type<MaterialNonLocalInterface>(*mat)) {
       continue;
     }
 
     auto & mat_non_local = dynamic_cast<MaterialNonLocalInterface &>(*mat);
     mat_non_local.computeNonLocalStresses(ghost_type);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::updateLocalInternal(
     ElementTypeMapReal & internal_flat, GhostType ghost_type,
     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, GhostType ghost_type,
     ElementKind kind) {
 
   const ID field_name = internal_flat.getName();
 
   for (auto & mat : materials) {
     if (not aka::is_of_type<MaterialNonLocalInterface>(*mat)) {
       continue;
     }
 
     auto & mat_non_local = dynamic_cast<MaterialNonLocalInterface &>(*mat);
     mat_non_local.updateNonLocalInternals(internal_flat, field_name, ghost_type,
                                           kind);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 FEEngine & SolidMechanicsModel::getFEEngineBoundary(const ID & name) {
   return getFEEngineClassBoundary<MyFEEngineType>(name);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::splitElementByMaterial(
     const Array<Element> & elements,
     std::vector<Array<Element>> & elements_per_mat) const {
   for (const auto & el : elements) {
     Element mat_el = el;
     mat_el.element = this->material_local_numbering(el);
     elements_per_mat[this->material_index(el)].push_back(mat_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 SynchronizationTag::_material_id: {
     size += elements.size() * sizeof(UInt);
     break;
   }
   case SynchronizationTag::_smm_mass: {
     size += nb_nodes_per_element * sizeof(Real) *
             Model::spatial_dimension; // mass vector
     break;
   }
   case SynchronizationTag::_smm_for_gradu: {
     size += nb_nodes_per_element * Model::spatial_dimension *
             sizeof(Real); // displacement
     break;
   }
   case SynchronizationTag::_smm_boundary: {
     // force, displacement, boundary
     size += nb_nodes_per_element * Model::spatial_dimension *
             (2 * sizeof(Real) + sizeof(bool));
     break;
   }
   case SynchronizationTag::_for_dump: {
     // displacement, velocity, acceleration, residual, force
     size += nb_nodes_per_element * Model::spatial_dimension * sizeof(Real) * 5;
     break;
   }
   default: {
   }
   }
 
   if (tag != SynchronizationTag::_material_id) {
     splitByMaterial(elements, [&](auto && mat, auto && elements) {
       size += mat.getNbData(elements, tag);
     });
   }
 
   AKANTU_DEBUG_OUT();
   return size;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::packData(CommunicationBuffer & buffer,
                                    const Array<Element> & elements,
                                    const SynchronizationTag & tag) const {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case SynchronizationTag::_material_id: {
     packElementalDataHelper(material_index, buffer, elements, false,
                             getFEEngine());
     break;
   }
   case SynchronizationTag::_smm_mass: {
     packNodalDataHelper(*mass, buffer, elements, mesh);
     break;
   }
   case SynchronizationTag::_smm_for_gradu: {
     packNodalDataHelper(*displacement, buffer, elements, mesh);
     break;
   }
   case SynchronizationTag::_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 SynchronizationTag::_smm_boundary: {
     packNodalDataHelper(*external_force, buffer, elements, mesh);
     packNodalDataHelper(*velocity, buffer, elements, mesh);
     packNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
     break;
   }
   default: {
   }
   }
 
   if (tag != SynchronizationTag::_material_id) {
     splitByMaterial(elements, [&](auto && mat, auto && elements) {
       mat.packData(buffer, elements, tag);
     });
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::unpackData(CommunicationBuffer & buffer,
                                      const Array<Element> & elements,
                                      const SynchronizationTag & tag) {
   AKANTU_DEBUG_IN();
 
   switch (tag) {
   case SynchronizationTag::_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;
     }
     break;
   }
   case SynchronizationTag::_smm_mass: {
     unpackNodalDataHelper(*mass, buffer, elements, mesh);
     break;
   }
   case SynchronizationTag::_smm_for_gradu: {
     unpackNodalDataHelper(*displacement, buffer, elements, mesh);
     break;
   }
   case SynchronizationTag::_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 SynchronizationTag::_smm_boundary: {
     unpackNodalDataHelper(*external_force, buffer, elements, mesh);
     unpackNodalDataHelper(*velocity, buffer, elements, mesh);
     unpackNodalDataHelper(*blocked_dofs, buffer, elements, mesh);
     break;
   }
   default: {
   }
   }
 
   if (tag != SynchronizationTag::_material_id) {
     splitByMaterial(elements, [&](auto && mat, auto && elements) {
       mat.unpackData(buffer, elements, tag);
     });
   }
 
   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 SynchronizationTag::_smm_uv: {
     size += sizeof(Real) * Model::spatial_dimension * 2;
     break;
   }
   case SynchronizationTag::_smm_res: /* FALLTHRU */
   case SynchronizationTag::_smm_mass: {
     size += sizeof(Real) * Model::spatial_dimension;
     break;
   }
   case SynchronizationTag::_for_dump: {
     size += sizeof(Real) * Model::spatial_dimension * 5;
     break;
   }
   default: {
     AKANTU_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 SynchronizationTag::_smm_uv: {
     packDOFDataHelper(*displacement, buffer, dofs);
     packDOFDataHelper(*velocity, buffer, dofs);
     break;
   }
   case SynchronizationTag::_smm_res: {
     packDOFDataHelper(*internal_force, buffer, dofs);
     break;
   }
   case SynchronizationTag::_smm_mass: {
     packDOFDataHelper(*mass, buffer, dofs);
     break;
   }
   case SynchronizationTag::_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_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 SynchronizationTag::_smm_uv: {
     unpackDOFDataHelper(*displacement, buffer, dofs);
     unpackDOFDataHelper(*velocity, buffer, dofs);
     break;
   }
   case SynchronizationTag::_smm_res: {
     unpackDOFDataHelper(*internal_force, buffer, dofs);
     break;
   }
   case SynchronizationTag::_smm_mass: {
     unpackDOFDataHelper(*mass, buffer, dofs);
     break;
   }
   case SynchronizationTag::_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_ERROR("Unknown ghost synchronization tag : " << tag);
   }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc b/src/model/solid_mechanics/solid_mechanics_model_cohesive/solid_mechanics_model_cohesive.cc
index 28575ae14..d2a57ed48 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,698 +1,692 @@
 /**
  * @file   solid_mechanics_model_cohesive.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @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: Fri Apr 09 2021
  *
  * @brief  Solid mechanics model for cohesive elements
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "solid_mechanics_model_cohesive.hh"
 #include "aka_iterators.hh"
 #include "cohesive_element_inserter.hh"
 #include "element_synchronizer.hh"
 #include "facet_synchronizer.hh"
 #include "fe_engine_template.hh"
 #include "global_ids_updater.hh"
 #include "integrator_gauss.hh"
 #include "material_cohesive.hh"
 #include "mesh_accessor.hh"
 #include "mesh_global_data_updater.hh"
 #include "parser.hh"
 #include "shape_cohesive.hh"
 /* -------------------------------------------------------------------------- */
 #include "dumpable_inline_impl.hh"
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_iohelper_paraview.hh"
-#endif
 /* -------------------------------------------------------------------------- */
 #include <algorithm>
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 class CohesiveMeshGlobalDataUpdater : public MeshGlobalDataUpdater {
 public:
   CohesiveMeshGlobalDataUpdater(SolidMechanicsModelCohesive & model)
       : model(model), mesh(model.getMesh()),
         global_ids_updater(model.getMesh(), *model.cohesive_synchronizer) {}
 
   /* ------------------------------------------------------------------------ */
   std::tuple<UInt, UInt>
   updateData(NewNodesEvent & nodes_event,
              NewElementsEvent & elements_event) override {
     auto * cohesive_nodes_event =
         dynamic_cast<CohesiveNewNodesEvent *>(&nodes_event);
     if (cohesive_nodes_event == nullptr) {
       return std::make_tuple(nodes_event.getList().size(),
                              elements_event.getList().size());
     }
 
     /// update nodes type
     auto & new_nodes = cohesive_nodes_event->getList();
     auto & old_nodes = cohesive_nodes_event->getOldNodesList();
 
     auto local_nb_new_nodes = new_nodes.size();
     auto nb_new_nodes = local_nb_new_nodes;
 
     if (mesh.isDistributed()) {
       MeshAccessor mesh_accessor(mesh);
       auto & nodes_flags = mesh_accessor.getNodesFlags();
       auto nb_old_nodes = nodes_flags.size();
       nodes_flags.resize(nb_old_nodes + local_nb_new_nodes);
 
       for (auto && data : zip(old_nodes, new_nodes)) {
         UInt old_node;
         UInt new_node;
         std::tie(old_node, new_node) = data;
         nodes_flags(new_node) = nodes_flags(old_node);
       }
 
       model.updateCohesiveSynchronizers(elements_event);
       nb_new_nodes = global_ids_updater.updateGlobalIDs(new_nodes.size());
     }
 
     auto nb_new_elements = elements_event.getList().size();
     const auto & comm = mesh.getCommunicator();
     comm.allReduce(nb_new_elements, SynchronizerOperation::_sum);
 
     if (nb_new_elements > 0) {
       mesh.sendEvent(elements_event);
     }
 
     if (nb_new_nodes > 0) {
       mesh.sendEvent(nodes_event);
     }
 
     return std::make_tuple(nb_new_nodes, nb_new_elements);
   }
 
 private:
   SolidMechanicsModelCohesive & model;
   Mesh & mesh;
   GlobalIdsUpdater global_ids_updater;
 };
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelCohesive::SolidMechanicsModelCohesive(
     Mesh & mesh, UInt dim, const ID & id,
     std::shared_ptr<DOFManager> dof_manager)
     : SolidMechanicsModel(mesh, dim, id, dof_manager,
                           ModelType::_solid_mechanics_model_cohesive),
       tangents("tangents", id), facet_stress("facet_stress", id),
       facet_material("facet_material", id) {
   AKANTU_DEBUG_IN();
 
   registerFEEngineObject<MyFEEngineCohesiveType>("CohesiveFEEngine", mesh,
                                                  Model::spatial_dimension);
 
   auto && tmp_material_selector =
       std::make_shared<DefaultMaterialCohesiveSelector>(*this);
 
   tmp_material_selector->setFallback(this->material_selector);
   this->material_selector = tmp_material_selector;
 
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("cohesive elements", id);
   this->mesh.addDumpMeshToDumper("cohesive elements", mesh,
                                  Model::spatial_dimension, _not_ghost,
                                  _ek_cohesive);
-#endif
 
   if (this->mesh.isDistributed()) {
     /// create the distributed synchronizer for cohesive elements
     this->cohesive_synchronizer = std::make_unique<ElementSynchronizer>(
         mesh, "cohesive_distributed_synchronizer");
 
     auto & synchronizer = mesh.getElementSynchronizer();
     this->cohesive_synchronizer->split(synchronizer, [](auto && el) {
       return Mesh::getKind(el.type) == _ek_cohesive;
     });
 
     this->registerSynchronizer(*cohesive_synchronizer,
                                SynchronizationTag::_material_id);
     this->registerSynchronizer(*cohesive_synchronizer,
                                SynchronizationTag::_smm_stress);
     this->registerSynchronizer(*cohesive_synchronizer,
                                SynchronizationTag::_smm_boundary);
   }
 
   this->inserter = std::make_unique<CohesiveElementInserter>(
       this->mesh, id + ":cohesive_element_inserter");
 
   registerFEEngineObject<MyFEEngineFacetType>(
       "FacetsFEEngine", mesh.getMeshFacets(), Model::spatial_dimension - 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 SolidMechanicsModelCohesive::~SolidMechanicsModelCohesive() = default;
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::setTimeStep(Real time_step,
                                               const ID & solver_id) {
   SolidMechanicsModel::setTimeStep(time_step, solver_id);
-
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.getDumper("cohesive elements").setTimeStep(time_step);
-#endif
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initFullImpl(const ModelOptions & options) {
   AKANTU_DEBUG_IN();
 
   const auto & smmc_options =
       aka::as_type<SolidMechanicsModelCohesiveOptions>(options);
 
   this->is_extrinsic = smmc_options.is_extrinsic;
 
   inserter->setIsExtrinsic(is_extrinsic);
 
   if (mesh.isDistributed()) {
     auto & mesh_facets = inserter->getMeshFacets();
     auto & synchronizer =
         aka::as_type<FacetSynchronizer>(mesh_facets.getElementSynchronizer());
 
     // synchronizeGhostFacetsConnectivity();
 
     /// create the facet synchronizer for extrinsic simulations
     if (is_extrinsic) {
       facet_stress_synchronizer = std::make_unique<ElementSynchronizer>(
           synchronizer, id + ":facet_stress_synchronizer");
       facet_stress_synchronizer->swapSendRecv();
       this->registerSynchronizer(*facet_stress_synchronizer,
                                  SynchronizationTag::_smmc_facets_stress);
     }
   }
 
   MeshAccessor mesh_accessor(mesh);
   mesh_accessor.registerGlobalDataUpdater(
       std::make_unique<CohesiveMeshGlobalDataUpdater>(*this));
 
   ParserSection section;
   bool is_empty;
   std::tie(section, is_empty) = this->getParserSection();
 
   if (not is_empty) {
     auto inserter_section =
         section.getSubSections(ParserType::_cohesive_inserter);
     if (inserter_section.begin() != inserter_section.end()) {
       inserter->parseSection(*inserter_section.begin());
     }
   }
 
   SolidMechanicsModel::initFullImpl(options);
 
   AKANTU_DEBUG_OUT();
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initMaterials() {
   AKANTU_DEBUG_IN();
 
   // make sure the material are instantiated
   if (not are_materials_instantiated) {
     instantiateMaterials();
   }
 
   /// find the first cohesive material
   UInt cohesive_index = UInt(-1);
 
   for (auto && material : enumerate(materials)) {
     if (dynamic_cast<MaterialCohesive *>(std::get<1>(material).get()) !=
         nullptr) {
       cohesive_index = std::get<0>(material);
       break;
     }
   }
 
   if (cohesive_index == UInt(-1)) {
     AKANTU_EXCEPTION("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
   // to know what material to call for stress checks
   const Mesh & mesh_facets = inserter->getMeshFacets();
   facet_material.initialize(
       mesh_facets, _spatial_dimension = spatial_dimension - 1,
       _with_nb_element = true,
       _default_value = material_selector->getFallbackValue());
 
   for_each_element(
       mesh_facets,
       [&](auto && element) {
         auto mat_index = (*material_selector)(element);
         auto & mat = aka::as_type<MaterialCohesive>(*materials[mat_index]);
         facet_material(element) = mat_index;
         if (is_extrinsic) {
           mat.addFacet(element);
         }
       },
       _spatial_dimension = spatial_dimension - 1, _ghost_type = _not_ghost);
 
   SolidMechanicsModel::initMaterials();
 
   if (is_extrinsic) {
     this->initAutomaticInsertion();
   } else {
     this->insertIntrinsicElements();
   }
 
   AKANTU_DEBUG_OUT();
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /**
  * Initialize the model,basically it  pre-compute the shapes, shapes derivatives
  * and jacobian
  */
 void SolidMechanicsModelCohesive::initModel() {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel::initModel();
 
   /// 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 auto & connectivity = mesh.getConnectivity(tmp_type, type_ghost);
       if (connectivity.empty()) {
         continue;
       }
 
       type = tmp_type;
       auto type_facet = Mesh::getFacetType(type);
       auto 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);
 
   if (is_extrinsic) {
     getFEEngine("FacetsFEEngine").initShapeFunctions(_not_ghost);
     getFEEngine("FacetsFEEngine").initShapeFunctions(_ghost);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::insertIntrinsicElements() {
   AKANTU_DEBUG_IN();
   inserter->insertIntrinsicElements();
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::initAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
   this->inserter->limitCheckFacets();
   this->updateFacetStressSynchronizer();
   this->resizeFacetStress();
 
   /// compute normals on facets
   this->computeNormals();
 
   this->initStressInterpolation();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::updateAutomaticInsertion() {
   AKANTU_DEBUG_IN();
 
   this->inserter->limitCheckFacets();
   this->updateFacetStressSynchronizer();
 
   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 (const 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
       const auto & facet_to_element =
           mesh_facets.getSubelementToElement(type, elem_gt);
       auto & el_q_facet = elements_quad_facets(type, elem_gt);
 
       auto facet_type = Mesh::getFacetType(type);
       auto nb_quad_per_facet =
           getFEEngine("FacetsFEEngine").getNbIntegrationPoints(facet_type);
       auto nb_facet_per_elem = facet_to_element.getNbComponent();
 
       // small hack in the loop to skip boundary elements, they are silently
       // initialized to NaN to see if this causes problems
       el_q_facet.resize(nb_element * nb_facet_per_elem * nb_quad_per_facet,
                         std::numeric_limits<Real>::quiet_NaN());
 
       for (auto && data :
            zip(make_view(facet_to_element),
                make_view(el_q_facet, spatial_dimension, nb_quad_per_facet))) {
         const auto & global_facet = std::get<0>(data);
         auto & el_q = std::get<1>(data);
 
         if (global_facet == ElementNull) {
           continue;
         }
 
         Matrix<Real> quad_f =
             make_view(quad_facets(global_facet.type, global_facet.ghost_type),
                       spatial_dimension, nb_quad_per_facet)
                 .begin()[global_facet.element];
 
         el_q = quad_f;
       }
     }
   }
 
   /// loop over non cohesive materials
   for (auto && material : materials) {
     if (aka::is_of_type<MaterialCohesive>(material)) {
       continue;
     }
     /// initialize the interpolation function
     material->initElementalFieldInterpolation(elements_quad_facets);
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::assembleInternalForces() {
   AKANTU_DEBUG_IN();
 
   // f_int += f_int_cohe
   for (auto & material : this->materials) {
     try {
       auto & mat = aka::as_type<MaterialCohesive>(*material);
       mat.computeTraction(_not_ghost);
     } catch (std::bad_cast & bce) {
     }
   }
 
   SolidMechanicsModel::assembleInternalForces();
 
   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) {
     if (not aka::is_of_type<MaterialCohesive>(material)) {
       /// interpolate stress on facet quadrature points positions
       material->interpolateStressOnFacets(facet_stress, by_elem_result);
     }
   }
 
   this->synchronize(SynchronizationTag::_smmc_facets_stress);
 }
 
 /* -------------------------------------------------------------------------- */
 UInt SolidMechanicsModelCohesive::checkCohesiveStress() {
   AKANTU_DEBUG_IN();
 
   if (not is_extrinsic) {
     AKANTU_EXCEPTION(
         "This function can only be used for extrinsic cohesive elements");
   }
 
   interpolateStress();
 
   for (auto & mat : materials) {
     if (aka::is_of_type<MaterialCohesive>(mat)) {
       /// check which not ghost cohesive elements are to be created
       auto * mat_cohesive = aka::as_type<MaterialCohesive>(mat.get());
       mat_cohesive->checkInsertion();
     }
   }
 
   /// communicate data among processors
   // this->synchronize(SynchronizationTag::_smmc_facets);
 
   /// insert cohesive elements
   UInt nb_new_elements = inserter->insertElements();
 
   // if (nb_new_elements > 0) {
   //   this->reinitializeSolver();
   // }
 
   AKANTU_DEBUG_OUT();
 
   return nb_new_elements;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onElementsAdded(
     const Array<Element> & element_list, const NewElementsEvent & event) {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel::onElementsAdded(element_list, event);
 
   if (is_extrinsic) {
     resizeFacetStress();
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::onNodesAdded(const Array<UInt> & new_nodes,
                                                const NewNodesEvent & event) {
   AKANTU_DEBUG_IN();
 
   SolidMechanicsModel::onNodesAdded(new_nodes, event);
 
   const CohesiveNewNodesEvent * cohesive_event;
   if ((cohesive_event = dynamic_cast<const CohesiveNewNodesEvent *>(&event)) ==
       nullptr) {
     return;
   }
 
   const auto & old_nodes = cohesive_event->getOldNodesList();
 
   auto copy = [this, &new_nodes, &old_nodes](auto & arr) {
     UInt new_node;
     UInt old_node;
 
     auto view = make_view(arr, spatial_dimension);
     auto begin = view.begin();
 
     for (auto && pair : zip(new_nodes, old_nodes)) {
       std::tie(new_node, old_node) = pair;
 
       auto old_ = begin + old_node;
       auto new_ = begin + new_node;
 
       *new_ = *old_;
     }
   };
 
   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 (displacement_increment) {
     copy(*displacement_increment);
   }
 
   copy(getDOFManager().getSolution("displacement"));
   // this->assembleMassLumped();
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::afterSolveStep(bool converged) {
   AKANTU_DEBUG_IN();
 
   /*
    * This is required because the Cauchy stress is the stress measure that
    * is used to check the insertion of cohesive elements
    */
   if (converged) {
     for (auto & mat : materials) {
       if (mat->isFiniteDeformation()) {
         mat->computeAllCauchyStresses(_not_ghost);
       }
     }
   }
 
   SolidMechanicsModel::afterSolveStep(converged);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::printself(std::ostream & stream,
                                             int indent) const {
   std::string space(indent, AKANTU_INDENT);
 
   stream << space << "SolidMechanicsModelCohesive ["
          << "\n";
   SolidMechanicsModel::printself(stream, indent + 2);
   stream << space << "]" << std::endl;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::resizeFacetStress() {
   AKANTU_DEBUG_IN();
 
   this->facet_stress.initialize(getFEEngine("FacetsFEEngine"),
                                 _nb_component =
                                     2 * spatial_dimension * spatial_dimension,
                                 _spatial_dimension = spatial_dimension - 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModelCohesive::addDumpGroupFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const std::string & group_name, 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_embedded_interface/embedded_interface_model.cc b/src/model/solid_mechanics/solid_mechanics_model_embedded_interface/embedded_interface_model.cc
index 5b1d0202a..096cf4d17 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_embedded_interface/embedded_interface_model.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_embedded_interface/embedded_interface_model.cc
@@ -1,175 +1,166 @@
 /**
  * @file   embedded_interface_model.cc
  *
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  *
  * @date creation: Fri Mar 13 2015
  * @date last modification: Wed Feb 14 2018
  *
  * @brief  Model of Solid Mechanics with embedded interfaces
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
-
 #include "embedded_interface_model.hh"
 #include "integrator_gauss.hh"
 #include "material_elastic.hh"
 #include "material_reinforcement.hh"
 #include "mesh_iterators.hh"
 #include "shape_lagrange.hh"
-
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumpable_inline_impl.hh"
 #include "dumper_iohelper_paraview.hh"
-#endif
-
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 EmbeddedInterfaceModel::EmbeddedInterfaceModel(Mesh & mesh,
                                                Mesh & primitive_mesh,
                                                UInt spatial_dimension,
                                                const ID & id)
     : SolidMechanicsModel(mesh, spatial_dimension, id),
       intersector(mesh, primitive_mesh), interface_mesh(nullptr),
       primitive_mesh(primitive_mesh), interface_material_selector(nullptr) {
   this->model_type = ModelType::_embedded_model;
 
   // This pointer should be deleted by ~SolidMechanicsModel()
   auto mat_sel_pointer =
       std::make_shared<MeshDataMaterialSelector<std::string>>("physical_names",
                                                               *this);
 
   this->setMaterialSelector(mat_sel_pointer);
 
   interface_mesh = &(intersector.getInterfaceMesh());
 
   // Create 1D FEEngine on the interface mesh
   registerFEEngineObject<MyFEEngineType>("EmbeddedInterfaceFEEngine",
                                          *interface_mesh, 1);
 
   // Registering allocator for material reinforcement
   MaterialFactory::getInstance().registerAllocator(
       "reinforcement",
       [&](UInt dim, const ID & constitutive, SolidMechanicsModel & /*unused*/,
           const ID & id) -> std::unique_ptr<Material> {
         if (constitutive == "elastic") {
           using mat = MaterialElastic<1>;
           switch (dim) {
           case 2:
             return std::make_unique<MaterialReinforcement<mat, 2>>(*this, id);
           case 3:
             return std::make_unique<MaterialReinforcement<mat, 3>>(*this, id);
           default:
             AKANTU_EXCEPTION("Dimension 1 is invalid for reinforcements");
           }
         } else {
           AKANTU_EXCEPTION("Reinforcement type" << constitutive
                                                 << " is not recognized");
         }
       });
 }
 
 /* -------------------------------------------------------------------------- */
 EmbeddedInterfaceModel::~EmbeddedInterfaceModel() {
   delete interface_material_selector;
 }
 
 /* -------------------------------------------------------------------------- */
 void EmbeddedInterfaceModel::initFullImpl(const ModelOptions & options) {
   const auto & eim_options =
       aka::as_type<EmbeddedInterfaceModelOptions>(options);
 
   // Do no initialize interface_mesh if told so
   if (eim_options.has_intersections) {
     intersector.constructData();
   }
 
   SolidMechanicsModel::initFullImpl(options);
 
-#if defined(AKANTU_USE_IOHELPER)
   this->mesh.registerDumper<DumperParaview>("reinforcement", id);
   this->mesh.addDumpMeshToDumper("reinforcement", *interface_mesh, 1,
                                  _not_ghost, _ek_regular);
-#endif
 }
 
 void EmbeddedInterfaceModel::initModel() {
   // Initialize interface FEEngine
   SolidMechanicsModel::initModel();
   FEEngine & engine = getFEEngine("EmbeddedInterfaceFEEngine");
   engine.initShapeFunctions(_not_ghost);
   engine.initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void EmbeddedInterfaceModel::assignMaterialToElements(
     const ElementTypeMapArray<UInt> * filter) {
   delete interface_material_selector;
   interface_material_selector =
       new InterfaceMeshDataMaterialSelector<std::string>("physical_names",
                                                          *this);
 
   for_each_element(
       getInterfaceMesh(),
       [&](auto && element) {
         auto mat_index = (*interface_material_selector)(element);
         // material_index(element) = mat_index;
         materials[mat_index]->addElement(element);
         // this->material_local_numbering(element) = index;
       },
       _element_filter = filter, _spatial_dimension = 1);
 
   SolidMechanicsModel::assignMaterialToElements(filter);
 }
 
 /* -------------------------------------------------------------------------- */
 void EmbeddedInterfaceModel::addDumpGroupFieldToDumper(
     const std::string & dumper_name, const std::string & field_id,
     const std::string & group_name, ElementKind element_kind,
     bool padding_flag) {
-#ifdef AKANTU_USE_IOHELPER
   std::shared_ptr<dumpers::Field> field;
 
   // If dumper is reinforcement, create a 1D elemental field
   if (dumper_name == "reinforcement") {
     field = this->createElementalField(field_id, group_name, padding_flag, 1,
                                        element_kind);
   } else {
     try {
       SolidMechanicsModel::addDumpGroupFieldToDumper(
           dumper_name, field_id, group_name, element_kind, padding_flag);
     } catch (...) {
     }
   }
   if (field) {
     DumperIOHelper & dumper = mesh.getGroupDumper(dumper_name, group_name);
     Model::addDumpGroupFieldToDumper(field_id, field, dumper);
   }
-
-#endif
 }
 
 } // namespace akantu
diff --git a/src/model/solid_mechanics/solid_mechanics_model_io.cc b/src/model/solid_mechanics/solid_mechanics_model_io.cc
index a77cbf731..2fa97d996 100644
--- a/src/model/solid_mechanics/solid_mechanics_model_io.cc
+++ b/src/model/solid_mechanics/solid_mechanics_model_io.cc
@@ -1,335 +1,311 @@
 /**
  * @file   solid_mechanics_model_io.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: Sun Jul 09 2017
  * @date last modification: Fri Apr 09 2021
  *
  * @brief  Dumpable part of the SolidMechnicsModel
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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 "group_manager_inline_impl.hh"
 
 #include "dumpable_inline_impl.hh"
-#ifdef AKANTU_USE_IOHELPER
+/* -------------------------------------------------------------------------- */
 #include "dumper_element_partition.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_field.hh"
 #include "dumper_homogenizing_field.hh"
 #include "dumper_internal_material_field.hh"
 #include "dumper_iohelper.hh"
 #include "dumper_material_padders.hh"
 #include "dumper_paraview.hh"
-#endif
+/* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 bool SolidMechanicsModel::isInternal(const std::string & field_name,
                                      ElementKind element_kind) {
   /// check if at least one material contains field_id as an internal
   for (auto & material : materials) {
     bool is_internal = material->isInternal<Real>(field_name, element_kind);
     if (is_internal) {
       return true;
     }
   }
 
   return false;
 }
 
 /* -------------------------------------------------------------------------- */
 ElementTypeMap<UInt>
 SolidMechanicsModel::getInternalDataPerElem(const std::string & field_name,
                                             ElementKind element_kind) {
   if (!(this->isInternal(field_name, element_kind))) {
     AKANTU_EXCEPTION("unknown internal " << field_name);
   }
 
   for (auto & material : materials) {
     if (material->isInternal<Real>(field_name, element_kind)) {
       return material->getInternalDataPerElem<Real>(field_name, element_kind);
     }
   }
 
   return ElementTypeMap<UInt>();
 }
 
 /* -------------------------------------------------------------------------- */
 ElementTypeMapArray<Real> &
 SolidMechanicsModel::flattenInternal(const std::string & field_name,
                                      ElementKind kind,
                                      const GhostType ghost_type) {
   auto key = std::make_pair(field_name, kind);
 
   ElementTypeMapArray<Real> * internal_flat;
 
   auto it = this->registered_internals.find(key);
   if (it == this->registered_internals.end()) {
     auto internal =
         std::make_unique<ElementTypeMapArray<Real>>(field_name, this->id);
 
     internal_flat = internal.get();
     this->registered_internals[key] = std::move(internal);
   } else {
     internal_flat = it->second.get();
   }
 
   for (auto type :
        mesh.elementTypes(Model::spatial_dimension, ghost_type, kind)) {
     if (internal_flat->exists(type, ghost_type)) {
       auto & internal = (*internal_flat)(type, ghost_type);
       internal.resize(0);
     }
   }
 
   for (auto & material : materials) {
     if (material->isInternal<Real>(field_name, kind)) {
       material->flattenInternal(field_name, *internal_flat, ghost_type, kind);
     }
   }
 
   return *internal_flat;
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::flattenAllRegisteredInternals(ElementKind kind) {
   ElementKind _kind;
   ID _id;
 
   for (auto & internal : this->registered_internals) {
     std::tie(_id, _kind) = internal.first;
     if (kind == _kind) {
       this->flattenInternal(_id, kind);
     }
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::onDump() {
   this->flattenAllRegisteredInternals(_ek_regular);
 }
 
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 std::shared_ptr<dumpers::Field> SolidMechanicsModel::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool padding_flag, UInt spatial_dimension, ElementKind kind) {
 
   std::shared_ptr<dumpers::Field> field;
 
   if (field_name == "partitions") {
     field = mesh.createElementalField<UInt, dumpers::ElementPartitionField>(
         mesh.getConnectivities(), group_name, spatial_dimension, kind);
   } else if (field_name == "material_index") {
     field = mesh.createElementalField<UInt, Vector, dumpers::ElementalField>(
         material_index, group_name, spatial_dimension, kind);
   } else {
     // this copy of field_name is used to compute derivated data such as
     // strain and von mises stress that are based on grad_u and stress
     std::string field_name_copy(field_name);
 
     if (field_name == "strain" || field_name == "Green strain" ||
         field_name == "principal strain" ||
         field_name == "principal Green strain") {
       field_name_copy = "grad_u";
     } else if (field_name == "Von Mises stress") {
       field_name_copy = "stress";
     }
 
     bool is_internal = this->isInternal(field_name_copy, kind);
 
     if (is_internal) {
       auto nb_data_per_elem =
           this->getInternalDataPerElem(field_name_copy, kind);
       auto & internal_flat = this->flattenInternal(field_name_copy, kind);
 
       field = mesh.createElementalField<Real, dumpers::InternalMaterialField>(
           internal_flat, group_name, spatial_dimension, kind, nb_data_per_elem);
 
       std::unique_ptr<dumpers::ComputeFunctorInterface> func;
       if (field_name == "strain") {
         func = std::make_unique<dumpers::ComputeStrain<false>>(*this);
       } else if (field_name == "Von Mises stress") {
         func = std::make_unique<dumpers::ComputeVonMisesStress>(*this);
       } else if (field_name == "Green strain") {
         func = std::make_unique<dumpers::ComputeStrain<true>>(*this);
       } else if (field_name == "principal strain") {
         func = std::make_unique<dumpers::ComputePrincipalStrain<false>>(*this);
       } else if (field_name == "principal Green strain") {
         func = std::make_unique<dumpers::ComputePrincipalStrain<true>>(*this);
       }
 
       if (func) {
         field = dumpers::FieldComputeProxy::createFieldCompute(field,
                                                                std::move(func));
       }
       // treat the paddings
       if (padding_flag) {
         if (field_name == "stress") {
           if (spatial_dimension == 2) {
             auto foo = std::make_unique<dumpers::StressPadder<2>>(*this);
             field = dumpers::FieldComputeProxy::createFieldCompute(
                 field, std::move(foo));
           }
         } else if (field_name == "strain" || field_name == "Green strain") {
           if (spatial_dimension == 2) {
             auto foo = std::make_unique<dumpers::StrainPadder<2>>(*this);
             field = dumpers::FieldComputeProxy::createFieldCompute(
                 field, std::move(foo));
           }
         }
       }
 
       // homogenize the field
       auto foo = dumpers::HomogenizerProxy::createHomogenizer(*field);
 
       field =
           dumpers::FieldComputeProxy::createFieldCompute(field, std::move(foo));
     }
   }
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 SolidMechanicsModel::createNodalFieldReal(const std::string & field_name,
                                           const std::string & group_name,
                                           bool padding_flag) {
 
   std::map<std::string, Array<Real> *> real_nodal_fields;
   real_nodal_fields["displacement"] = this->displacement.get();
   real_nodal_fields["mass"] = this->mass.get();
   real_nodal_fields["velocity"] = this->velocity.get();
   real_nodal_fields["acceleration"] = this->acceleration.get();
   real_nodal_fields["external_force"] = this->external_force.get();
   real_nodal_fields["internal_force"] = this->internal_force.get();
   real_nodal_fields["increment"] = this->displacement_increment.get();
 
   if (field_name == "force") {
     AKANTU_EXCEPTION("The 'force' field has been renamed in 'external_force'");
   } else if (field_name == "residual") {
     AKANTU_EXCEPTION(
         "The 'residual' field has been replaced by 'internal_force'");
   }
 
   std::shared_ptr<dumpers::Field> field;
   if (padding_flag) {
     field = this->mesh.createNodalField(real_nodal_fields[field_name],
                                         group_name, 3);
   } else {
     field =
         this->mesh.createNodalField(real_nodal_fields[field_name], group_name);
   }
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field> SolidMechanicsModel::createNodalFieldBool(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs.get();
 
   std::shared_ptr<dumpers::Field> field;
   field = mesh.createNodalField(uint_nodal_fields[field_name], group_name);
   return field;
 }
-/* -------------------------------------------------------------------------- */
-#else
-/* -------------------------------------------------------------------------- */
-std::shared_ptr<dumpers::Field> SolidMechanicsModel::createElementalField(
-    const std::string &, const std::string &, bool, const UInt &, ElementKind) {
-  return nullptr;
-}
-/* --------------------------------------------------------------------------
- */
-std::shaed_ptr<dumpers::Field>
-SolidMechanicsModel::createNodalFieldReal(const std::string &,
-                                          const std::string &, bool) {
-  return nullptr;
-}
-
-/* --------------------------------------------------------------------------
- */
-std::shared_ptr<dumpers::Field>
-SolidMechanicsModel::createNodalFieldBool(const std::string &,
-                                          const std::string &, bool) {
-  return nullptr;
-}
 
-#endif
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::dump(const std::string & dumper_name) {
   this->onDump();
   EventManager::sendEvent(SolidMechanicsModelEvent::BeforeDumpEvent());
   mesh.dump(dumper_name);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::dump(const std::string & dumper_name, UInt step) {
   this->onDump();
   EventManager::sendEvent(SolidMechanicsModelEvent::BeforeDumpEvent());
   mesh.dump(dumper_name, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::dump(const std::string & dumper_name, Real time,
                                UInt step) {
   this->onDump();
   EventManager::sendEvent(SolidMechanicsModelEvent::BeforeDumpEvent());
   mesh.dump(dumper_name, time, step);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::dump() {
   this->onDump();
   EventManager::sendEvent(SolidMechanicsModelEvent::BeforeDumpEvent());
   mesh.dump();
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::dump(UInt step) {
   this->onDump();
   EventManager::sendEvent(SolidMechanicsModelEvent::BeforeDumpEvent());
   mesh.dump(step);
 }
 
 /* -------------------------------------------------------------------------- */
 void SolidMechanicsModel::dump(Real time, UInt step) {
   this->onDump();
   EventManager::sendEvent(SolidMechanicsModelEvent::BeforeDumpEvent());
   mesh.dump(time, step);
 }
 
 } // namespace akantu
diff --git a/src/model/structural_mechanics/structural_mechanics_model.cc b/src/model/structural_mechanics/structural_mechanics_model.cc
index 6419ff3b7..46b07b5e7 100644
--- a/src/model/structural_mechanics/structural_mechanics_model.cc
+++ b/src/model/structural_mechanics/structural_mechanics_model.cc
@@ -1,626 +1,620 @@
 /**
  * @file   structural_mechanics_model.cc
  *
  * @author Fabian Barras <fabian.barras@epfl.ch>
  * @author Lucas Frerot <lucas.frerot@epfl.ch>
  * @author Sébastien Hartmann <sebastien.hartmann@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  * @author Damien Spielmann <damien.spielmann@epfl.ch>
  *
  * @date creation: Fri Jul 15 2011
  * @date last modification: Mon Mar 15 2021
  *
  * @brief  Model implementation for Structural Mechanics elements
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "structural_mechanics_model.hh"
 #include "dof_manager.hh"
 #include "integrator_gauss.hh"
 #include "mesh.hh"
 #include "shape_structural.hh"
 #include "sparse_matrix.hh"
 #include "time_step_solver.hh"
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 #include "dumpable_inline_impl.hh"
 #include "dumper_elemental_field.hh"
 #include "dumper_internal_material_field.hh"
 #include "dumper_iohelper_paraview.hh"
 #include "group_manager_inline_impl.hh"
-#endif
 /* -------------------------------------------------------------------------- */
 #include "structural_element_bernoulli_beam_2.hh"
 #include "structural_element_bernoulli_beam_3.hh"
 #include "structural_element_kirchhoff_shell.hh"
 /* -------------------------------------------------------------------------- */
 //#include "structural_mechanics_model_inline_impl.hh"
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 inline UInt StructuralMechanicsModel::getNbDegreeOfFreedom(ElementType type) {
   UInt ndof = 0;
 #define GET_(type) ndof = ElementClass<type>::getNbDegreeOfFreedom()
   AKANTU_BOOST_KIND_ELEMENT_SWITCH(GET_, _ek_structural);
 #undef GET_
 
   return ndof;
 }
 
 /* -------------------------------------------------------------------------- */
 StructuralMechanicsModel::StructuralMechanicsModel(Mesh & mesh, UInt dim,
                                                    const ID & id)
     : Model(mesh, ModelType::_structural_mechanics_model, dim, id), f_m2a(1.0),
       stress("stress", id), element_material("element_material", id),
       set_ID("beam sets", id) {
   AKANTU_DEBUG_IN();
 
   registerFEEngineObject<MyFEEngineType>("StructuralMechanicsFEEngine", mesh,
                                          spatial_dimension);
 
   if (spatial_dimension == 2) {
     nb_degree_of_freedom = 3;
   } else if (spatial_dimension == 3) {
     nb_degree_of_freedom = 6;
   } else {
     AKANTU_TO_IMPLEMENT();
   }
 
-#ifdef AKANTU_USE_IOHELPER
   this->mesh.registerDumper<DumperParaview>("structural_mechanics_model", id,
                                             true);
-#endif
   this->mesh.addDumpMesh(mesh, spatial_dimension, _not_ghost, _ek_structural);
 
   this->initDOFManager();
 
   this->dumper_default_element_kind = _ek_structural;
 
   mesh.getElementalData<Real>("extra_normal")
       .initialize(mesh, _element_kind = _ek_structural,
                   _nb_component = spatial_dimension, _with_nb_element = true,
                   _default_value = 0.);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 StructuralMechanicsModel::~StructuralMechanicsModel() = default;
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initFullImpl(const ModelOptions & options) {
   Model::initFullImpl(options);
 
   // Initializing stresses
   ElementTypeMap<UInt> stress_components;
 
   /// TODO this is ugly af, maybe add a function to FEEngine
   for (auto && type : mesh.elementTypes(_spatial_dimension = _all_dimensions,
                       _element_kind = _ek_structural)) {
     UInt nb_components = 0;
 
 // Getting number of components for each element type
 #define GET_(type) nb_components = ElementClass<type>::getNbStressComponents()
     AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(GET_);
 #undef GET_
 
     stress_components(nb_components, type);
   }
 
   stress.initialize(
       getFEEngine(), _spatial_dimension = _all_dimensions,
       _element_kind = _ek_structural,
       _nb_component = [&stress_components](ElementType type,
                                            GhostType /*unused*/) -> UInt {
         return stress_components(type);
       });
 }
 
 /* -------------------------------------------------------------------------- */
 
 void StructuralMechanicsModel::initFEEngineBoundary() {
   /// TODO: this function should not be reimplemented
   /// we're just avoiding a call to Model::initFEEngineBoundary()
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::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
 }
 
 /* -------------------------------------------------------------------------- */
 /* Initialisation                                                             */
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initSolver(
     TimeStepSolverType time_step_solver_type, NonLinearSolverType /*unused*/) {
   AKANTU_DEBUG_IN();
 
   this->allocNodalField(displacement_rotation, nb_degree_of_freedom,
                         "displacement");
   this->allocNodalField(external_force, nb_degree_of_freedom, "external_force");
   this->allocNodalField(internal_force, nb_degree_of_freedom, "internal_force");
   this->allocNodalField(blocked_dofs, nb_degree_of_freedom, "blocked_dofs");
 
   auto & dof_manager = this->getDOFManager();
 
   if (not dof_manager.hasDOFs("displacement")) {
     dof_manager.registerDOFs("displacement", *displacement_rotation,
                              _dst_nodal);
     dof_manager.registerBlockedDOFs("displacement", *this->blocked_dofs);
   }
 
   if (time_step_solver_type == TimeStepSolverType::_dynamic ||
       time_step_solver_type == TimeStepSolverType::_dynamic_lumped) {
     this->allocNodalField(velocity, nb_degree_of_freedom, "velocity");
     this->allocNodalField(acceleration, nb_degree_of_freedom, "acceleration");
 
     if (!dof_manager.hasDOFsDerivatives("displacement", 1)) {
       dof_manager.registerDOFsDerivative("displacement", 1, *this->velocity);
       dof_manager.registerDOFsDerivative("displacement", 2,
                                          *this->acceleration);
     }
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::initModel() {
   element_material.initialize(mesh, _element_kind = _ek_structural,
                               _default_value = 0, _with_nb_element = true);
 
   getFEEngine().initShapeFunctions(_not_ghost);
   getFEEngine().initShapeFunctions(_ghost);
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::assembleStiffnessMatrix() {
   AKANTU_DEBUG_IN();
 
   if (not need_to_reassemble_stiffness) {
     return;
   }
 
   if (not getDOFManager().hasMatrix("K")) {
     getDOFManager().getNewMatrix("K", getMatrixType("K"));
   }
 
   this->getDOFManager().zeroMatrix("K");
 
   for (const auto & type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_structural)) {
 #define ASSEMBLE_STIFFNESS_MATRIX(type) assembleStiffnessMatrix<type>();
 
     AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(ASSEMBLE_STIFFNESS_MATRIX);
 #undef ASSEMBLE_STIFFNESS_MATRIX
   }
 
   need_to_reassemble_stiffness = false;
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::computeStresses() {
   AKANTU_DEBUG_IN();
 
   for (const auto & type :
        mesh.elementTypes(spatial_dimension, _not_ghost, _ek_structural)) {
 #define COMPUTE_STRESS_ON_QUAD(type) computeStressOnQuad<type>();
 
     AKANTU_BOOST_STRUCTURAL_ELEMENT_SWITCH(COMPUTE_STRESS_ON_QUAD);
 #undef COMPUTE_STRESS_ON_QUAD
   }
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field> StructuralMechanicsModel::createNodalFieldBool(
     const std::string & field_name, const std::string & group_name,
     __attribute__((unused)) bool padding_flag) {
 
   std::map<std::string, Array<bool> *> uint_nodal_fields;
   uint_nodal_fields["blocked_dofs"] = blocked_dofs.get();
 
   return mesh.createNodalField(uint_nodal_fields[field_name], group_name);
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field>
 StructuralMechanicsModel::createNodalFieldReal(const std::string & field_name,
                                                const std::string & group_name,
                                                bool padding_flag) {
 
   UInt n;
   if (spatial_dimension == 2) {
     n = 2;
   } else {
     n = 3;
   }
 
   UInt padding_size = 0;
   if (padding_flag) {
     padding_size = 3;
   }
 
   if (field_name == "displacement") {
     return mesh.createStridedNodalField(displacement_rotation.get(), group_name,
                                         n, 0, padding_size);
   }
 
   if (field_name == "velocity") {
     return mesh.createStridedNodalField(velocity.get(), group_name, n, 0,
                                         padding_size);
   }
 
   if (field_name == "acceleration") {
     return mesh.createStridedNodalField(acceleration.get(), group_name, n, 0,
                                         padding_size);
   }
 
   if (field_name == "rotation") {
     return mesh.createStridedNodalField(displacement_rotation.get(), group_name,
                                         nb_degree_of_freedom - n, n,
                                         padding_size);
   }
 
   if (field_name == "force") {
     return mesh.createStridedNodalField(external_force.get(), group_name, n, 0,
                                         padding_size);
   }
   if (field_name == "external_force") {
     return mesh.createStridedNodalField(external_force.get(), group_name, n, 0,
                                         padding_size);
   }
 
   if (field_name == "momentum") {
     return mesh.createStridedNodalField(external_force.get(), group_name,
                                         nb_degree_of_freedom - n, n,
                                         padding_size);
   }
 
   if (field_name == "internal_force") {
     return mesh.createStridedNodalField(internal_force.get(), group_name, n, 0,
                                         padding_size);
   }
 
   if (field_name == "internal_momentum") {
     return mesh.createStridedNodalField(internal_force.get(), group_name,
                                         nb_degree_of_freedom - n, n,
                                         padding_size);
   }
 
   return nullptr;
 }
 
 /* -------------------------------------------------------------------------- */
 std::shared_ptr<dumpers::Field> StructuralMechanicsModel::createElementalField(
     const std::string & field_name, const std::string & group_name,
     bool /*unused*/, UInt spatial_dimension, ElementKind kind) {
 
   std::shared_ptr<dumpers::Field> field;
 
   if (field_name == "element_index_by_material") {
     field = mesh.createElementalField<UInt, Vector, dumpers::ElementalField>(
         field_name, group_name, spatial_dimension, kind);
   }
   if (field_name == "stress") {
     ElementTypeMap<UInt> nb_data_per_elem = this->mesh.getNbDataPerElem(stress);
 
     field = mesh.createElementalField<Real, dumpers::InternalMaterialField>(
         stress, group_name, this->spatial_dimension, kind, nb_data_per_elem);
   }
 
   return field;
 }
 
 /* -------------------------------------------------------------------------- */
 /* Virtual methods from SolverCallback */
 /* -------------------------------------------------------------------------- */
 /// get the type of matrix needed
 MatrixType StructuralMechanicsModel::getMatrixType(const ID & /*id*/) const {
   return _symmetric;
 }
 
 /// callback to assemble a Matrix
 void StructuralMechanicsModel::assembleMatrix(const ID & id) {
   if (id == "K") {
     assembleStiffnessMatrix();
   } else if (id == "M") {
     assembleMassMatrix();
   }
 }
 
 /// callback to assemble a lumped Matrix
 void StructuralMechanicsModel::assembleLumpedMatrix(const ID & /*id*/) {}
 
 /// callback to assemble the residual StructuralMechanicsModel::(rhs)
 void StructuralMechanicsModel::assembleResidual() {
   AKANTU_DEBUG_IN();
 
   auto & dof_manager = getDOFManager();
 
   assembleInternalForce();
 
   dof_manager.assembleToResidual("displacement", *external_force, 1);
   dof_manager.assembleToResidual("displacement", *internal_force, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::assembleResidual(const ID & residual_part) {
   AKANTU_DEBUG_IN();
 
   if ("external" == residual_part) {
     this->getDOFManager().assembleToResidual("displacement",
                                              *this->external_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   if ("internal" == residual_part) {
     this->assembleInternalForce();
     this->getDOFManager().assembleToResidual("displacement",
                                              *this->internal_force, 1);
     AKANTU_DEBUG_OUT();
     return;
   }
 
   AKANTU_CUSTOM_EXCEPTION(
       debug::SolverCallbackResidualPartUnknown(residual_part));
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* Virtual methods from Model                                                 */
 /* -------------------------------------------------------------------------- */
 /// get some default values for derived classes
 std::tuple<ID, TimeStepSolverType>
 StructuralMechanicsModel::getDefaultSolverID(const AnalysisMethod & method) {
   switch (method) {
   case _static: {
     return std::make_tuple("static", TimeStepSolverType::_static);
   }
   case _implicit_dynamic: {
     return std::make_tuple("implicit", TimeStepSolverType::_dynamic);
   }
   default:
     return std::make_tuple("unknown", TimeStepSolverType::_not_defined);
   }
 }
 
 /* ------------------------------------------------------------------------ */
 ModelSolverOptions StructuralMechanicsModel::getDefaultSolverOptions(
     const TimeStepSolverType & type) const {
   ModelSolverOptions options;
 
   switch (type) {
   case TimeStepSolverType::_static: {
     options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_pseudo_time;
     options.solution_type["displacement"] = IntegrationScheme::_not_defined;
     break;
   }
   case TimeStepSolverType::_dynamic: {
     options.non_linear_solver_type = NonLinearSolverType::_newton_raphson;
     options.integration_scheme_type["displacement"] =
         IntegrationSchemeType::_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 StructuralMechanicsModel::assembleInternalForce() {
   internal_force->zero();
   computeStresses();
 
   for (auto type : mesh.elementTypes(_spatial_dimension = _all_dimensions,
                    _element_kind = _ek_structural)) {
     assembleInternalForce(type, _not_ghost);
     // assembleInternalForce(type, _ghost);
   }
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::assembleInternalForce(ElementType type,
                                                      GhostType gt) {
   auto & fem = getFEEngine();
   auto & sigma = stress(type, gt);
   auto ndof = getNbDegreeOfFreedom(type);
   auto nb_nodes = mesh.getNbNodesPerElement(type);
   auto ndof_per_elem = ndof * nb_nodes;
 
   Array<Real> BtSigma(fem.getNbIntegrationPoints(type) *
                           mesh.getNbElement(type),
                       ndof_per_elem, "BtSigma");
   fem.computeBtD(sigma, BtSigma, type, gt);
 
   Array<Real> intBtSigma(0, ndof_per_elem, "intBtSigma");
   fem.integrate(BtSigma, intBtSigma, ndof_per_elem, type, gt);
 
   getDOFManager().assembleElementalArrayLocalArray(intBtSigma, *internal_force,
                                                    type, gt, -1.);
 }
 
 /* -------------------------------------------------------------------------- */
 Real StructuralMechanicsModel::getKineticEnergy() {
   if (not this->getDOFManager().hasMatrix("M")) {
     return 0.;
   }
 
   Real ekin = 0.;
   UInt nb_nodes = mesh.getNbNodes();
 
   Array<Real> Mv(nb_nodes, nb_degree_of_freedom);
   this->getDOFManager().assembleMatMulVectToArray("displacement", "M",
                                                   *this->velocity, Mv);
 
   for (auto && data : zip(arange(nb_nodes), make_view(Mv, nb_degree_of_freedom),
                           make_view(*this->velocity, nb_degree_of_freedom))) {
     ekin += std::get<2>(data).dot(std::get<1>(data)) *
             static_cast<Real>(mesh.isLocalOrMasterNode(std::get<0>(data)));
   }
 
   mesh.getCommunicator().allReduce(ekin, SynchronizerOperation::_sum);
 
   return ekin / 2.;
 }
 
 /* -------------------------------------------------------------------------- */
 Real StructuralMechanicsModel::getPotentialEnergy() {
   Real epot = 0.;
   UInt nb_nodes = mesh.getNbNodes();
 
   Array<Real> Ku(nb_nodes, nb_degree_of_freedom);
   this->getDOFManager().assembleMatMulVectToArray(
       "displacement", "K", *this->displacement_rotation, Ku);
 
   for (auto && data :
        zip(arange(nb_nodes), make_view(Ku, nb_degree_of_freedom),
            make_view(*this->displacement_rotation, nb_degree_of_freedom))) {
     epot += std::get<2>(data).dot(std::get<1>(data)) *
             static_cast<Real>(mesh.isLocalOrMasterNode(std::get<0>(data)));
   }
 
   mesh.getCommunicator().allReduce(epot, SynchronizerOperation::_sum);
 
   return epot / 2.;
 }
 
 /* -------------------------------------------------------------------------- */
 Real StructuralMechanicsModel::getEnergy(const ID & energy) {
   if (energy == "kinetic") {
     return getKineticEnergy();
   }
 
   if (energy == "potential") {
     return getPotentialEnergy();
   }
 
   return 0;
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::computeForcesByLocalTractionArray(
     const Array<Real> & tractions, ElementType type) {
   AKANTU_DEBUG_IN();
 
   auto nb_element = getFEEngine().getMesh().getNbElement(type);
   auto nb_nodes_per_element =
       getFEEngine().getMesh().getNbNodesPerElement(type);
   auto nb_quad = getFEEngine().getNbIntegrationPoints(type);
 
   // check dimension match
   AKANTU_DEBUG_ASSERT(
       Mesh::getSpatialDimension(type) == getFEEngine().getElementDimension(),
       "element type dimension does not match the dimension of boundaries : "
           << getFEEngine().getElementDimension()
           << " != " << Mesh::getSpatialDimension(type));
 
   // check size of the vector
   AKANTU_DEBUG_ASSERT(
       tractions.size() == nb_quad * nb_element,
       "the size of the vector should be the total number of quadrature points");
 
   // check number of components
   AKANTU_DEBUG_ASSERT(tractions.getNbComponent() == nb_degree_of_freedom,
                       "the number of components should be the spatial "
                       "dimension of the problem");
 
   Array<Real> Ntbs(nb_element * nb_quad,
                    nb_degree_of_freedom * nb_nodes_per_element);
 
   auto & fem = getFEEngine();
   fem.computeNtb(tractions, Ntbs, type);
 
   // allocate the vector that will contain the integrated values
   auto name = id + std::to_string(type) + ":integral_boundary";
   Array<Real> int_funct(nb_element, nb_degree_of_freedom * nb_nodes_per_element,
                         name);
 
   // do the integration
   getFEEngine().integrate(Ntbs, int_funct,
                           nb_degree_of_freedom * nb_nodes_per_element, type);
 
   // assemble the result into force vector
   getDOFManager().assembleElementalArrayLocalArray(int_funct, *external_force,
                                                    type, _not_ghost, 1);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::computeForcesByGlobalTractionArray(
     const Array<Real> & traction_global, ElementType type) {
   AKANTU_DEBUG_IN();
 
   UInt nb_element = mesh.getNbElement(type);
   UInt nb_quad = getFEEngine().getNbIntegrationPoints(type);
 
   Array<Real> traction_local(nb_element * nb_quad, nb_degree_of_freedom,
                              id + ":structuralmechanics:imposed_linear_load");
 
   auto R_it = getFEEngineClass<MyFEEngineType>()
                   .getShapeFunctions()
                   .getRotations(type)
                   .begin(nb_degree_of_freedom, nb_degree_of_freedom);
 
   auto Te_it = traction_global.begin(nb_degree_of_freedom);
   auto te_it = traction_local.begin(nb_degree_of_freedom);
 
   for (UInt e = 0; e < nb_element; ++e, ++R_it) {
     for (UInt q = 0; q < nb_quad; ++q, ++Te_it, ++te_it) {
       // turn the traction in the local referential
       te_it->template mul<false>(*R_it, *Te_it);
     }
   }
 
   computeForcesByLocalTractionArray(traction_local, type);
 
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 void StructuralMechanicsModel::afterSolveStep(bool converged) {
   if (converged) {
     assembleInternalForce();
   }
 }
 
 } // namespace akantu
diff --git a/test/ci/debian:testing/Dockerfile b/test/ci/debian:testing/Dockerfile
index 13e3e7116..1d1a948b7 100644
--- a/test/ci/debian:testing/Dockerfile
+++ b/test/ci/debian:testing/Dockerfile
@@ -1,37 +1,38 @@
 FROM debian:testing
 MAINTAINER Nicolas Richart <nicolas.richart@epfl.ch>
 
 # library dependencies
 RUN apt-get -qq update && apt-get -qq -y install \
     g++ gfortran clang cmake \
     openmpi-bin libmumps-dev libscotch-dev \
     libboost-dev libopenblas-dev \
     python3 python3-dev python3-numpy python3-scipy python3-mpi4py \
     && rm -rf /var/lib/apt/lists/*
 
 # for documentation
 RUN apt-get -qq update && apt-get -qq -y install \
     python3-sphinx \
     python3-sphinxcontrib.bibtex \
     python3-sphinx-rtd-theme \
     python3-breathe \
     python3-git python3-jinja2 \
     doxygen graphviz \
     && rm -rf /var/lib/apt/lists/*
 
 # for ci
 RUN apt-get -qq update && apt-get -qq -y install \
     gmsh python3-pytest python3-click python3-termcolor \
     ccache clang-format python3-flake8 python3-pip clang-tidy \
     curl git xsltproc jq \
     gcovr llvm binutils \
+    ninja-build \
     && rm -rf /var/lib/apt/lists/*
 
 RUN pip3 install warning_parser
 
 COPY .openmpi /root/.openmpi
 
 # for debug
 RUN apt-get -qq update && apt-get -qq -y install \
     gdb valgrind \
     && rm -rf /var/lib/apt/lists/*
diff --git a/test/ci/includes_for_ci/aka_config.hh b/test/ci/includes_for_ci/aka_config.hh
index a734453da..2c1e484ca 100644
--- a/test/ci/includes_for_ci/aka_config.hh
+++ b/test/ci/includes_for_ci/aka_config.hh
@@ -1,99 +1,98 @@
 /**
  * @file   aka_config.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Feb 08 2021
  * @date last modification:  Mon Feb 08 2021
  *
  * @brief  Compilation time configuration of Akantu
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #ifndef AKANTU_AKA_CONFIG_HH_
 #define AKANTU_AKA_CONFIG_HH_
 
 #define AKANTU_VERSION_MAJOR 4
 #define AKANTU_VERSION_MINOR 0
 #define AKANTU_VERSION_PATCH 0
 #define AKANTU_VERSION                                                         \
   (AKANTU_VERSION_MAJOR * 10000 + AKANTU_VERSION_MINOR * 100 +                 \
    AKANTU_VERSION_PATCH)
 
 namespace akantu {
 using Real = double;
 using Int = int;
 using UInt = unsigned int;
 } // namespace akantu
 
 #define AKANTU_INTEGER_SIZE 4
 #define AKANTU_FLOAT_SIZE 8
 
 /* #undef AKANTU_HAS_STRDUP */
 
 /* #undef AKANTU_USE_BLAS */
 #define AKANTU_USE_LAPACK
 
 #define AKANTU_PARALLEL
 #define AKANTU_USE_MPI
 
 #define AKANTU_USE_SCOTCH
 /* #undef AKANTU_USE_PTSCOTCH */
 /* #undef AKANTU_SCOTCH_NO_EXTERN */
 
 #define AKANTU_IMPLICIT
 #define AKANTU_USE_MUMPS
 /* #undef AKANTU_USE_PETSC */
 
-#define AKANTU_USE_IOHELPER
 /* #undef AKANTU_USE_QVIEW */
 /* #undef AKANTU_USE_BLACKDYNAMITE */
 
 #define AKANTU_USE_PYBIND11
 
 /* #undef AKANTU_USE_OBSOLETE_GETTIMEOFDAY */
 
 /* #undef AKANTU_EXTRA_MATERIALS */
 /* #undef AKANTU_STUDENTS_EXTRA_PACKAGE */
 #define AKANTU_DAMAGE_NON_LOCAL
 
 #define AKANTU_SOLID_MECHANICS
 #define AKANTU_STRUCTURAL_MECHANICS
 #define AKANTU_HEAT_TRANSFER
 #define AKANTU_PYTHON_INTERFACE
 
 #define AKANTU_COHESIVE_ELEMENT
 /* #undef AKANTU_PARALLEL_COHESIVE_ELEMENT */
 
 /* #undef AKANTU_IGFEM */
 
 /* #undef AKANTU_USE_CGAL */
 /* #undef AKANTU_EMBEDDED */
 
 // Debug tools
 /* #undef AKANTU_NDEBUG */
 /* #undef AKANTU_DEBUG_TOOLS */
 #define READLINK_COMMAND / bin / readlink
 #define ADDR2LINE_COMMAND / usr / bin / addr2line
 
 #endif /* AKANTU_AKA_CONFIG_HH_ */
diff --git a/test/ci/make-wheels.sh b/test/ci/make-wheels.sh
new file mode 100755
index 000000000..e252d6bd5
--- /dev/null
+++ b/test/ci/make-wheels.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+set +x
+
+export PLAT=manylinux2010_x86_64
+
+source /etc/profile
+
+function repair_wheel {
+  wheel="$1"
+  if ! auditwheel show "$wheel"; then
+    echo "Skipping non-platform wheel $wheel"
+  else
+    auditwheel repair "$wheel" --plat "$PLAT"
+  fi
+}
+
+# Compile wheels
+for PYBIN in /opt/python/cp3*/bin; do
+  ccache --zero-stats
+  echo "${PYBIN}/pip" wheel . --no-deps -w dist/
+  "${PYBIN}/pip" wheel . --no-deps -w dist/
+  ccache --show-stats
+done
+
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${CI_AKANTU_INSTALL_PREFIX}/lib64
+
+# Bundle external shared libraries into the wheels
+for whl in dist/*.whl; do
+  echo repair_wheel "$whl"
+  repair_wheel "$whl"
+done
diff --git a/test/ci/manylinux/Dockerfile b/test/ci/manylinux/Dockerfile
deleted file mode 100644
index 698c2059f..000000000
--- a/test/ci/manylinux/Dockerfile
+++ /dev/null
@@ -1,15 +0,0 @@
-FROM quay.io/pypa/manylinux2010_x86_64
-MAINTAINER Guillaume Anciaux <guillaume.anciaux@epfl.ch>
-
-RUN git clone https://github.com/spack/spack.git
-RUN yum install -y xz
-RUN mkdir -p /root/.spack/linux/
-COPY compilers.yaml /root/.spack/linux/
-RUN spack/bin/spack install perl
-RUN /spack/bin/spack install boost
-RUN /spack/bin/spack install cmake
-RUN /spack/bin/spack install openblas
-RUN /spack/bin/spack install mumps@5.2.0 ~mpi
-RUN /spack/bin/spack install akantu@master external_solvers=mumps ~mpi ^mumps@5.2.0~mpi
-RUN yum install -y environment-modules
-RUN git clone https://gitlab.com/akantu/pypi_akantu.git
diff --git a/test/ci/manylinux:2010_x86_64/Dockerfile b/test/ci/manylinux:2010_x86_64/Dockerfile
new file mode 100644
index 000000000..3fcd933ce
--- /dev/null
+++ b/test/ci/manylinux:2010_x86_64/Dockerfile
@@ -0,0 +1,76 @@
+FROM quay.io/pypa/manylinux2010_x86_64 as builder
+MAINTAINER Nicolas Richart <nicolas.richart@epfl.ch>
+
+ENV LANG en_US.UTF-8
+
+RUN yum install -y xz zlib-devel
+# What we want to install and how we want to install it
+# is specified in a manifest file (spack.yaml)
+RUN mkdir -p /softs/spack-environment
+COPY spack.yaml /softs/spack-environment
+
+RUN adduser -u 1000  -s /bin/false app
+RUN mkdir -p /softs && chown -R app:app /softs
+
+USER app
+
+RUN cd /softs && git clone https://github.com/spack/spack.git -b v0.16.3
+
+RUN cd /softs && git clone https://gitlab.com/epfl-lsms/spack-packages.git
+
+COPY packages.yaml /softs/spack/etc/spack
+COPY repos.yaml /softs/spack/etc/spack
+
+# Install the software, remove unnecessary deps
+RUN /opt/python/cp36-cp36m/bin/python /softs/spack/bin/spack -e /softs/spack-environment install && \
+    /opt/python/cp36-cp36m/bin/python /softs/spack/bin/spack gc -y
+
+# Strip all the binaries
+RUN find -L /softs/view/* -type f -exec readlink -f '{}' \; | \
+    xargs file -i | \
+    grep 'charset=binary' | \
+    grep 'x-executable\|x-archive\|x-sharedlib' | \
+    awk -F: '{print $1}' | xargs strip -s
+
+USER root
+
+# Modifications to the environment that are necessary to run
+RUN cd /softs/spack-environment && \
+    /opt/python/cp36-cp36m/bin/python /softs/spack/bin/spack env activate --sh -d . >> /etc/profile.d/z10_spack_environment.sh
+
+# Bare OS image to run the installed executables
+FROM quay.io/pypa/manylinux2010_x86_64
+
+RUN yum install -y xz zlib-devel ccache
+
+RUN adduser -u 1000  -s /bin/false app
+
+COPY --from=builder /softs/spack /softs/spack
+COPY --from=builder /softs/spack-environment /softs/spack-environment
+COPY --from=builder /softs/software /softs/software
+COPY --from=builder /softs/view /softs/view
+COPY --from=builder /etc/profile.d/z10_spack_environment.sh /etc/profile.d/z10_spack_environment.sh
+
+RUN chown -R app:app /softs
+
+RUN mkdir -p /build && chown app:app /build
+
+ENV CROSS_ROOT /opt/rh/devtoolset-8/root/usr/bin
+ENV AS=${CROSS_ROOT}/as \
+    AR=${CROSS_ROOT}/ar \
+    CC=${CROSS_ROOT}/gcc \
+    CPP=${CROSS_ROOT}/cpp \
+    CXX=${CROSS_ROOT}/g++ \
+    LD=${CROSS_ROOT}/ld \
+    FC=${CROSS_ROOT}/gfortran \
+    CMAKE_PREFIX_PATH=/soft/view
+
+COPY install-pip.sh /build
+RUN /build/install-pip.sh
+
+COPY Toolchain.cmake ${CROSS_ROOT}/../lib/
+ENV CMAKE_TOOLCHAIN_FILE ${CROSS_ROOT}/../lib/Toolchain.cmake
+
+USER app
+
+#ENTRYPOINT ["/bin/bash", "--rcfile", "/etc/profile", "-l"]
diff --git a/test/ci/manylinux:2010_x86_64/Toolchain.cmake b/test/ci/manylinux:2010_x86_64/Toolchain.cmake
new file mode 100644
index 000000000..73776cac8
--- /dev/null
+++ b/test/ci/manylinux:2010_x86_64/Toolchain.cmake
@@ -0,0 +1,12 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_CROSSCOMPILING FALSE)
+set(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+
+set(MANYLINUX2010 TRUE)
+
+set(CMAKE_CXX_COMPILER_LAUNCHER /usr/bin/ccache)
+set(CMAKE_C_COMPILER /opt/rh/devtoolset-8/root/usr/bin/gcc)
+set(CMAKE_CXX_COMPILER /opt/rh/devtoolset-8/root/usr/bin/g++)
+set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})
+set(CMAKE_Fortran_COMPILER /opt/rh/devtoolset-8/root/usr/bin/gfortran)
diff --git a/test/ci/manylinux/compilers.yaml b/test/ci/manylinux:2010_x86_64/compilers.yaml
similarity index 100%
rename from test/ci/manylinux/compilers.yaml
rename to test/ci/manylinux:2010_x86_64/compilers.yaml
diff --git a/test/ci/manylinux:2010_x86_64/install-pip.sh b/test/ci/manylinux:2010_x86_64/install-pip.sh
new file mode 100755
index 000000000..9b8e9e1d1
--- /dev/null
+++ b/test/ci/manylinux:2010_x86_64/install-pip.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+for PIP in /opt/python/*/bin/pip; do
+  $PIP install --disable-pip-version-check --upgrade pip
+  $PIP install scikit-build==0.8.1
+done
diff --git a/test/ci/manylinux:2010_x86_64/packages.yaml b/test/ci/manylinux:2010_x86_64/packages.yaml
new file mode 100644
index 000000000..cbca89528
--- /dev/null
+++ b/test/ci/manylinux:2010_x86_64/packages.yaml
@@ -0,0 +1,84 @@
+packages:
+  all:
+    target: [x86_64]
+  gcc:
+    externals:
+    - spec: gcc@8.3.1 languages=c,c++,fortran
+      prefix: /opt/rh/devtoolset-8/root/usr
+      extra_attributes:
+        compilers:
+          c: /opt/rh/devtoolset-8/root/usr/bin/gcc
+          cxx: /opt/rh/devtoolset-8/root/usr/bin/x86_64-redhat-linux-g++
+          fortran: /opt/rh/devtoolset-8/root/usr/bin/gfortran
+  git:
+    externals:
+    - spec: git@2.30.0~tcltk
+      prefix: /usr/local
+  cmake:
+    externals:
+    - spec: cmake@2.8.12.2
+      prefix: /usr
+  tar:
+    externals:
+    - spec: tar@1.23
+      prefix: /
+  m4:
+    externals:
+    - spec: m4@1.4.13
+      prefix: /usr
+  diffutils:
+    externals:
+    - spec: diffutils@2.8.1
+      prefix: /usr
+  cpio:
+    externals:
+    - spec: cpio@2.10
+      prefix: /
+  gmake:
+    externals:
+    - spec: gmake@3.81
+      prefix: /usr
+  python:
+    externals:
+    - spec: python@2.6.6+bz2+ctypes+dbm~lzma+nis+pyexpat+readline+sqlite3+ssl~tix~tkinter+uuid+zlib
+      prefix: /usr
+  libtool:
+    externals:
+    - spec: libtool@2.4.6
+      prefix: /usr/local
+  findutils:
+    externals:
+    - spec: findutils@4.4.2
+      prefix: /usr
+  openssl:
+    externals:
+    - spec: openssl@1.0.1e-fips
+      prefix: /usr
+  bison:
+    externals:
+    - spec: bison@2.4.1
+      prefix: /usr
+  autoconf:
+    externals:
+    - spec: autoconf@2.69
+      prefix: /usr/local
+    - spec: autoconf@2.63
+      prefix: /usr
+  texinfo:
+    externals:
+    - spec: texinfo@4.13
+      prefix: /usr
+  automake:
+    externals:
+    - spec: automake@1.16.2
+      prefix: /usr/local
+    - spec: automake@1.11.1
+      prefix: /usr
+  bash:
+    externals:
+    - spec: bash@4.1.2
+      prefix: /
+  pkg-config:
+    externals:
+    - spec: pkg-config@0.23
+      prefix: /usr
diff --git a/test/ci/manylinux:2010_x86_64/repos.yaml b/test/ci/manylinux:2010_x86_64/repos.yaml
new file mode 100644
index 000000000..8d2c11f64
--- /dev/null
+++ b/test/ci/manylinux:2010_x86_64/repos.yaml
@@ -0,0 +1,2 @@
+repos:
+- /softs/spack-packages
diff --git a/test/ci/manylinux:2010_x86_64/spack.yaml b/test/ci/manylinux:2010_x86_64/spack.yaml
new file mode 100644
index 000000000..a4df41ea0
--- /dev/null
+++ b/test/ci/manylinux:2010_x86_64/spack.yaml
@@ -0,0 +1,33 @@
+spack:
+  compilers:
+  - compiler:
+      paths:
+        cc: /opt/rh/devtoolset-8/root/usr/bin/gcc
+        cxx: /opt/rh/devtoolset-8/root/usr/bin/g++
+        f77: /opt/rh/devtoolset-8/root/usr/bin/gfortran
+        fc: /opt/rh/devtoolset-8/root/usr/bin/gfortran
+      operating_system: centos6
+      target: x86_64
+      modules: []
+      environment:
+        set:
+          LD_LIBRARY_PATH: /usr/local/lib
+      extra_rpaths: []
+      flags: {}
+      spec: gcc@8.3.1
+
+  include:
+  - /softs/spack/etc/spack/packages.yaml
+    
+  config:
+    install_tree: /softs/software
+
+  specs:
+  - cmake@3.18.2 ~ncurses ~openssl
+  - zlib
+  - boost ~atomic ~chrono ~clanglibcpp ~container ~context ~coroutine ~date_time ~debug ~exception ~fiber ~filesystem ~graph ~icu~iostreams ~locale ~log ~math ~mpi ~multithreaded ~numpy ~pic ~program_options ~python ~random ~regex ~serialization ~shared ~signals ~singlethreaded ~system ~taggedlayout ~test ~thread ~timer ~wave
+  - openblas +pic
+  - mumps ~mpi ~complex ~float
+  concretization: together
+
+  view: /softs/view
diff --git a/test/ci/ubuntu:lts/Dockerfile b/test/ci/ubuntu:lts/Dockerfile
index 51f94b297..ed52389e3 100644
--- a/test/ci/ubuntu:lts/Dockerfile
+++ b/test/ci/ubuntu:lts/Dockerfile
@@ -1,31 +1,32 @@
 FROM ubuntu:xenial
 MAINTAINER Nicolas Richart <nicolas.richart@epfl.ch>
 
 ENV TZ=Europe/Zurich
 RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 
 # Install akantu dependencies
 RUN apt-get -qq update && apt-get -qq -y install \
     g++ gfortran  cmake \
     openmpi-bin libmumps-dev libscotch-dev \
     libboost-dev libopenblas-dev libcgal-dev \
     python3 python3-dev python3-numpy python3-scipy python3-pip \
     && rm -rf /var/lib/apt/lists/*
 
 RUN pip3 install mpi4py
 
 # Install test utilities
 RUN apt-get -qq update && apt-get -qq -y install \
     python3-yaml python3-pytest python3-termcolor python3-click \
     ccache  gmsh curl git xsltproc \
     gcovr binutils \
+    ninja-build \
     && rm -rf /var/lib/apt/lists/*
 
 RUN pip3 install warning_parser
 
 COPY .openmpi /root/.openmpi
 
 # for debug
 RUN apt-get -qq update && apt-get -qq -y install \
     gdb valgrind \
     && rm -rf /var/lib/apt/lists/*
diff --git a/test/test_gtest_main.cc b/test/test_gtest_main.cc
index f999cdd80..07a748c16 100644
--- a/test/test_gtest_main.cc
+++ b/test/test_gtest_main.cc
@@ -1,84 +1,73 @@
 /**
  * @file   test_gtest_main.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Thu Nov 09 2017
  * @date last modification:  Tue Dec 10 2019
  *
  * @brief  Main function for gtest tests
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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 "communicator.hh"
 /* -------------------------------------------------------------------------- */
 #include <gtest/gtest.h>
 #if defined(AKANTU_TEST_USE_PYBIND11)
 #include <pybind11/embed.h>
 namespace py = pybind11;
 #endif
 /* -------------------------------------------------------------------------- */
 
 namespace {
 class AkaEnvironment : public ::testing::Environment {
 public:
   AkaEnvironment(int & argc, char **& argv) : argc(argc), argv(argv) {}
   // Override this to define how to set up the environment.
-  void SetUp() override {
-    ::akantu::initialize(argc, argv);
-
-#if defined(AKANTU_USE_PYBIND11)
-// py::initialize_interpreter();
-#endif
-  }
+  void SetUp() override { ::akantu::initialize(argc, argv); }
   // Override this to define how to tear down the environment.
-  void TearDown() override {
-    ::akantu::finalize();
-#if defined(AKANTU_USE_PYBIND11)
-// py::finalize_interpreter();
-#endif
-  }
+  void TearDown() override { ::akantu::finalize(); }
 
 protected:
   int & argc;
   char **& argv;
 };
 } // namespace
 
 int main(int argc, char ** argv) {
 #if defined(AKANTU_TEST_USE_PYBIND11)
   py::scoped_interpreter guard{};
 #endif
 
   ::testing::InitGoogleTest(&argc, argv);
   ::testing::AddGlobalTestEnvironment(new AkaEnvironment(argc, argv));
 
   ::testing::TestEventListeners & listeners =
       ::testing::UnitTest::GetInstance()->listeners();
   if (::akantu::Communicator::getStaticCommunicator().whoAmI() != 0) {
     delete listeners.Release(listeners.default_result_printer());
   }
 
   return RUN_ALL_TESTS();
 }
diff --git a/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_mesh_data.cc b/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_mesh_data.cc
index c5eddb71a..c9a2e57b2 100644
--- a/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_mesh_data.cc
+++ b/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_mesh_data.cc
@@ -1,117 +1,115 @@
 /**
  * @file   test_mesh_partitionate_mesh_data.cc
  *
  * @author Dana Christen <dana.christen@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Fri Nov 02 2018
  *
  * @brief  test of manual partitioner
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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"
 #include "mesh_partition_mesh_data.hh"
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 #include "dumper_elemental_field.hh"
 #include "dumper_paraview.hh"
-#endif // AKANTU_USE_IOHELPER
 /* -------------------------------------------------------------------------- */
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt dim = 2;
   UInt nb_partitions = 8;
   akantu::Mesh mesh(dim);
   mesh.read("quad.msh");
 
   ElementTypeMapArray<UInt> partition;
   UInt nb_component = 1;
 
   GhostType gt = _not_ghost;
   for (auto & type : mesh.elementTypes(dim, gt)) {
     UInt nb_element = mesh.getNbElement(type, gt);
     partition.alloc(nb_element, nb_component, type, gt);
     Array<UInt> & type_partition_reference = partition(type, gt);
     for (UInt i(0); i < nb_element; ++i) {
       Vector<Real> barycenter(dim);
       Element element{type, i, gt};
       mesh.getBarycenter(element, barycenter);
 
       Real real_proc = barycenter[0] * nb_partitions;
       if (std::abs(real_proc - round(real_proc)) <
           10 * std::numeric_limits<Real>::epsilon()) {
         type_partition_reference(i) = round(real_proc);
       } else {
         std::cout << "*";
         type_partition_reference(i) = floor(real_proc);
       }
       std::cout << "Assigned proc " << type_partition_reference(i)
                 << " to elem " << i << " (type " << type
                 << ", barycenter x-coordinate " << barycenter[0] << ")"
                 << std::endl;
     }
   }
 
   akantu::MeshPartitionMeshData * partitioner =
       new akantu::MeshPartitionMeshData(mesh, dim);
   partitioner->setPartitionMapping(partition);
   partitioner->partitionate(nb_partitions);
 
   for (auto & type : mesh.elementTypes(dim, gt)) {
     UInt nb_element = mesh.getNbElement(type, gt);
     const Array<UInt> & type_partition_reference = partition(type, gt);
     const Array<UInt> & type_partition = partitioner->getPartitions()(type, gt);
     for (UInt i(0); i < nb_element; ++i) {
       if (not(type_partition(i) == type_partition_reference(i))) {
         std::cout << "Incorrect partitioning" << std::endl;
         return 1;
       }
     }
   }
 
 #ifdef DEBUG_TEST
   DumperParaview dumper("test-mesh-data-partition");
   dumpers::Field * field1 =
       new dumpers::ElementalField<UInt>(partitioner->getPartitions(), dim);
   dumpers::Field * field2 = new dumpers::ElementalField<UInt>(partition, dim);
   dumper.registerMesh(mesh, dim);
   dumper.registerField("partitions", field1);
   dumper.registerField("partitions_ref", field2);
   dumper.dump();
 #endif
 
   delete partitioner;
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_scotch.cc b/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_scotch.cc
index b2868f25f..82a95e473 100644
--- a/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_scotch.cc
+++ b/test/test_mesh_utils/test_mesh_partitionate/test_mesh_partitionate_scotch.cc
@@ -1,75 +1,71 @@
 /**
  * @file   test_mesh_partitionate_scotch.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Sep 12 2010
  * @date last modification: Fri Nov 02 2018
  *
  * @brief  test of internal facet extraction
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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"
 #include "mesh_partition_scotch.hh"
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 #include "dumper_elemental_field.hh"
 #include "dumper_iohelper_paraview.hh"
-#endif // AKANTU_USE_IOHELPER
 
 using namespace akantu;
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
   debug::setDebugLevel(akantu::dblDump);
 
   int dim = 2;
 
   Mesh mesh(dim);
   mesh.read("triangle.msh");
 
   MeshPartitionScotch partition(mesh, dim);
   partition.partitionate(8);
 
-#ifdef AKANTU_USE_IOHELPER
   DumperParaview dumper("test-scotch-partition");
   auto field = std::make_shared<dumpers::ElementalField<UInt>>(
       partition.getPartitions(), dim);
   dumper.registerMesh(mesh, dim);
   dumper.registerField("partitions", field);
   dumper.dump();
-#endif // AKANTU_USE_IOHELPER
 
   partition.reorder();
   mesh.write("triangle_reorder.msh");
 
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_extrinsic/test_cohesive_parallel_extrinsic_tetrahedron_displacement.cc b/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_extrinsic/test_cohesive_parallel_extrinsic_tetrahedron_displacement.cc
index 58c16d7dc..c163d337f 100644
--- a/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_extrinsic/test_cohesive_parallel_extrinsic_tetrahedron_displacement.cc
+++ b/test/test_model/test_solid_mechanics_model/test_cohesive/test_parallel_cohesive/test_cohesive_parallel_extrinsic/test_cohesive_parallel_extrinsic_tetrahedron_displacement.cc
@@ -1,405 +1,401 @@
 /**
  * @file   test_cohesive_parallel_extrinsic_tetrahedron_displacement.cc
  *
  * @author Marco Vocialta <marco.vocialta@epfl.ch>
  *
  * @date creation: Fri Oct 13 2017
  * @date last modification:  Wed Nov 08 2017
  *
  * @brief  Displacement test for 3D cohesive elements
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 #include "dumper_paraview.hh"
 #include "material_cohesive_linear.hh"
 #include "solid_mechanics_model_cohesive.hh"
 
-#ifdef AKANTU_USE_IOHELPER
-#include "dumper_paraview.hh"
-#endif
-
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 bool checkDisplacement(SolidMechanicsModelCohesive & model, ElementType type,
                        std::ofstream & error_output, UInt step,
                        bool barycenters);
 
 int main(int argc, char * argv[]) {
   initialize("material.dat", argc, argv);
 
   debug::setDebugLevel(dblWarning);
 
   const UInt max_steps = 500;
   Math::setTolerance(1.e-12);
 
   UInt spatial_dimension = 3;
   ElementType type = _tetrahedron_10;
 
   Mesh mesh(spatial_dimension);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   akantu::MeshPartition * partition = NULL;
   if (prank == 0) {
     // Read the mesh
     mesh.read("tetrahedron.msh");
 
     /// partition the mesh
     partition = new MeshPartitionScotch(mesh, spatial_dimension);
     //    debug::setDebugLevel(dblDump);
     partition->partitionate(psize);
     //    debug::setDebugLevel(dblWarning);
   }
 
   SolidMechanicsModelCohesive model(mesh);
 
   model.initParallel(partition, NULL, true);
 
   // debug::setDebugLevel(dblDump);
   // std::cout << mesh << std::endl;
   // debug::setDebugLevel(dblWarning);
 
   model.initFull(
       SolidMechanicsModelCohesiveOptions(_explicit_lumped_mass, true));
 
   /* ------------------------------------------------------------------------ */
   /* Facet part                                                               */
   /* ------------------------------------------------------------------------ */
 
   // Array<Real> limits(spatial_dimension, 2);
   // limits(0, 0) = -0.01;
   // limits(0, 1) = 0.01;
   // limits(1, 0) = -100;
   // limits(1, 1) = 100;
   // limits(2, 0) = -100;
   // limits(2, 1) = 100;
 
   // model.enableFacetsCheckOnArea(limits);
 
   /* ------------------------------------------------------------------------ */
   /* End of facet part                                                        */
   /* ------------------------------------------------------------------------ */
 
   // debug::setDebugLevel(dblDump);
   // std::cout << mesh_facets << std::endl;
   // debug::setDebugLevel(dblWarning);
 
   Real time_step = model.getStableTimeStep() * 0.1;
   model.setTimeStep(time_step);
   std::cout << "Time step: " << time_step << std::endl;
 
   model.assembleMassLumped();
 
   Array<Real> & position = mesh.getNodes();
   Array<Real> & velocity = model.getVelocity();
   Array<bool> & boundary = model.getBlockedDOFs();
   Array<Real> & displacement = model.getDisplacement();
   //  const Array<Real> & residual = model.getResidual();
 
   UInt nb_nodes = mesh.getNbNodes();
 
   /// boundary conditions
   for (UInt n = 0; n < nb_nodes; ++n) {
     if (position(n, 0) > 0.99 || position(n, 0) < -0.99) {
       for (UInt dim = 0; dim < spatial_dimension; ++dim) {
         boundary(n, dim) = true;
       }
     }
 
     if (position(n, 0) > 0.99 || position(n, 0) < -0.99) {
       for (UInt dim = 0; dim < spatial_dimension; ++dim) {
         boundary(n, dim) = true;
       }
     }
   }
 
   // #if defined (AKANTU_DEBUG_TOOLS)
   //   Vector<Real> facet_center(spatial_dimension);
   //   facet_center(0) =  0;
   //   facet_center(1) = -0.16666667;
   //   facet_center(2) =  0.5;
 
   //   debug::element_manager.setMesh(mesh);
   //   debug::element_manager.addModule(debug::_dm_material_cohesive);
   //   debug::element_manager.addModule(debug::_dm_debug_tools);
   //   //debug::element_manager.addModule(debug::_dm_integrator);
   // #endif
 
   /// initial conditions
   Real loading_rate = 1;
   Real disp_update = loading_rate * time_step;
   for (UInt n = 0; n < nb_nodes; ++n) {
     velocity(n, 0) = loading_rate * position(n, 0);
     velocity(n, 1) = loading_rate * position(n, 0);
   }
 
   model.synchronizeBoundaries();
   model.updateResidual();
 
   std::stringstream paraview_output;
   paraview_output << "extrinsic_parallel_tetrahedron_" << psize;
 
   model.setBaseName(paraview_output.str());
   model.addDumpFieldVector("displacement");
   model.addDumpFieldVector("velocity");
   model.addDumpFieldVector("acceleration");
   model.addDumpFieldVector("residual");
   model.addDumpFieldTensor("stress");
   model.addDumpFieldTensor("grad_u");
   model.addDumpField("partitions");
   //  model.getDumper().getDumper().setMode(iohelper::BASE64);
   model.dump();
 
   model.setBaseNameToDumper("cohesive elements",
                             paraview_output.str() + "_cohesive_elements");
   model.addDumpFieldVectorToDumper("cohesive elements", "displacement");
   model.addDumpFieldToDumper("cohesive elements", "damage");
   model.dump("cohesive elements");
 
   std::stringstream error_stream;
   error_stream << "error"
                << ".csv";
   std::ofstream error_output;
   error_output.open(error_stream.str().c_str());
   error_output << "# Step, Average, Max, Min" << std::endl;
 
   if (checkDisplacement(model, type, error_output, 0, true)) {
   }
 
   /// Main loop
   for (UInt s = 1; s <= max_steps; ++s) {
 
     /// update displacement on extreme nodes
     for (UInt n = 0; n < mesh.getNbNodes(); ++n) {
       if (position(n, 0) > 0.99 || position(n, 0) < -0.99) {
         displacement(n, 0) += disp_update * position(n, 0);
         displacement(n, 1) += disp_update * position(n, 0);
       }
     }
 
     model.checkCohesiveStress();
 
     model.solveStep();
 
     if (s % 100 == 0) {
       if (prank == 0)
         std::cout << "passing step " << s << "/" << max_steps << std::endl;
     }
   }
 
   model.dump();
   model.dump("cohesive elements");
 
   if (!checkDisplacement(model, type, error_output, max_steps, false)) {
     finalize();
     return EXIT_FAILURE;
   }
 
   finalize();
   return EXIT_SUCCESS;
 }
 
 bool checkDisplacement(SolidMechanicsModelCohesive & model, ElementType type,
                        std::ofstream & error_output, UInt step,
                        bool barycenters) {
 
   Mesh & mesh = model.getMesh();
   UInt spatial_dimension = mesh.getSpatialDimension();
   const Array<UInt> & connectivity = mesh.getConnectivity(type);
   const Array<Real> & displacement = model.getDisplacement();
   UInt nb_element = mesh.getNbElement(type);
   UInt nb_nodes_per_elem = Mesh::getNbNodesPerElement(type);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
 
   if (psize == 1) {
     std::stringstream displacement_file;
     displacement_file << "displacement/displacement_" << std::setfill('0')
                       << std::setw(6) << step;
     std::ofstream displacement_output;
     displacement_output.open(displacement_file.str().c_str());
 
     for (UInt el = 0; el < nb_element; ++el) {
       for (UInt n = 0; n < nb_nodes_per_elem; ++n) {
         UInt node = connectivity(el, n);
 
         for (UInt dim = 0; dim < spatial_dimension; ++dim) {
           displacement_output << std::setprecision(15)
                               << displacement(node, dim) << " ";
         }
         displacement_output << std::endl;
       }
     }
 
     displacement_output.close();
 
     if (barycenters) {
       std::stringstream barycenter_file;
       barycenter_file << "displacement/barycenters";
       std::ofstream barycenter_output;
       barycenter_output.open(barycenter_file.str().c_str());
 
       Element element(type, 0);
       Vector<Real> bary(spatial_dimension);
 
       for (UInt el = 0; el < nb_element; ++el) {
         element.element = el;
         mesh.getBarycenter(element, bary);
 
         for (UInt dim = 0; dim < spatial_dimension; ++dim) {
           barycenter_output << std::setprecision(15) << bary(dim) << " ";
         }
         barycenter_output << std::endl;
       }
 
       barycenter_output.close();
     }
   } else {
 
     if (barycenters)
       return true;
 
     /// read data
     std::stringstream displacement_file;
     displacement_file << "displacement/displacement_" << std::setfill('0')
                       << std::setw(6) << step;
     std::ifstream displacement_input;
     displacement_input.open(displacement_file.str().c_str());
 
     Array<Real> displacement_serial(0, spatial_dimension);
     Vector<Real> disp_tmp(spatial_dimension);
 
     while (displacement_input.good()) {
       for (UInt i = 0; i < spatial_dimension; ++i)
         displacement_input >> disp_tmp(i);
 
       displacement_serial.push_back(disp_tmp);
     }
 
     std::stringstream barycenter_file;
     barycenter_file << "displacement/barycenters";
     std::ifstream barycenter_input;
     barycenter_input.open(barycenter_file.str().c_str());
 
     Array<Real> barycenter_serial(0, spatial_dimension);
 
     while (barycenter_input.good()) {
       for (UInt dim = 0; dim < spatial_dimension; ++dim)
         barycenter_input >> disp_tmp(dim);
 
       barycenter_serial.push_back(disp_tmp);
     }
 
     Element element(type, 0);
     Vector<Real> bary(spatial_dimension);
 
     Array<Real>::iterator<Vector<Real>> it;
     Array<Real>::iterator<Vector<Real>> begin =
         barycenter_serial.begin(spatial_dimension);
     Array<Real>::iterator<Vector<Real>> end =
         barycenter_serial.end(spatial_dimension);
 
     Array<Real>::const_iterator<Vector<Real>> disp_it;
     Array<Real>::iterator<Vector<Real>> disp_serial_it;
 
     Vector<Real> difference(spatial_dimension);
     Array<Real> error;
 
     /// compute error
     for (UInt el = 0; el < nb_element; ++el) {
       element.element = el;
       mesh.getBarycenter(element, bary);
 
       /// find element
       for (it = begin; it != end; ++it) {
         UInt matched_dim = 0;
 
         while (matched_dim < spatial_dimension &&
                Math::are_float_equal(bary(matched_dim), (*it)(matched_dim)))
           ++matched_dim;
 
         if (matched_dim == spatial_dimension)
           break;
       }
 
       if (it == end) {
         std::cout << "Element barycenter not found!" << std::endl;
         return false;
       }
 
       UInt matched_el = it - begin;
 
       disp_serial_it = displacement_serial.begin(spatial_dimension) +
                        matched_el * nb_nodes_per_elem;
 
       for (UInt n = 0; n < nb_nodes_per_elem; ++n, ++disp_serial_it) {
         UInt node = connectivity(el, n);
         if (!mesh.isLocalOrMasterNode(node))
           continue;
 
         disp_it = displacement.begin(spatial_dimension) + node;
 
         difference = *disp_it;
         difference -= *disp_serial_it;
 
         error.push_back(difference.norm());
       }
     }
 
     /// compute average error
     Real average_error = std::accumulate(error.begin(), error.end(), 0.);
     comm.allReduce(&average_error, 1, _so_sum);
 
     UInt error_size = error.getSize();
     comm.allReduce(&error_size, 1, _so_sum);
 
     average_error /= error_size;
 
     /// compute maximum and minimum
     Real max_error = *std::max_element(error.begin(), error.end());
     comm.allReduce(&max_error, 1, _so_max);
 
     Real min_error = *std::min_element(error.begin(), error.end());
     comm.allReduce(&min_error, 1, _so_min);
 
     /// output data
     if (prank == 0) {
       error_output << step << ", " << average_error << ", " << max_error << ", "
                    << min_error << std::endl;
     }
 
     if (max_error > 1.e-9) {
       std::cout << "Displacement error is too big!" << std::endl;
       return false;
     }
   }
 
   return true;
 }
diff --git a/test/test_solver/test_sparse_matrix_profile_parallel.cc b/test/test_solver/test_sparse_matrix_profile_parallel.cc
index ff9cd2370..c15cedce0 100644
--- a/test/test_solver/test_sparse_matrix_profile_parallel.cc
+++ b/test/test_solver/test_sparse_matrix_profile_parallel.cc
@@ -1,114 +1,112 @@
 /**
  * @file   test_sparse_matrix_profile_parallel.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Nov 08 2017
  *
  * @brief  test the sparse matrix class in parallel
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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 "communicator.hh"
 #include "mesh.hh"
 #include "mesh_io_msh.hh"
 #include "mesh_partition_scotch.hh"
 #include "solver_mumps.hh"
 #include "sparse_matrix.hh"
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   akantu::initialize(argc, argv);
 
   int dim = 2;
-  //#ifdef AKANTU_USE_IOHELPER
   // akantu::ElementType type = akantu::_triangle_6;
-  //#endif //AKANTU_USE_IOHELPER
   akantu::Mesh mesh(dim);
 
   //  akantu::debug::setDebugLevel(akantu::dblDump);
 
   akantu::StaticCommunicator * comm =
       akantu::Communicator::getStaticCommunicator();
   akantu::Int psize = comm->getNbProc();
   akantu::Int prank = comm->whoAmI();
 
   akantu::UInt n = 0;
 
   /* ------------------------------------------------------------------------ */
   /* Parallel initialization                                                  */
   /* ------------------------------------------------------------------------ */
   akantu::Communicator * communicator;
   if (prank == 0) {
     akantu::MeshIOMSH mesh_io;
     mesh_io.read("triangle.msh", mesh);
     akantu::MeshPartition * partition =
         new akantu::MeshPartitionScotch(mesh, dim);
 
     //    partition->reorder();
     mesh_io.write("triangle_reorder.msh", mesh);
 
     n = mesh.getNbNodes();
 
     partition->partitionate(psize);
     communicator =
         akantu::Communicator::createCommunicatorDistributeMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         akantu::Communicator::createCommunicatorDistributeMesh(mesh, NULL);
   }
 
   std::cout << "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA "
             << mesh.getNbGlobalNodes() << std::endl;
 
   akantu::SparseMatrix sparse_matrix(mesh, akantu::_symmetric, 2, "mesh");
   sparse_matrix.buildProfile();
 
   akantu::Solver * solver = new akantu::SolverMumps(sparse_matrix);
 
   if (prank == 0) {
     for (akantu::UInt i = 0; i < n; ++i) {
       solver->getRHS().storage()[i] = 1.;
     }
   }
 
   akantu::debug::setDebugLevel(akantu::dblDump);
   solver->initialize();
 
   std::stringstream sstr;
   sstr << "profile_" << prank << ".mtx";
   sparse_matrix.saveProfile(sstr.str());
 
   akantu::finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_synchronizer/test_dof_synchronizer.cc b/test/test_synchronizer/test_dof_synchronizer.cc
index 773683e93..dd7d89890 100644
--- a/test/test_synchronizer/test_dof_synchronizer.cc
+++ b/test/test_synchronizer/test_dof_synchronizer.cc
@@ -1,148 +1,145 @@
 /**
  * @file   test_dof_synchronizer.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Wed Jan 15 2020
  *
  * @brief  Test the functionality of the DOFSynchronizer class
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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 "communicator.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "mesh_io.hh"
 #include "mesh_partition_scotch.hh"
 
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 #include "io_helper.hh"
-#endif // AKANTU_USE_IOHELPER
 
 /* -------------------------------------------------------------------------- */
 using namespace akantu;
 
 int main(int argc, char * argv[]) {
   const UInt spatial_dimension = 2;
 
   initialize(argc, argv);
 
   const auto & comm = akantu::Communicator::getStaticCommunicator();
   Int prank = comm.whoAmI();
 
   Mesh mesh(spatial_dimension);
 
   if (prank == 0)
     mesh.read("bar.msh");
   mesh.distribute();
 
   DOFManagerDefault dof_manager(mesh, "test_dof_manager");
 
   UInt nb_nodes = mesh.getNbNodes();
 
   /* ------------------------------------------------------------------------ */
   /* test the synchronization                                                 */
   /* ------------------------------------------------------------------------ */
   Array<Real> test_synchronize(nb_nodes, spatial_dimension, "Test vector");
   dof_manager.registerDOFs("test_synchronize", test_synchronize, _dst_nodal);
 
   auto & equation_number =
       dof_manager.getLocalEquationsNumbers("test_synchronize");
 
   DOFSynchronizer & dof_synchronizer = dof_manager.getSynchronizer();
 
   std::cout << "Synchronizing a dof vector" << std::endl;
 
   Array<Int> local_data_array(dof_manager.getLocalSystemSize(), 2);
   auto it_data = local_data_array.begin(2);
 
   for (UInt local_dof = 0; local_dof < dof_manager.getLocalSystemSize();
        ++local_dof) {
     UInt equ_number = equation_number(local_dof);
     Vector<Int> val;
     if (dof_manager.isLocalOrMasterDOF(equ_number)) {
       UInt global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
       val = {0, 1};
       val += global_dof * 2;
     } else {
       val = {-1, -1};
     }
 
     Vector<Int> data = it_data[local_dof];
     data = val;
   }
 
   dof_synchronizer.synchronizeArray(local_data_array);
 
   auto test_data = [&]() -> void {
     auto it_data = local_data_array.begin(2);
     for (UInt local_dof = 0; local_dof < dof_manager.getLocalSystemSize();
          ++local_dof) {
       UInt equ_number = equation_number(local_dof);
 
       Vector<Int> exp_val;
 
       UInt global_dof = dof_manager.localToGlobalEquationNumber(local_dof);
 
       if (dof_manager.isLocalOrMasterDOF(equ_number) ||
           dof_manager.isSlaveDOF(equ_number)) {
         exp_val = {0, 1};
         exp_val += global_dof * 2;
       } else {
         exp_val = {-1, -1};
       }
 
       Vector<Int> val = it_data[local_dof];
       if (exp_val != val) {
         std::cerr << "Failed !" << prank << " DOF: " << global_dof << " - l"
                   << local_dof << " value:" << val << " expected: " << exp_val
                   << std::endl;
         exit(1);
       }
     }
   };
 
   test_data();
 
   if (prank == 0) {
     Array<Int> test_gathered(dof_manager.getSystemSize(), 2);
     dof_synchronizer.gather(local_data_array, test_gathered);
 
     local_data_array.set(-1);
     dof_synchronizer.scatter(local_data_array, test_gathered);
   } else {
     dof_synchronizer.gather(local_data_array);
 
     local_data_array.set(-1);
     dof_synchronizer.scatter(local_data_array);
   }
 
   test_data();
 
   finalize();
 
   return 0;
 }
diff --git a/test/test_synchronizer/test_dof_synchronizer_communication.cc b/test/test_synchronizer/test_dof_synchronizer_communication.cc
index 7e6a3e0a5..3b9be2840 100644
--- a/test/test_synchronizer/test_dof_synchronizer_communication.cc
+++ b/test/test_synchronizer/test_dof_synchronizer_communication.cc
@@ -1,110 +1,107 @@
 /**
  * @file   test_dof_synchronizer_communication.cc
  *
  * @author Aurelia Isabel Cuba Ramos <aurelia.cubaramos@epfl.ch>
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Tue Dec 09 2014
  * @date last modification:  Sun Dec 30 2018
  *
  * @brief  test to synchronize global equation numbers
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2015-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 /* -------------------------------------------------------------------------- */
-#include "aka_common.hh"
 #include "dof_synchronizer.hh"
 #include "element_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_partition_scotch.hh"
 #include "synchronizer_registry.hh"
 /* -------------------------------------------------------------------------- */
-#ifdef AKANTU_USE_IOHELPER
 #include "dumper_paraview.hh"
-#endif // AKANTU_USE_IOHELPER
 
 #include "test_dof_data_accessor.hh"
 
 using namespace akantu;
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   initialize(argc, argv);
 
   UInt spatial_dimension = 3;
 
   Mesh mesh(spatial_dimension);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
   bool wait = true;
   if (argc > 1) {
     if (prank == 0)
       while (wait)
         ;
   }
 
   ElementSynchronizer * communicator = NULL;
   if (prank == 0) {
     mesh.read("cube.msh");
 
     MeshPartition * partition =
         new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     communicator =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   /* --------------------------------------------------------------------------
    */
   /* test the communications of the dof synchronizer */
   /* --------------------------------------------------------------------------
    */
 
   std::cout << "Initializing the synchronizer" << std::endl;
   DOFSynchronizer dof_synchronizer(mesh, spatial_dimension);
   dof_synchronizer.initGlobalDOFEquationNumbers();
 
   AKANTU_DEBUG_INFO("Creating TestDOFAccessor");
   TestDOFAccessor test_dof_accessor(
       dof_synchronizer.getGlobalDOFEquationNumbers());
   SynchronizerRegistry synch_registry(test_dof_accessor);
   synch_registry.registerSynchronizer(dof_synchronizer,
                                       SynchronizationTag::_test);
 
   AKANTU_DEBUG_INFO("Synchronizing tag");
   synch_registry.synchronize(SynchronizationTag::_test);
 
   delete communicator;
   finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/test/test_synchronizer/test_grid_synchronizer.cc b/test/test_synchronizer/test_grid_synchronizer.cc
index 465080ba0..276d4272d 100644
--- a/test/test_synchronizer/test_grid_synchronizer.cc
+++ b/test/test_synchronizer/test_grid_synchronizer.cc
@@ -1,311 +1,309 @@
 /**
  * @file   test_grid_synchronizer.cc
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Oct 19 2014
  * @date last modification:  Sun Dec 30 2018
  *
  * @brief  test the GridSynchronizer object
  *
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  * details.
  *
  * You 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_grid_dynamic.hh"
 #include "grid_synchronizer.hh"
 #include "mesh.hh"
 #include "mesh_partition.hh"
 #include "synchronizer_registry.hh"
 #include "test_data_accessor.hh"
-#ifdef AKANTU_USE_IOHELPER
 #include "io_helper.hh"
-#endif // AKANTU_USE_IOHELPER
 
 using namespace akantu;
 
 const UInt spatial_dimension = 2;
 
 typedef std::map<std::pair<Element, Element>, Real> pair_list;
 
 #include "test_grid_tools.hh"
 
 static void
 updatePairList(const ElementTypeMapArray<Real> & barycenter,
                const SpatialGrid<Element> & grid, Real radius,
                pair_list & neighbors,
                neighbors_map_t<spatial_dimension>::type & neighbors_map) {
   AKANTU_DEBUG_IN();
 
   GhostType ghost_type = _not_ghost;
 
   Element e;
   e.ghost_type = ghost_type;
 
   // generate the pair of neighbor depending of the cell_list
   ElementTypeMapArray<Real>::type_iterator it =
       barycenter.firstType(_all_dimensions, ghost_type);
   ElementTypeMapArray<Real>::type_iterator last_type =
       barycenter.lastType(0, ghost_type);
   for (; it != last_type; ++it) {
     // loop over quad points
 
     e.type = *it;
     e.element = 0;
 
     const Array<Real> & barycenter_vect = barycenter(*it, ghost_type);
     UInt sp = barycenter_vect.getNbComponent();
 
     Array<Real>::const_iterator<Vector<Real>> bary = barycenter_vect.begin(sp);
     Array<Real>::const_iterator<Vector<Real>> bary_end =
         barycenter_vect.end(sp);
 
     for (; bary != bary_end; ++bary, e.element++) {
 #if !defined(AKANTU_NDEBUG)
       Point<spatial_dimension> pt1(*bary);
 #endif
 
       SpatialGrid<Element>::CellID cell_id = grid.getCellID(*bary);
       SpatialGrid<Element>::neighbor_cells_iterator first_neigh_cell =
           grid.beginNeighborCells(cell_id);
       SpatialGrid<Element>::neighbor_cells_iterator last_neigh_cell =
           grid.endNeighborCells(cell_id);
 
       // loop over neighbors cells of the one containing the current element
       for (; first_neigh_cell != last_neigh_cell; ++first_neigh_cell) {
         SpatialGrid<Element>::Cell::const_iterator first_neigh_el =
             grid.beginCell(*first_neigh_cell);
         SpatialGrid<Element>::Cell::const_iterator last_neigh_el =
             grid.endCell(*first_neigh_cell);
 
         // loop over the quadrature point in the current cell of the cell list
         for (; first_neigh_el != last_neigh_el; ++first_neigh_el) {
           const Element & elem = *first_neigh_el;
 
           Array<Real>::const_iterator<Vector<Real>> neigh_it =
               barycenter(elem.type, elem.ghost_type).begin(sp);
 
           const Vector<Real> & neigh_bary = neigh_it[elem.element];
 
           Real distance = bary->distance(neigh_bary);
           if (distance <= radius) {
 #if !defined(AKANTU_NDEBUG)
             Point<spatial_dimension> pt2(neigh_bary);
             neighbors_map[pt1].push_back(pt2);
 #endif
             std::pair<Element, Element> pair = std::make_pair(e, elem);
             pair_list::iterator p = neighbors.find(pair);
             if (p != neighbors.end()) {
               AKANTU_ERROR("Pair already registered ["
                            << e << " " << elem << "] -> " << p->second << " "
                            << distance);
             } else {
               neighbors[pair] = distance;
             }
           }
         }
       }
     }
   }
   AKANTU_DEBUG_OUT();
 }
 
 /* -------------------------------------------------------------------------- */
 /* Main                                                                       */
 /* -------------------------------------------------------------------------- */
 int main(int argc, char * argv[]) {
   akantu::initialize(argc, argv);
 
   Real radius = 0.001;
 
   Mesh mesh(spatial_dimension);
 
   const auto & comm = Communicator::getStaticCommunicator();
   Int psize = comm.getNbProc();
   Int prank = comm.whoAmI();
   ElementSynchronizer * dist = NULL;
 
   if (prank == 0) {
     mesh.read("bar.msh");
     MeshPartition * partition =
         new MeshPartitionScotch(mesh, spatial_dimension);
     partition->partitionate(psize);
     dist =
         ElementSynchronizer::createDistributedSynchronizerMesh(mesh, partition);
     delete partition;
   } else {
     dist = ElementSynchronizer::createDistributedSynchronizerMesh(mesh, NULL);
   }
 
   mesh.computeBoundingBox();
 
   const Vector<Real> & lower_bounds = mesh.getLowerBounds();
   const Vector<Real> & upper_bounds = mesh.getUpperBounds();
 
   Vector<Real> center = 0.5 * (upper_bounds + lower_bounds);
 
   Vector<Real> spacing(spatial_dimension);
   for (UInt i = 0; i < spatial_dimension; ++i) {
     spacing[i] = radius * 1.2;
   }
 
   SpatialGrid<Element> grid(spatial_dimension, spacing, center);
 
   GhostType ghost_type = _not_ghost;
 
   Mesh::type_iterator it = mesh.firstType(spatial_dimension, ghost_type);
   Mesh::type_iterator last_type = mesh.lastType(spatial_dimension, ghost_type);
 
   ElementTypeMapArray<Real> barycenters("", "");
   mesh.initElementTypeMapArray(barycenters, spatial_dimension,
                                spatial_dimension);
 
   Element e;
   e.ghost_type = ghost_type;
 
   for (; it != last_type; ++it) {
     UInt nb_element = mesh.getNbElement(*it, ghost_type);
     e.type = *it;
     Array<Real> & barycenter = barycenters(*it, ghost_type);
     barycenter.resize(nb_element);
 
     Array<Real>::iterator<Vector<Real>> bary_it =
         barycenter.begin(spatial_dimension);
     for (UInt elem = 0; elem < nb_element; ++elem) {
       mesh.getBarycenter(elem, *it, bary_it->storage(), ghost_type);
       e.element = elem;
       grid.insert(e, *bary_it);
       ++bary_it;
     }
   }
 
   std::stringstream sstr;
   sstr << "mesh_" << prank << ".msh";
   mesh.write(sstr.str());
 
   Mesh grid_mesh(spatial_dimension, "grid_mesh", 0);
   std::stringstream sstr_grid;
   sstr_grid << "grid_mesh_" << prank << ".msh";
   grid.saveAsMesh(grid_mesh);
   grid_mesh.write(sstr_grid.str());
 
   std::cout << "Pouet 1" << std::endl;
 
   AKANTU_DEBUG_INFO("Creating TestAccessor");
   TestAccessor test_accessor(mesh, barycenters);
   SynchronizerRegistry synch_registry(test_accessor);
 
   GridSynchronizer * grid_communicator =
       GridSynchronizer::createGridSynchronizer(mesh, grid);
 
   std::cout << "Pouet 2" << std::endl;
 
   ghost_type = _ghost;
 
   it = mesh.firstType(spatial_dimension, ghost_type);
   last_type = mesh.lastType(spatial_dimension, ghost_type);
   e.ghost_type = ghost_type;
   for (; it != last_type; ++it) {
     UInt nb_element = mesh.getNbElement(*it, ghost_type);
     e.type = *it;
     Array<Real> & barycenter = barycenters(*it, ghost_type);
     barycenter.resize(nb_element);
 
     Array<Real>::iterator<Vector<Real>> bary_it =
         barycenter.begin(spatial_dimension);
     for (UInt elem = 0; elem < nb_element; ++elem) {
       mesh.getBarycenter(elem, *it, bary_it->storage(), ghost_type);
       e.element = elem;
       grid.insert(e, *bary_it);
       ++bary_it;
     }
   }
 
   Mesh grid_mesh_ghost(spatial_dimension, "grid_mesh_ghost", 0);
   std::stringstream sstr_gridg;
   sstr_gridg << "grid_mesh_ghost_" << prank << ".msh";
   grid.saveAsMesh(grid_mesh_ghost);
   grid_mesh_ghost.write(sstr_gridg.str());
 
   std::cout << "Pouet 3" << std::endl;
 
   neighbors_map_t<spatial_dimension>::type neighbors_map;
   pair_list neighbors;
 
   updatePairList(barycenters, grid, radius, neighbors, neighbors_map);
   pair_list::iterator nit = neighbors.begin();
   pair_list::iterator nend = neighbors.end();
 
   std::stringstream sstrp;
   sstrp << "pairs_" << prank;
   std::ofstream fout(sstrp.str().c_str());
   for (; nit != nend; ++nit) {
     fout << "[" << nit->first.first << "," << nit->first.second << "] -> "
          << nit->second << std::endl;
   }
 
   std::string file = "neighbors_ref";
   std::stringstream sstrf;
   sstrf << file << "_" << psize << "_" << prank;
 
   file = sstrf.str();
 
   std::ofstream nout;
   nout.open(file.c_str());
   neighbors_map_t<spatial_dimension>::type::iterator it_n =
       neighbors_map.begin();
   neighbors_map_t<spatial_dimension>::type::iterator end_n =
       neighbors_map.end();
   for (; it_n != end_n; ++it_n) {
     std::sort(it_n->second.begin(), it_n->second.end());
 
     std::vector<Point<spatial_dimension>>::iterator it_v = it_n->second.begin();
     std::vector<Point<spatial_dimension>>::iterator end_v = it_n->second.end();
 
     nout << "####" << std::endl;
     nout << it_n->second.size() << std::endl;
     nout << it_n->first << std::endl;
     nout << "#" << std::endl;
     for (; it_v != end_v; ++it_v) {
       nout << *it_v << std::endl;
     }
   }
 
   fout.close();
 
   synch_registry.registerSynchronizer(*dist, SynchronizationTag::_smm_mass);
 
   synch_registry.registerSynchronizer(*grid_communicator,
                                       SynchronizationTag::_test);
 
   AKANTU_DEBUG_INFO("Synchronizing tag on Dist");
   synch_registry.synchronize(SynchronizationTag::_smm_mass);
 
   AKANTU_DEBUG_INFO("Synchronizing tag on Grid");
   synch_registry.synchronize(SynchronizationTag::_test);
 
   delete grid_communicator;
   delete dist;
   akantu::finalize();
 
   return EXIT_SUCCESS;
 }
diff --git a/third-party/MUMPS_4.10.0.patch b/third-party/MUMPS_4.10.0.patch
deleted file mode 100644
index 83eea4b60..000000000
--- a/third-party/MUMPS_4.10.0.patch
+++ /dev/null
@@ -1,202 +0,0 @@
-diff --git a/MUMPS_4.10.0.orig/Makefile b/MUMPS_4.10.0/Makefile
-index fc1cb67..9a1dbb5 100644
---- a/MUMPS_4.10.0.orig/Makefile
-+++ b/MUMPS_4.10.0/Makefile
-@@ -8,7 +8,7 @@ default:	dexamples
- 
- .PHONY: default alllib all s d c z \
- 	sexamples dexamples cexamples zexamples \
--	mumps_lib requiredobj libseqneeded clean
-+	mumps_lib requiredobj libseqneeded install clean
- 
- alllib:		s d c z
- all:		sexamples dexamples cexamples zexamples
-@@ -51,29 +51,47 @@ zexamples:	z
- 	(cd examples ; $(MAKE) z)
- 
- 
--requiredobj: Makefile.inc $(LIBSEQNEEDED) $(libdir)/libpord$(PLAT)$(LIBEXT)
-+requiredobj: Makefile.inc $(LIBSEQNEEDED) $(libdir)/libpord$(PLAT)$(LIBEXT) $(libdir)/libpord$(PLAT)$(SHLIBEXT)
- 
- # dummy MPI library (sequential version)
- 
- libseqneeded:
- 	(cd libseq; $(MAKE))
-+	cp libseq/lib* $(libdir)
- 
- # Build the libpord.a library and copy it into $(topdir)/lib
- $(libdir)/libpord$(PLAT)$(LIBEXT):
- 	if [ "$(LPORDDIR)" != "" ] ; then \
- 	  cd $(LPORDDIR); \
--	  $(MAKE) CC="$(CC)" CFLAGS="$(OPTC)" AR="$(AR)" RANLIB="$(RANLIB)" OUTC=$(OUTC) LIBEXT=$(LIBEXT); \
-+	  $(MAKE) CC="$(CC)" CFLAGS="$(OPTC)" AR="$(AR)" RANLIB="$(RANLIB)" OUTC=$(OUTC) LIBEXT=$(LIBEXT) PLAT=$(PLAT) SHLIBEXT=$(SHLIBEXT); \
- 	fi;
- 	if [ "$(LPORDDIR)" != "" ] ; then \
--	  cp $(LPORDDIR)/libpord$(LIBEXT) $@; \
-+	  cp $(LPORDDIR)/libpord$(PLAT)$(LIBEXT) $@; \
- 	fi;
- 
-+$(libdir)/libpord$(PLAT)$(SHLIBEXT):
-+	if [ "$(LPORDDIR)" != "" ] ; then \
-+	  cd $(LPORDDIR); \
-+	  $(MAKE) CC="$(CC)" CFLAGS="$(OPTC)" AR="$(AR)" RANLIB="$(RANLIB)" OUTC=$(OUTC) LIBEXT=$(LIBEXT) PLAT=$(PLAT) SHLIBEXT=$(SHLIBEXT) libpord$(PLAT)$(SHLIBEXT); \
-+	fi;
-+	if [ "$(LPORDDIR)" != "" ] ; then \
-+	  cp $(LPORDDIR)/libpord$(PLAT)$(SHLIBEXT) $@; \
-+	fi;
-+
-+prefix		?= /usr/local
-+
-+install: mumps_lib
-+	-$(MKDIR) $(prefix)/include/
-+	-$(MKDIR) $(prefix)/lib/
-+	-$(CP) include/* $(prefix)/include/
-+	-$(CP) lib/*     $(prefix)/lib/
-+
- clean:
- 	(cd src; $(MAKE) clean)
- 	(cd examples; $(MAKE) clean)
--	(cd $(libdir); $(RM) *$(PLAT)$(LIBEXT))
-+	(cd $(libdir); $(RM) *$(PLAT)$(LIBEXT) *$(PLAT)$(SHLIBEXT))
- 	(cd libseq; $(MAKE) clean)
- 	if [ $(LPORDDIR) != "" ] ; then \
--	  cd $(LPORDDIR); $(MAKE) realclean; \
-+	  cd $(LPORDDIR); $(MAKE) LIBEXT=$(LIBEXT) PLAT=$(PLAT) SHLIBEXT=$(SHLIBEXT) realclean; \
-         fi;
- 
-diff --git a/MUMPS_4.10.0.orig/PORD/lib/Makefile b/MUMPS_4.10.0/PORD/lib/Makefile
-index de56d23..f1defbf 100644
---- a/MUMPS_4.10.0.orig/PORD/lib/Makefile
-+++ b/MUMPS_4.10.0/PORD/lib/Makefile
-@@ -12,7 +12,7 @@ COPTIONS = $(INCLUDES) $(CFLAGS) $(OPTFLAGS)
- 
- OBJS = graph.o gbipart.o gbisect.o ddcreate.o ddbisect.o nestdiss.o \
-        multisector.o gelim.o bucket.o tree.o \
--       symbfac.o interface.o sort.o minpriority.o 
-+       symbfac.o interface.o sort.o minpriority.o
- 
- # Note: numfac.c read.c mapping.c triangular.c matrix.c kernel.c
- # were not direcly used by MUMPS and have been removed from the
-@@ -21,12 +21,15 @@ OBJS = graph.o gbipart.o gbisect.o ddcreate.o ddbisect.o nestdiss.o \
- .c.o:
- 	$(CC) $(COPTIONS) -c $*.c $(OUTC)$*.o
- 
--libpord$(LIBEXT):$(OBJS)
-+libpord$(PLAT)$(LIBEXT):$(OBJS)
- 	$(AR)$@ $(OBJS)
- 	$(RANLIB) $@
- 
-+libpord$(PLAT)$(SHLIBEXT): $(OBJS)
-+	$(CC) -shared $(OBJS) -o libpord$(PLAT)$(SHLIBEXT)
-+
- clean:
- 	rm -f *.o
- 
- realclean:
--	rm -f *.o libpord.a
-+	rm -f *.o libpord$(PLAT)$(SHLIBEXT) libpord$(PLAT)$(LIBEXT)
-diff --git a/MUMPS_4.10.0/PORD/lib/libpord b/MUMPS_4.10.0/PORD/lib/libpord
-new file mode 100755
-index 0000000..91cd0f2
-Binary files /dev/null and b/MUMPS_4.10.0/PORD/lib/libpord differ
-diff --git a/MUMPS_4.10.0.orig/libseq/Makefile b/MUMPS_4.10.0/libseq/Makefile
-index 73701c2..cec44d0 100644
---- a/MUMPS_4.10.0.orig/libseq/Makefile
-+++ b/MUMPS_4.10.0/libseq/Makefile
-@@ -7,11 +7,15 @@ all: libmpiseq
- 
- include ../Makefile.inc
- 
--libmpiseq: libmpiseq$(PLAT)$(LIBEXT)
-+libmpiseq: libmpiseq$(PLAT)$(LIBEXT) libmpiseq$(PLAT)$(SHLIBEXT)
- 
- libmpiseq$(PLAT)$(LIBEXT): mpi.o mpic.o elapse.o
- 	$(AR)$@ mpi.o mpic.o elapse.o
- 	$(RANLIB) $@
-+
-+libmpiseq$(PLAT)$(SHLIBEXT): mpi.o mpic.o elapse.o
-+	$(FC) -shared $^ -o libmpiseq$(PLAT)$(SHLIBEXT)
-+
- .f.o:
- 	$(FC) $(OPTF)              -c $*.f $(OUTF)$*.o
- .c.o:
-diff --git a/MUMPS_4.10.0/libseq/libmpiseq_seq.so b/MUMPS_4.10.0/libseq/libmpiseq_seq.so
-new file mode 100755
-index 0000000..e9c024d
-Binary files /dev/null and b/MUMPS_4.10.0/libseq/libmpiseq_seq.so differ
-diff --git a/MUMPS_4.10.0.orig/src/Makefile b/MUMPS_4.10.0/src/Makefile
-index d42a915..1505fdf 100644
---- a/MUMPS_4.10.0.orig/src/Makefile
-+++ b/MUMPS_4.10.0/src/Makefile
-@@ -20,7 +20,10 @@ z:
- include $(topdir)/Makefile.inc
- 
- mumps_lib:    $(libdir)/libmumps_common$(PLAT)$(LIBEXT) \
--              $(libdir)/lib$(ARITH)mumps$(PLAT)$(LIBEXT)
-+              $(libdir)/libmumps_common$(PLAT)$(SHLIBEXT) \
-+              $(libdir)/lib$(ARITH)mumps$(PLAT)$(LIBEXT) \
-+              $(libdir)/lib$(ARITH)mumps$(PLAT)$(SHLIBEXT)
-+
- 
- OBJS_COMMON = \
-         mumps_part9.o\
-@@ -34,9 +37,9 @@ OBJS_COMMON = \
-         mumps_io_err.o\
-         mumps_static_mapping.o\
-         mumps_sol_es.o\
--	tools_common_mod.o
-+        tools_common_mod.o
- 
--OBJS = 	$(ARITH)mumps_part1.o\
-+OBJS =  $(ARITH)mumps_part1.o\
-         $(ARITH)mumps_part2.o\
-         $(ARITH)mumps_part3.o\
-         $(ARITH)mumps_part4.o\
-@@ -60,14 +63,22 @@ $(libdir)/lib$(ARITH)mumps$(PLAT)$(LIBEXT):    $(OBJS)
- 	$(AR)$@ $?
- 	$(RANLIB) $@
- 
-+$(libdir)/libmumps_common$(PLAT)$(SHLIBEXT):	$(OBJS_COMMON)
-+	$(FC) -shared $^ -L$(libdir) $(LORDERINGS) $(LIBS) $(LIBBLAS) $(LIBOTHERS) -o $(libdir)/libmumps_common$(PLAT)$(SHLIBEXT)
-+
-+
-+$(libdir)/lib$(ARITH)mumps$(PLAT)$(SHLIBEXT):    $(OBJS)
-+	$(FC) -shared $^ -L$(libdir) -lmumps_common$(PLAT) $(LORDERINGS) $(LIBS) $(LIBBLAS) $(LIBOTHERS) -o $(libdir)/lib$(ARITH)mumps$(PLAT)$(SHLIBEXT)
-+
-+
- $(ARITH)mumps_load.o:		$(ARITH)mumps_comm_buffer.o \
--				$(ARITH)mumps_struc_def.o
-+                                $(ARITH)mumps_struc_def.o
- 
--$(ARITH)mumps_ooc.o: 		$(ARITH)mumps_struc_def.o \
--				$(ARITH)mumps_ooc_buffer.o \
--				mumps_ooc_common.o
-+$(ARITH)mumps_ooc.o:            $(ARITH)mumps_struc_def.o \
-+                                $(ARITH)mumps_ooc_buffer.o \
-+                                mumps_ooc_common.o
- 
--$(ARITH)mumps_ooc_buffer.o: 	mumps_ooc_common.o
-+$(ARITH)mumps_ooc_buffer.o:     mumps_ooc_common.o
- 
- 
- $(ARITH)mumps_part1.o \
-@@ -78,8 +89,8 @@ $(ARITH)mumps_part5.o \
- $(ARITH)mumps_part6.o \
- $(ARITH)mumps_part7.o \
- $(ARITH)mumps_part8.o:	$(ARITH)mumps_comm_buffer.o \
--			$(ARITH)mumps_load.o \
--			$(ARITH)mumps_ooc.o
-+                        $(ARITH)mumps_load.o \
-+                        $(ARITH)mumps_ooc.o
- 
- $(ARITH)mumps_part5.o:	mumps_static_mapping.o
- $(ARITH)mumps_part5.o:	$(ARITH)mumps_part2.o
-@@ -95,7 +106,7 @@ $(ARITH)mumps_part8.o : mumps_sol_es.o
- 
- $(ARITH)mumps_c.o:	mumps_c.c
- 	$(CC) $(OPTC) $(INCS) $(CDEFS) -DMUMPS_ARITH=MUMPS_ARITH_$(ARITH) \
--	      $(IORDERINGSC) $(ORDERINGSC) -I../include -c $? $(OUTC)$@
-+              $(IORDERINGSC) $(ORDERINGSC) -I../include -c $? $(OUTC)$@
- 
- 
- clean:
diff --git a/third-party/MUMPS_4.10.0_make.inc.cmake b/third-party/MUMPS_4.10.0_make.inc.cmake
deleted file mode 100644
index a0fe5bd71..000000000
--- a/third-party/MUMPS_4.10.0_make.inc.cmake
+++ /dev/null
@@ -1,84 +0,0 @@
-MUMPS_TYPE = @MUMPS_TYPE@
-PLAT     = @MUMPS_PREFIX@
-LIBEXT   = @CMAKE_STATIC_LIBRARY_SUFFIX@
-SHLIBEXT = @CMAKE_SHARED_LIBRARY_SUFFIX@
-OUTC    = -o 
-OUTF    = -o 
-ISCOTCH    = -I@SCOTCH_INCLUDE_DIR@
-LSCOTCH    = @MUMPS_SCOTCH_LIBRARIES@
-LPORDDIR = $(topdir)/PORD/lib/
-IPORD    = -I$(topdir)/PORD/include/
-LPORD    = -L$(LPORDDIR) -lpord$(PLAT)
-ORDERINGSF  = -Dpord -Dscotch
-ORDERINGSC  = $(ORDERINGSF)
-LORDERINGS = $(LMETIS) $(LPORD) $(LSCOTCH)
-IORDERINGSF = $(ISCOTCH)
-IORDERINGSC = $(IMETIS) $(IPORD) $(ISCOTCH)
-RM      = '@CMAKE_COMMAND@' -E remove -f
-MKDIR   = '@CMAKE_COMMAND@' -E make_directory
-CP      = cp -af
-
-ifeq ($(MUMPS_TYPE),seq)
-# CC : C compiler
-CC      = '@CMAKE_C_COMPILER@'
-# FC : Fortran 90 compiler
-FC      = '@CMAKE_Fortran_COMPILER@'
-# FL : Fortran linker
-FL      = '@CMAKE_Fortran_COMPILER@'
-else
-# CC : C compiler
-CC      = '@MPI_C_COMPILER@'
-# FC : Fortran 90 compiler
-FC      = '@MPI_Fortran_COMPILER@'
-# FL : Fortran linker
-FL      = '@MPI_Fortran_COMPILER@'
-endif
-
-# AR : Archive object in a library
-AR      = '@CMAKE_AR@' vr 
-# RANLIB : generate index of an archive file
-RANLIB  = '@CMAKE_RANLIB@'
-# SCALAP should define the SCALAPACK and  BLACS libraries.
-SCALAP  = '@SCALAPACK_LIBRARIES@'
-
-INCPAR  =
-LIBPAR  = $(SCALAP)
-
-# The parallel version is not concerned by the next two lines.
-# They are related to the sequential library provided by MUMPS,
-# to use instead of ScaLAPACK and MPI.
-INCSEQ  = -I$(topdir)/libseq
-LIBSEQ  = -L$(topdir)/libseq -lmpiseq$(PLAT)
-LIBBLAS = @MUMPS_BLAS_LIBRARIES@
-LIBOTHERS = @AKANTU_MUMPS_PTHREAD@
-
-# FORTRAN/C COMPATIBILITY:
-#  Use:
-#    -DAdd_ if your Fortran compiler adds an underscore at the end
-#              of symbols,
-#     -DAdd__ if your Fortran compiler adds 2 underscores,
-#
-#     -DUPPER if your Fortran compiler uses uppercase symbols
-#
-#     leave empty if your Fortran compiler does not change the symbols.
-#
-CDEFS = @AKANTU_MUMPS_CDEFS@
-#COMPILER OPTIONS
-OPTF    = -O -w -fPIC
-OPTC    = -O -I. -fPIC
-OPTL    = -O -fPIC
-#Sequential:
-ifeq ($(MUMPS_TYPE),seq)
-INCS = $(INCSEQ)
-LIBS = $(LIBSEQ)
-LIBSEQNEEDED = libseqneeded
-endif
-
-#Parallel:
-ifeq ($(MUMPS_TYPE),par)
-INCS = $(INCPAR)
-LIBS = $(LIBPAR)
-LIBSEQNEEDED =
-endif
-
-prefix  = ${INSTALL_DIR}
\ No newline at end of file
diff --git a/third-party/MUMPS_4.9.2_make.inc.cmake b/third-party/MUMPS_4.9.2_make.inc.cmake
deleted file mode 100644
index dad937150..000000000
--- a/third-party/MUMPS_4.9.2_make.inc.cmake
+++ /dev/null
@@ -1,162 +0,0 @@
-#
-#  This file is part of MUMPS 4.9.2, built on Thu Nov  5 07:05:08 UTC 2009
-#
-################################################################################
-#
-#   Makefile.inc.generic
-#
-#   This defines some parameters dependent on your platform; you should
-#   look for the approriate file in the directory ./Make.inc/ and copy it
-#   into a file called Makefile.inc. For example, from the MUMPS root
-#   directory, use 
-#   "cp Make.inc/Makefile.inc.generic ./Makefile.inc"
-#   (see the main README file for details)
-#
-#   If you do not find any suitable Makefile in Makefile.inc, use this file:
-#   "cp Make.inc/Makefile.inc.generic ./Makefile.inc" and modify it according
-#   to the comments given below. If you manage to build MUMPS on a new platform,
-#   and think that this could be useful to others, you may want to send us
-#   the corresponding Makefile.inc file.
-#
-################################################################################
-
-# CHOOSE BETWEEN USING THE SEQUENTIAL OR THE PARALLEL VERSION.
-MUMPS_TYPE = @MUMPS_TYPE@
-
-########################################################################
-#Begin orderings
-#
-# NOTE that PORD is distributed within MUMPS by default. If you would like to
-# use other orderings, you need to obtain the corresponding package and modify
-# the variables below accordingly.
-# For example, to have Metis available within MUMPS:
-#          1/ download Metis and compile it
-#          2/ uncomment (suppress # in first column) lines
-#             starting with LMETISDIR,  LMETIS
-#          3/ add -Dmetis in line ORDERINGSF
-#             ORDERINGSF  = -Dpord -Dmetis
-#          4/ Compile and install MUMPS
-#             make clean; make   (to clean up previous installation)
-#
-#          Metis/ParMetis and SCOTCH/PT-SCOTCH (ver 5.1 and later) orderings are now available for MUMPS.
-#
-
-ISCOTCH    = -I@SCOTCH_INCLUDE_DIR@
-# You have to choose one among the following two lines depending on
-# the type of analysis you want to perform. If you want to perform only
-# sequential analysis choose the first (remember to add -Dscotch in the ORDERINGSF
-# variable below); for both parallel and sequential analysis choose the second 
-# line (remember to add -Dptscotch in the ORDERINGSF variable below)
-LSCOTCH    = @SCOTCH_LIBRARIES@
-
-LPORDDIR = $(topdir)/PORD/lib/
-IPORD    = -I$(topdir)/PORD/include/
-LPORD    = -L$(LPORDDIR) -lpord
-
-#LMETISDIR = /local/metis/
-#IMETIS    = # Metis doesn't need include files (Fortran interface avail.)
-
-# You have to choose one among the following two lines depending on
-# the type of analysis you want to perform. If you want to perform only
-# sequential analysis choose the first (remember to add -Dmetis in the ORDERINGSF
-# variable below); for both parallel and sequential analysis choose the second 
-# line (remember to add -Dparmetis in the ORDERINGSF variable below)
-
-#LMETIS    = -L$(LMETISDIR) -lmetis
-#LMETIS    = -L$(LMETISDIR) -lparmetis -lmetis
-
-# The following variables will be used in the compilation process.
-# Please note that -Dptscotch and -Dparmetis imply -Dscotch and -Dmetis respectively.
-#ORDERINGSF = -Dscotch -Dmetis -Dpord -Dptscotch -Dparmetis
-ORDERINGSF  = -Dpord -Dscotch
-ORDERINGSC  = $(ORDERINGSF)
-
-LORDERINGS = $(LMETIS) $(LPORD) $(LSCOTCH)
-IORDERINGSF = $(ISCOTCH)
-IORDERINGSC = $(IMETIS) $(IPORD) $(ISCOTCH)
-
-#End orderings
-########################################################################
-# DEFINE HERE SOME COMMON COMMANDS, THE COMPILER NAMES, ETC...
-
-# PLAT : use it to add a default suffix to the generated libraries
-PLAT    = @MUMPS_PREFIX@
-# RM : remove files
-RM      = '@CMAKE_COMMAND@' -E remove -f
-
-ifeq ($(MUMPS_TYPE),seq)
-# CC : C compiler
-CC      = '@CMAKE_C_COMPILER@'
-# FC : Fortran 90 compiler
-FC      = '@CMAKE_Fortran_COMPILER@'
-# FL : Fortran linker
-FL      = '@CMAKE_Fortran_COMPILER@'
-else
-# CC : C compiler
-CC      = '@MPI_C_COMPILER@'
-# FC : Fortran 90 compiler
-FC      = '@MPI_Fortran_COMPILER@'
-# FL : Fortran linker
-FL      = '@MPI_Fortran_COMPILER@'
-endif
-
-# AR : Archive object in a library
-AR      = '@CMAKE_AR@' vr 
-# RANLIB : generate index of an archive file
-#   (optionnal use "RANLIB = echo" in case of problem)
-RANLIB  = '@CMAKE_RANLIB@'
-#RANLIB  = echo
-
-# SCALAP should define the SCALAPACK and  BLACS libraries.
-SCALAP  = @PROJECT_BINARY_DIR@/third-party/lib/libscalapack.a
-
-# INCLUDE DIRECTORY FOR MPI
-INCPAR  =
-#INCPAR  = @MPI_Fortran_COMPILE_FLAGS@ @MUMPS_MPI_INCLUDE_PATH@
-
-# LIBRARIES USED BY THE PARALLEL VERSION OF MUMPS: $(SCALAP) and MPI
-#LIBPAR  = $(SCALAP) @MPI_Fortran_LINK_FLAGS@ @MUMPS_MPI_Fortran_LIBRARIES@
-LIBPAR  = $(SCALAP)
-
-# The parallel version is not concerned by the next two lines.
-# They are related to the sequential library provided by MUMPS,
-# to use instead of ScaLAPACK and MPI.
-INCSEQ  = -I$(topdir)/libseq
-LIBSEQ  = -L$(topdir)/libseq -lmpiseq
-
-# DEFINE HERE YOUR BLAS LIBRARY
-LIBBLAS = @BLAS_LIBRARIES@
-
-# DEFINE YOUR PTHREAD LIBRARY
-LIBOTHERS = @AKANTU_MUMPS_PTHREAD@
-
-# FORTRAN/C COMPATIBILITY:
-#  Use:
-#    -DAdd_ if your Fortran compiler adds an underscore at the end
-#              of symbols,
-#     -DAdd__ if your Fortran compiler adds 2 underscores,
-#
-#     -DUPPER if your Fortran compiler uses uppercase symbols
-#
-#     leave empty if your Fortran compiler does not change the symbols.
-#
-CDEFS = @AKANTU_MUMPS_CDEFS@
-
-#COMPILER OPTIONS
-OPTF    = -O -w -fPIC
-OPTC    = -O -I. -fPIC
-OPTL    = -O -fPIC
-
-#Sequential:
-ifeq ($(MUMPS_TYPE),seq)
-INC = $(INCSEQ)
-LIB = $(LIBSEQ)
-LIBSEQNEEDED = libseqneeded
-endif
-
-#Parallel:
-ifeq ($(MUMPS_TYPE),par)
-INC = $(INCPAR)
-LIB = $(LIBPAR)
-LIBSEQNEEDED =
-endif
diff --git a/third-party/MUMPS_5.0.0.patch b/third-party/MUMPS_5.0.0.patch
deleted file mode 100644
index 52469cd54..000000000
--- a/third-party/MUMPS_5.0.0.patch
+++ /dev/null
@@ -1,154 +0,0 @@
-diff -Naur MUMPS_5.0.0/libseq/Makefile MUMPS_5.0.0.shared/libseq/Makefile
---- MUMPS_5.0.0/libseq/Makefile	2015-02-20 09:20:00.000000000 +0100
-+++ MUMPS_5.0.0.shared/libseq/Makefile	2015-03-06 14:23:37.293877000 +0100
-@@ -8,11 +8,15 @@
- 
- include ../Makefile.inc
- 
--libmpiseq: libmpiseq$(PLAT)$(LIBEXT)
-+libmpiseq: libmpiseq$(PLAT)$(LIBEXT) libmpiseq$(PLAT)$(SHLIBEXT)
- 
- libmpiseq$(PLAT)$(LIBEXT): mpi.o mpic.o elapse.o
- 	$(AR)$@ mpi.o mpic.o elapse.o
- 	$(RANLIB) $@
-+
-+libmpiseq$(PLAT)$(SHLIBEXT): mpi.o mpic.o elapse.o
-+	$(FC) -shared $^ -o libmpiseq$(PLAT)$(SHLIBEXT)
-+
- .f.o:
- 	$(FC) $(OPTF)              -c $*.f $(OUTF)$*.o
- .c.o:
-diff -Naur MUMPS_5.0.0/Makefile MUMPS_5.0.0.shared/Makefile
---- MUMPS_5.0.0/Makefile	2015-02-20 09:19:56.000000000 +0100
-+++ MUMPS_5.0.0.shared/Makefile	2015-03-06 14:24:13.083854000 +0100
-@@ -2,14 +2,15 @@
- #  This file is part of MUMPS 5.0.0, released
- #  on Fri Feb 20 08:19:56 UTC 2015
- #
--topdir = .
--libdir = $(topdir)/lib
-+topdir  = .
-+libdir  = $(topdir)/lib
-+prefix ?= /usr/local
- 
- default:	dexamples
- 
- .PHONY: default alllib all c z s d \
- 	sexamples dexamples cexamples zexamples \
--	mumps_lib requiredobj libseqneeded clean
-+	mumps_lib requiredobj libseqneeded install clean
- 
- alllib:		c z s d
- all:		cexamples zexamples sexamples dexamples
-@@ -51,29 +52,46 @@
- dexamples:	d
- 	(cd examples ; $(MAKE) d)
- 
--requiredobj: Makefile.inc $(LIBSEQNEEDED) $(libdir)/libpord$(PLAT)$(LIBEXT)
-+requiredobj: Makefile.inc $(LIBSEQNEEDED) $(libdir)/libpord$(PLAT)$(LIBEXT) $(libdir)/libpord$(PLAT)$(SHLIBEXT)
- 
- # dummy MPI library (sequential version)
- 
- libseqneeded:
- 	(cd libseq; $(MAKE))
-+	cp libseq/lib* $(libdir)
- 
- # Build the libpord.a library and copy it into $(topdir)/lib
- $(libdir)/libpord$(PLAT)$(LIBEXT):
- 	if [ "$(LPORDDIR)" != "" ] ; then \
- 	  cd $(LPORDDIR); \
--	  $(MAKE) CC="$(CC)" CFLAGS="$(OPTC)" AR="$(AR)" RANLIB="$(RANLIB)" OUTC="$(OUTC)" LIBEXT=$(LIBEXT); \
-+	  $(MAKE) CC="$(CC)" CFLAGS="$(OPTC)" AR="$(AR)" RANLIB="$(RANLIB)" OUTC="$(OUTC)" LIBEXT=$(LIBEXT) PLAT=$(PLAT) SHLIBEXT=$(SHLIBEXT); \
- 	fi;
- 	if [ "$(LPORDDIR)" != "" ] ; then \
- 	  cp $(LPORDDIR)/libpord$(LIBEXT) $@; \
- 	fi;
- 
-+$(libdir)/libpord$(PLAT)$(SHLIBEXT):
-+	if [ "$(LPORDDIR)" != "" ] ; then \
-+	  cd $(LPORDDIR); \
-+	  $(MAKE) CC="$(CC)" CFLAGS="$(OPTC)" AR="$(AR)" RANLIB="$(RANLIB)" OUTC="$(OUTC)" LIBEXT=$(LIBEXT) PLAT=$(PLAT) SHLIBEXT=$(SHLIBEXT) libpord$(PLAT)$(SHLIBEXT); \
-+	fi;
-+	if [ "$(LPORDDIR)" != "" ] ; then \
-+	  cp $(LPORDDIR)/libpord$(PLAT)$(SHLIBEXT) $@; \
-+	fi;
-+
-+install: alllib
-+	-$(MKDIR) $(prefix)/include/
-+	-$(MKDIR) $(prefix)/lib/
-+	-$(CP) include/* $(prefix)/include/
-+	-$(CP) lib/*     $(prefix)/lib/
-+
- clean:
- 	(cd src; $(MAKE) clean)
- 	(cd examples; $(MAKE) clean)
--	(cd $(libdir); $(RM) *$(PLAT)$(LIBEXT))
-+	(cd $(libdir); $(RM) *$(PLAT)$(LIBEXT) *$(PLAT)$(SHLIBEXT))
- 	(cd libseq; $(MAKE) clean)
- 	if [ "$(LPORDDIR)" != "" ] ; then \
- 	  cd $(LPORDDIR); $(MAKE) realclean; \
-+	  cd $(LPORDDIR); $(MAKE) LIBEXT=$(LIBEXT) PLAT=$(PLAT) SHLIBEXT=$(SHLIBEXT) realclean; \
-         fi;
- 
-diff -Naur MUMPS_5.0.0/PORD/lib/Makefile MUMPS_5.0.0.shared/PORD/lib/Makefile
---- MUMPS_5.0.0/PORD/lib/Makefile	2015-02-20 09:19:56.000000000 +0100
-+++ MUMPS_5.0.0.shared/PORD/lib/Makefile	2015-03-06 14:23:37.272190000 +0100
-@@ -13,7 +13,7 @@
- 
- OBJS = graph.o gbipart.o gbisect.o ddcreate.o ddbisect.o nestdiss.o \
-        multisector.o gelim.o bucket.o tree.o \
--       symbfac.o interface.o sort.o minpriority.o 
-+       symbfac.o interface.o sort.o minpriority.o
- 
- # Note: numfac.c read.c mapping.c triangular.c matrix.c kernel.c
- # were not direcly used by MUMPS and have been removed from the
-@@ -24,12 +24,15 @@
- .c.o:
- 	$(CC) $(COPTIONS) -c $*.c $(OUTC)$*.o
- 
--libpord$(LIBEXT):$(OBJS)
-+libpord$(PLAT)$(LIBEXT):$(OBJS)
- 	$(AR)$@ $(OBJS)
- 	$(RANLIB) $@
- 
-+libpord$(PLAT)$(SHLIBEXT): $(OBJS)
-+	$(CC) -shared $(OBJS) -o libpord$(PLAT)$(SHLIBEXT)
-+
- clean:
- 	rm -f *.o
- 
- realclean:
--	rm -f *.o libpord.a
-+	rm -f *.o libpord$(PLAT)$(SHLIBEXT) libpord$(PLAT)$(LIBEXT)
-diff -Naur MUMPS_5.0.0/src/Makefile MUMPS_5.0.0.shared/src/Makefile
---- MUMPS_5.0.0/src/Makefile	2015-02-20 09:19:56.000000000 +0100
-+++ MUMPS_5.0.0.shared/src/Makefile	2015-03-06 14:24:22.568979000 +0100
-@@ -24,7 +24,10 @@
- include $(topdir)/Makefile.inc
- 
- mumps_lib:    $(libdir)/libmumps_common$(PLAT)$(LIBEXT) \
--              $(libdir)/lib$(ARITH)mumps$(PLAT)$(LIBEXT)
-+              $(libdir)/libmumps_common$(PLAT)$(SHLIBEXT) \
-+              $(libdir)/lib$(ARITH)mumps$(PLAT)$(LIBEXT) \
-+              $(libdir)/lib$(ARITH)mumps$(PLAT)$(SHLIBEXT)
-+
- 
- OBJS_COMMON_MOD = \
-         ana_omp_m.o\
-@@ -161,6 +164,16 @@
- 	$(AR)$@ $?
- 	$(RANLIB) $@
- 
-+$(libdir)/libmumps_common$(PLAT)$(SHLIBEXT):	$(OBJS_COMMON_MOD) $(OBJS_COMMON_OTHER)
-+	$(FC) -shared $^ -L$(libdir) $(LORDERINGS) $(LIBS) $(LIBBLAS) $(LIBOTHERS) -o $(libdir)/libmumps_common$(PLAT)$(SHLIBEXT)
-+
-+
-+$(libdir)/lib$(ARITH)mumps$(PLAT)$(SHLIBEXT):    $(OBJS_MOD) $(OBJS_OTHER)
-+	$(FC) -shared $^ -L$(libdir) -lmumps_common$(PLAT) $(LORDERINGS) $(LIBS) $(LIBBLAS) $(LIBOTHERS) -o $(libdir)/lib$(ARITH)mumps$(PLAT)$(SHLIBEXT)
-+
-+
-+
-+
- # Dependencies between modules:
- $(ARITH)mumps_load.o:		$(ARITH)mumps_comm_buffer.o \
- 				$(ARITH)mumps_struc_def.o \
diff --git a/third-party/akantu_iterators/CMakeLists.txt b/third-party/akantu_iterators/CMakeLists.txt
index b69021f26..e8fb878d1 100644
--- a/third-party/akantu_iterators/CMakeLists.txt
+++ b/third-party/akantu_iterators/CMakeLists.txt
@@ -1,73 +1,73 @@
 cmake_minimum_required(VERSION 3.5.1)
 
-project(AkantuIterators)
+project(akantu_iterators)
 
 # ------------------------------------------------------------------------------
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(BUILD_SHARED_LIBS ON)
 if (NOT AKANTU_ITERATORS_PYTHON_MAJOR_VERSION)
   set(AKANTU_ITERATORS_PYTHON_MAJOR_VERSION 3)
 endif()
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
 
 include(AkantuIteratorsTools)
 # ------------------------------------------------------------------------------
 
 set(AKANTU_ITERATORS_PUBLIC_HDRS
   include/aka_compatibilty_with_cpp_standard.hh
   include/aka_iterators.hh
   include/aka_static_if.hh
   include/aka_tuple_tools.hh
   include/aka_str_hash.hh
   include/iterators/aka_arange_iterator.hh
   include/iterators/aka_enumerate_iterator.hh
   include/iterators/aka_filter_iterator.hh
   include/iterators/aka_transform_iterator.hh
   include/iterators/aka_zip_iterator.hh
   )
 
 add_library(akantu_iterators INTERFACE)
 
 target_include_directories(akantu_iterators
-  INTERFACE $<INSTALL_INTERFACE:include>
+  INTERFACE $<INSTALL_INTERFACE:include/${PROJECT_NAME}>
   )
 
 # small trick for build includes in public
 set_property(TARGET akantu_iterators APPEND PROPERTY
   INTERFACE_INCLUDE_DIRECTORIES $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
 
 set_target_properties(akantu_iterators
   PROPERTIES
   INTERFACE_CXX_STANDARD 14
   )
 
 # ------------------------------------------------------------------------------
 option(AKANTU_ITERATORS_TESTS "Activating tests" OFF)
 mark_as_advanced(AKANTU_ITERATORS_TESTS)
 if(AKANTU_ITERATORS_TESTS)
   enable_testing()
   add_external_package(GTest)
   add_subdirectory(test)
 endif()
 
 # ------------------------------------------------------------------------------
 if(NOT AKANTU_ITERATORS_TARGETS_EXPORT)
   set(AKANTU_ITERATORS_TARGETS_EXPORT AkantuIteratorsTargets)
 endif()
 
 include(GNUInstallDirs)
 install(TARGETS akantu_iterators
   EXPORT ${AKANTU_ITERATORS_TARGETS_EXPORT}
   )
 
-install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
 
 if("${AKANTU_ITERATORS_TARGETS_EXPORT}" STREQUAL "AkantuIteratorsTargets")
   install(EXPORT AkantuIteratorsTargets
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/${PROJECT_NAME})
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
 
   #Export for build tree
   export(EXPORT AkantuIteratorsTargets
     FILE "${CMAKE_CURRENT_BINARY_DIR}/AkantuIteratorsTargets.cmake")
   export(PACKAGE AkantuIterators)
 endif()
diff --git a/third-party/blas_3.5.0_make.inc.cmake b/third-party/blas_3.5.0_make.inc.cmake
deleted file mode 100644
index 426e32598..000000000
--- a/third-party/blas_3.5.0_make.inc.cmake
+++ /dev/null
@@ -1,38 +0,0 @@
-####################################################################
-#  BLAS make include file.                                         #
-#  March 2007                                                      #
-####################################################################
-#
-SHELL = @CMAKE_SH@
-#
-#  The machine (platform) identifier to append to the library names
-#
-PLAT = _@CMAKE_SYSTEM_NAME@
-#  
-#  Modify the FORTRAN and OPTS definitions to refer to the
-#  compiler and desired compiler options for your machine.  NOOPT
-#  refers to the compiler options desired when NO OPTIMIZATION is
-#  selected.  Define LOADER and LOADOPTS to refer to the loader and 
-#  desired load options for your machine.
-#
-FORTRAN  = '@CMAKE_Fortran_COMPILER@'
-OPTS     = -O3
-DRVOPTS  = $(OPTS)
-NOOPT    =
-LOADER   = '@CMAKE_Fortran_COMPILER@'
-LOADOPTS =
-#
-#  The archiver and the flag(s) to use when building archive (library)
-#  If you system has no ranlib, set RANLIB = echo.
-#
-ARCH     = '@CMAKE_AR@'
-ARCHFLAGS= cr
-#
-#  The location and name of the Reference BLAS library.
-#
-BLASLIB      = blas$(PLAT).a
-
-RANLIB   = '@CMAKE_Fortran_COMPILER@' @CMAKE_SHARED_LIBRARY_Fortran_FLAGS@ -shared \
-             -o @CMAKE_SHARED_LIBRARY_PREFIX@blas@CMAKE_SHARED_LIBRARY_SUFFIX@ \
-             -Wl,--whole-archive $(BLASLIB) -Wl,--no-whole-archive; \
-             '@CMAKE_COMMAND@' -E echo
diff --git a/third-party/cmake/mumps.cmake b/third-party/cmake/mumps.cmake
deleted file mode 100644
index 8a2387e7a..000000000
--- a/third-party/cmake/mumps.cmake
+++ /dev/null
@@ -1,152 +0,0 @@
-#===============================================================================
-# @file   mumps.cmake
-#
-# @author Nicolas Richart <nicolas.richart@epfl.ch>
-#
-# @date creation: Mon Mar 30 2015
-# @date last modification: Wed Nov 11 2015
-#
-# @brief  compilation of the third-party MUMPS
-#
-# @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/>.
-#
-#===============================================================================
-
-enable_language(Fortran)
-
-set(MUMPS_VERSION ${AKANTU_USE_MUMPS_VERSION})
-set(MUMPS_ARCHIVE "${PROJECT_SOURCE_DIR}/third-party/MUMPS_${MUMPS_VERSION}.tar.gz")
-set(MUMPS_ARCHIVE_HASH_4.9.2  "MD5=d0b8f139a4acf29b76dbae69ade8ac54")
-set(MUMPS_ARCHIVE_HASH_4.10.0 "MD5=959e9981b606cd574f713b8422ef0d9f")
-set(MUMPS_ARCHIVE_HASH_5.0.0  "MD5=3c6aeab847e9d775ca160194a9db2b75")
-
-if(NOT EXISTS ${MUMPS_ARCHIVE})
-  message(FATAL_ERROR "To be able to compile MUMPS please download it from "
-    "http://mumps.enseeiht.fr/ or http://graal.ens-lyon.fr/MUMPS and place it "
-    "in the directory: ${PROJECT_SOURCE_DIR}/third-party and in cmake set the "
-    "variable AKANTU_MUMPS_VERSION to the corresponding version "
-    "\n"
-    "Supported version for automated compilation in Akantu are 4.9.2, 4.10.0 "
-    "and 5.0.0")
-endif()
-
-package_get_option_name(MPI _mpi_option)
-if(${_mpi_option})
-  unset(MUMPS_PREFIX)
-else()
-  set(MUMPS_PREFIX _seq)
-endif()
-
-package_use_system(Scotch _scotch_use_system)
-if(NOT _scotch_use_system)
-  list(APPEND MUMPS_DEPENDS Scotch)
-endif()
-
-package_get_option_name(ScaLAPACK _scalapack_option)
-package_use_system(ScaLAPACK _scalapack_use_system)
-if(NOT _scalapack_use_system AND ${_scalapack_option})
-  list(APPEND MUMPS_DEPENDS ScaLAPACK)
-endif()
-
-include(AkantuMacros)
-
-package_get_libraries(Scotch _scotch_libraries)
-string(REPLACE ";" " " MUMPS_SCOTCH_LIBRARIES
-  "${_scotch_libraries};${SCOTCH_LIBRARY_ESMUMPS}")
-
-package_get_libraries(BLAS _blas_libraries)
-foreach(_blas_lib ${_blas_libraries})
-  if("${_blas_lib}" MATCHES ".*\\.framework")
-    get_filename_component(_blas_framework "${_blas_lib}" NAME_WE)
-    set(MUMPS_BLAS_LIBRARIES "${MUMPS_BLAS_LIBRARIES} -framework ${_blas_framework}")
-  else()
-    set(MUMPS_BLAS_LIBRARIES "${MUMPS_BLAS_LIBRARIES} ${_blas_lib}")
-  endif()
-endforeach()
-
-if("${MUMPS_TYPE}" STREQUAL "seq")
-  set_third_party_shared_libirary_name(MUMPS_LIBRARY_MPI mpiseq${MUMPS_PREFIX})
-  mark_as_advanced(MUMPS_LIBRARY_MPI)
-else()
-  set(MUMPS_LIBRARY_MPI "")
-endif()
-
-if(CMAKE_C_COMPILER_ID STREQUAL "Intel")
-  set(MUMPS_EXTRA_Fortran_FLAGS "-nofor_main")
-else()
-  set(MUMPS_EXTRA_Fortran_FLAGS "")
-endif()
-
-if(CMAKE_VERSION VERSION_GREATER 3.1)
-  set(_extra_options
-    DOWNLOAD_NO_PROGRESS 1
-    EXCLUDE_FROM_ALL 1
-    )
-endif()
-
-if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-  set(AKANTU_MUMPS_CDEFS "-DAdd_ -DWITHOUT_PTHREAD")
-else()
-  set(AKANTU_MUMPS_CDEFS "-DAdd_")
-  set(AKANTU_MUMPS_PTHREAD "-lpthread")
-endif()
-
-configure_file(${PROJECT_SOURCE_DIR}/third-party/MUMPS_${MUMPS_VERSION}_make.inc.cmake
-  ${PROJECT_BINARY_DIR}/third-party/MUMPS_make.inc @ONLY)
-
-ExternalProject_Add(MUMPS
-  DEPENDS ${MUMPS_DEPENDS}
-  PREFIX ${PROJECT_BINARY_DIR}/third-party
-  URL ${MUMPS_ARCHIVE}
-  URL_HASH ${MUMPS_ARCHIVE_HASH_${MUMPS_VERSION}}
-  ${_extra_options}
-  BUILD_IN_SOURCE 1
-  PATCH_COMMAND ${PATCH_COMMAND} -p2 < ${PROJECT_SOURCE_DIR}/third-party/MUMPS_${MUMPS_VERSION}.patch
-  CONFIGURE_COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_BINARY_DIR}/third-party/MUMPS_make.inc Makefile.inc
-  BUILD_COMMAND ${CMAKE_MAKE_PROGRAM} d
-  INSTALL_COMMAND "${CMAKE_MAKE_PROGRAM}" prefix=<INSTALL_DIR> install
-  LOG_DOWNLOAD 1
-  LOG_CONFIGURE 1
-  LOG_BUILD 1
-  LOG_INSTALL 1
-  )
-
-set_third_party_shared_libirary_name(MUMPS_LIBRARY_DMUMPS dmumps${MUMPS_PREFIX})
-set_third_party_shared_libirary_name(MUMPS_LIBRARY_COMMON mumps_common${MUMPS_PREFIX})
-set_third_party_shared_libirary_name(MUMPS_LIBRARY_PORD pord${MUMPS_PREFIX})
-
-mark_as_advanced(
-  MUMPS_LIBRARY_COMMON
-  MUMPS_LIBRARY_DMUMPS
-  MUMPS_LIBRARY_PORD
-  MUMPS_LIBRARY_MPI
-  MUMPS_INCLUDE_DIR
-  )
-
-set(MUMPS_LIBRARIES_ALL
-  ${MPI_Fortran_LIBRARIES}
-  ${MUMPS_LIBRARY_COMMON}
-  ${MUMPS_LIBRARY_DMUMPS}
-  ${MUMPS_LIBRARY_PORD}
-  ${MUMPS_LIBRARY_MPI})
-
-set(MUMPS_INCLUDE_DIR ${PROJECT_BINARY_DIR}/third-party/include CACHE PATH "" FORCE)
-set(MUMPS_LIBRARIES ${MUMPS_LIBRARIES_ALL} CACHE INTERNAL "Libraries for MUMPS" FORCE)
-
-package_add_extra_dependency(Mumps MUMPS)
diff --git a/third-party/cmake/scalapack.cmake b/third-party/cmake/scalapack.cmake
deleted file mode 100644
index be7626c4e..000000000
--- a/third-party/cmake/scalapack.cmake
+++ /dev/null
@@ -1,69 +0,0 @@
-#===============================================================================
-# @file   scalapack.cmake
-#
-# @author Nicolas Richart <nicolas.richart@epfl.ch>
-#
-# @date creation: Mon Mar 30 2015
-# @date last modification: Wed Jun 10 2015
-#
-# @brief  package description for mumps support
-#
-# @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/>.
-#
-#===============================================================================
-
-enable_language(Fortran)
-
-if(CMAKE_VERSION VERSION_GREATER 3.1)
-  set(_extra_options 
-    UPDATE_DISCONNECTED 1
-    DOWNLOAD_NO_PROGRESS 1
-    EXCLUDE_FROM_ALL 1
-    )
-endif()
-
-set(SCALAPACK_DIR ${PROJECT_BINARY_DIR}/third-party)
-ExternalProject_Add(ScaLAPACK
-  PREFIX   ${SCALAPACK_DIR}
-  URL      ${SCALAPACK_ARCHIVE}
-  URL_HASH ${SCALAPACK_ARCHIVE_HASH}
-  ${_extra_options}
-  PATCH_COMMAND patch -p1 < ${PROJECT_SOURCE_DIR}/third-party/scalapack_${SCALAPACK_VERSION}.patch
-  CMAKE_COMMAND BLA_VENDOR=$ENV{BLA_VENDOR} MPICH_F90=${CMAKE_Fortran_COMPILER} ${CMAKE_COMMAND}
-  CMAKE_ARGS <SOURCE_DIR>/ScaLAPACK
-  CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
-  -DMPIEXEC:PATH=${MPIEXEC}
-  -DCMAKE_C_COMPILER:PATH=${CMAKE_C_COMPILER}
-  -DMPI_C_COMPILER:PATH=${MPI_C_COMPILER}
-  -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
-  -DCMAKE_Fortran_COMPILER:PATH=${CMAKE_Fortran_COMPILER}
-  -DCMAKE_Fortran_FLAGS:STRING=${CMAKE_Fortran_FLAGS}
-  -DMPI_Fortran_COMPILER:PATH=${MPI_Fortran_COMPILER}
-  -DBUILD_SHARED_LIBS:BOOL=ON
-  -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
-  BUILD_COMMAND BLA_VENDOR=$ENV{BLA_VENDOR} MPICH_F90=${CMAKE_Fortran_COMPILER} ${CMAKE_MAKE_PROGRAM}
-  LOG_DOWNLOAD 1
-  LOG_CONFIGURE 1
-  LOG_BUILD 1
-  LOG_INSTALL 1
-  )
-
-set_third_party_shared_libirary_name(SCALAPACK_LIBRARIES scalapack)
-set(SCALAPACK_INCLUDE_DIR ${SCALAPACK_DIR}/include CACHE PATH "" FORCE)
-mark_as_advanced(SCALAPACK_LIBRARIES SCALAPACK_INCLUDE_DIR)
diff --git a/third-party/cmake/scotch.cmake b/third-party/cmake/scotch.cmake
deleted file mode 100644
index fe9f5e7ff..000000000
--- a/third-party/cmake/scotch.cmake
+++ /dev/null
@@ -1,128 +0,0 @@
-#===============================================================================
-# @file   scotch.cmake
-#
-# @author Nicolas Richart <nicolas.richart@epfl.ch>
-#
-# @date creation: Mon Mar 30 2015
-# @date last modification: Wed Nov 11 2015
-#
-# @brief  build script for scotch
-#
-# @section LICENSE
-#
-# Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
-# (LSMS - Laboratoire de Simulation en Mécanique des Solides)
-#
-# Akantu is free  software: you can redistribute it and/or  modify it under the
-# terms  of the  GNU Lesser  General Public  License as  published by  the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
-# details.
-#
-# You should  have received  a copy  of the GNU  Lesser General  Public License
-# along with Akantu. If not, see <http://www.gnu.org/licenses/>.
-#
-#===============================================================================
-
-if(TARGET Scotch)
-  return()
-endif()
-
-if(NOT EXISTS ${PROJECT_SOURCE_DIR}/third-party/${SCOTCH_ARCHIVE})
-  set(_scotch_download_command
-    URL ${SCOTCH_URL}
-#    URL_HASH ${SCOTCH_ARCHIVE_HASH}
-    TLS_VERIFY FALSE
-    )
-else()
-  set(_scotch_download_command
-    URL ${PROJECT_SOURCE_DIR}/third-party/${SCOTCH_ARCHIVE}
-    URL_HASH ${SCOTCH_ARCHIVE_HASH})
-endif()
-
-if(CMAKE_VERSION VERSION_GREATER 3.1)
-  set(_extra_options
-    DOWNLOAD_NO_PROGRESS 1
-    EXCLUDE_FROM_ALL 1
-    )
-endif()
-
-find_package(BISON REQUIRED)
-find_package(FLEX REQUIRED)
-find_package(ZLIB)
-
-#if(ZLIB_FOUND)
-#  set(_zlib_cflags "-DCOMMON_FILE_COMPRESS_GZ -I${ZLIB_INCLUDE_DIR}")
-#  set(_zlib_ldflags "${ZLIB_LIBRARY}")
-#endif()
-
-if(NOT CMAKE_SYSTEM_NAME STREQUAL "Windows")
-  if (AKANTU_USE_OBSOLETE_GETTIMEOFDAY)
-    set(_timing_cflags -DCOMMON_TIMING_OLD)
-  endif()
-  set(_system_cflags "-DCOMMON_PTHREAD -DSCOTCH_PTHREAD ${_timing_cflags}")
-  set(_system_ldflags "-lpthread")
-else()
-  set(_system_cflags "-DCOMMON_RANDOM_RAND -DCOMMON_WINDOWS -DCOMMON_STUB_FORK -D'pipe(pfds)=_pipe(pfds,1024,0x8000)'")
-endif()
-
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  set(_architecture_cflags -DIDXSIZE64)
-endif()
-
-math(EXPR _n "${AKANTU_INTEGER_SIZE} * 8")
-if(NOT _n EQUAL 32)
-  set(_num_size_cflags "-DINTSIZE${_n}")
-endif()
-
-if(HAVE_STDINT_H)
-  set(_stdint -DHAVE_STDINT_H)
-endif()
-
-set(AKANTU_SCOTCH_CFLAGS "-O3 -w -fPIC -Drestrict=__restrict -DCOMMON_RANDOM_FIXED_SEED -DSCOTCH_RENAME -DSCOTCH_RENAME_PARSER ${_zlib_cflags} ${_system_cflags} ${_architecture_cflags} ${_num_size_cflags} ${_stdint}")
-set(AKANTU_SCOTCH_LDFLAGS "${_zlib_ldflags} ${_system_ldflags} -lm")
-
-set(SCOTCH_DIR ${PROJECT_BINARY_DIR}/third-party)
-configure_file(
-  ${PROJECT_SOURCE_DIR}/third-party/scotch_${SCOTCH_VERSION}_make.inc.cmake
-  ${SCOTCH_DIR}/scotch_make.inc)
-
-include(ExternalProject)
-
-ExternalProject_Add(Scotch
-  PREFIX ${SCOTCH_DIR}
-  ${_scotch_download_command}
-  ${_extra_options}
-  PATCH_COMMAND ${PATCH_COMMAND} -p1 < ${PROJECT_SOURCE_DIR}/third-party/scotch_${SCOTCH_VERSION}.patch
-  CONFIGURE_COMMAND ${CMAKE_COMMAND} -E copy ${SCOTCH_DIR}/scotch_make.inc src/Makefile.inc
-  BUILD_IN_SOURCE 1
-  BUILD_COMMAND ${CMAKE_MAKE_PROGRAM} -C src
-  INSTALL_COMMAND ${CMAKE_MAKE_PROGRAM} prefix=<INSTALL_DIR> -C src install
-  LOG_DOWNLOAD 1
-  LOG_CONFIGURE 1
-  LOG_BUILD 1
-  LOG_INSTALL 1
-  )
-
-set_third_party_shared_libirary_name(SCOTCH_LIBRARY scotch)
-set_third_party_shared_libirary_name(SCOTCH_LIBRARY_ERR     scotcherr)
-set_third_party_shared_libirary_name(SCOTCH_LIBRARY_ERREXIT scotcherrexit)
-set_third_party_shared_libirary_name(SCOTCH_LIBRARY_ESMUMPS esmumps)
-
-set(SCOTCH_INCLUDE_DIR ${SCOTCH_DIR}/include CACHE PATH "" FORCE)
-
-mark_as_advanced(
-  SCOTCH_LIBRARY
-  SCOTCH_LIBRARY_ERR
-  SCOTCH_LIBRARY_ERREXIT
-  SCOTCH_LIBRARY_ESMUMPS
-  SCOTCH_INCLUDE_DIR)
-
-set(SCOTCH_LIBRARIES_ALL ${SCOTCH_LIBRARY} ${SCOTCH_LIBRARY_ERR})
-set(SCOTCH_LIBRARIES ${SCOTCH_LIBRARIES_ALL} CACHE INTERNAL "Libraries for scotch" FORCE)
-
-package_add_extra_dependency(Scotch Scotch)
diff --git a/third-party/iohelper/src/CMakeLists.txt b/third-party/iohelper/src/CMakeLists.txt
index 5f438689a..bbf164a4b 100644
--- a/third-party/iohelper/src/CMakeLists.txt
+++ b/third-party/iohelper/src/CMakeLists.txt
@@ -1,112 +1,114 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 #
 # @date creation: Thu Nov 24 2011
 # @date last modification: Wed Nov 13 2013
 #
 # @brief  main iohelper configuration
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # IOHelper is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # IOHelper is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with IOHelper. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #===============================================================================
 # List of source files
 #===============================================================================
 set(IOHELPER_COMMON_SRC
   dumper_lammps.cc
   dumper.cc
   dumper_paraview.cc
   dumper_text.cc
   paraview_helper.cc
 #  src/reader_restart.cpp
 )
 
 set(IOHELPER_COMMON_HEADERS
   field_inline_impl.hh
   dumper_restart.hh
   field_interface.hh
   visitor.hh
   field.hh
   variable_inline_impl.hh
   variable_interface.hh
   variable.hh
   container_array.hh
   dumper_paraview.hh
   dumper_text.hh
   paraview_helper.tcc
   iohelper_common.hh
   io_helper.hh
   dumper.hh
   file_manager.hh
   paraview_helper.hh
   dumper_C_wrapper.h
   base64.hh
   dumper_lammps.hh
   base64_reader.hh
 )
 
 #===============================================================================
 # Library creation rule
 #===============================================================================
 add_library(iohelper ${IOHELPER_COMMON_SRC})
 
 # link library with other libraries
 target_link_libraries(iohelper ${IOHELPER_EXTERNAL_LIBS})
 target_include_directories(iohelper
   PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
   INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
             $<INSTALL_INTERFACE:include/iohelper>
   PUBLIC ${ZLIB_INCLUDE_DIR} ${ZLIB_INCLUDE_DIRS}
   )
 
 
 set_target_properties(iohelper PROPERTIES PUBLIC_HEADER "${IOHELPER_COMMON_HEADERS}")
 set_property(TARGET iohelper PROPERTY CXX_STANDARD 11)
 
 export(TARGETS iohelper
   FILE "${CMAKE_BINARY_DIR}/IOHelperLibraryDepends.cmake")
 export(PACKAGE IOHelper)
 
 #===============================================================================
 # Install rules
 #===============================================================================
 # Tweak for when IOHelper is a subproject
 if(NOT IOHELPER_TARGETS_EXPORT)
   set(IOHELPER_TARGETS_EXPORT IOHelperLibraryDepends)
 endif()
 
+include(GNUInstallDirs)
+
 install(TARGETS iohelper
   EXPORT ${IOHELPER_TARGETS_EXPORT}
-  ARCHIVE DESTINATION lib COMPONENT lib
-  LIBRARY DESTINATION lib COMPONENT lib
-  RUNTIME DESTINATION lib COMPONENT lib
-  PUBLIC_HEADER DESTINATION include/iohelper COMPONENT dev
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT lib
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT lib
+  RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT lib
+  PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/iohelper COMPONENT dev
   )
 
 # Install the export set for use with the install-tree
 if("${IOHELPER_TARGETS_EXPORT}" STREQUAL "IOHelperLibraryDepends")
-  install(EXPORT IOHelperLibraryDepends DESTINATION  lib/iohelper
+  install(EXPORT IOHelperLibraryDepends DESTINATION  ${CMAKE_INSTALL_LIBDIR}/cmake/IOHelper
     COMPONENT dev)
 endif()
 
 
 set(IOHELPER_INCLUDE_DIRS ${IOHelper_SOURCE_DIR}/src CACHE INTERNAL "Internal include directorie to link with IOHelper as a subproject")
diff --git a/third-party/pybind11.cmake.in b/third-party/pybind11.cmake.in
index 1757513d7..54dd731e2 100644
--- a/third-party/pybind11.cmake.in
+++ b/third-party/pybind11.cmake.in
@@ -1,16 +1,16 @@
 cmake_minimum_required(VERSION 3.1)
 
 project(pybind11-download NONE)
 
 include(ExternalProject)
 
 ExternalProject_Add(pybind11
-  SOURCE_DIR ${PROJECT_SOURCE_DIR}/third-party/pybind11
-  BINARY_DIR ${PROJECT_BINARY_DIR}/third-party/pybind11
-  GIT_REPOSITORY ${PYBIND11_GIT}
-  GIT_TAG        ${PYBIND11_VERSION}
+  SOURCE_DIR        ${PROJECT_SOURCE_DIR}/third-party/pybind11
+  BINARY_DIR        ${PROJECT_BINARY_DIR}/third-party/pybind11
+  GIT_REPOSITORY    ${PYBIND11_GIT}
+  GIT_TAG           ${PYBIND11_VERSION}
   CONFIGURE_COMMAND ""
   BUILD_COMMAND     ""
   INSTALL_COMMAND   ""
   TEST_COMMAND      ""
   )
diff --git a/third-party/scalapack_2.0.2.patch b/third-party/scalapack_2.0.2.patch
deleted file mode 100644
index dfb84eafb..000000000
--- a/third-party/scalapack_2.0.2.patch
+++ /dev/null
@@ -1,56 +0,0 @@
-diff -Naur scalapack-2.0.2.orig/BLACS/CMakeLists.txt scalapack-2.0.2/BLACS/CMakeLists.txt
---- scalapack-2.0.2.orig/BLACS/CMakeLists.txt	2011-11-08 21:48:31.000000000 +0100
-+++ scalapack-2.0.2/BLACS/CMakeLists.txt	2014-07-01 18:29:02.766208418 +0200
-@@ -1,4 +1 @@
- add_subdirectory(SRC)
--if(BUILD_TESTING)
--  add_subdirectory(TESTING)
--endif(BUILD_TESTING)
-diff -Naur scalapack-2.0.2.orig/CMakeLists.txt scalapack-2.0.2/CMakeLists.txt
---- scalapack-2.0.2.orig/CMakeLists.txt	2012-05-02 05:58:24.000000000 +0200
-+++ scalapack-2.0.2/CMakeLists.txt	2014-07-01 18:29:02.766208418 +0200
-@@ -85,22 +85,13 @@
-   install(TARGETS ${lib} EXPORT scalapack-targets
-     ARCHIVE DESTINATION lib${LIB_SUFFIX}
-     LIBRARY DESTINATION lib${LIB_SUFFIX}
--    RUNTIME DESTINATION Testing
-   )
- endmacro()
- 
- # --------------------------------------------------
--# Testing
--SET(DART_TESTING_TIMEOUT 600)
--
--enable_testing()
--include(CTest)
--enable_testing()
--# --------------------------------------------------
- 
- # Organize output files.  On Windows this also keeps .dll files next
- # to the .exe files that need them, making tests easy to run.
--set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${SCALAPACK_BINARY_DIR}/TESTING)
- set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${SCALAPACK_BINARY_DIR}/lib)
- set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${SCALAPACK_BINARY_DIR}/lib)
- 
-@@ -243,7 +234,6 @@
-    scalapack_install_library(scalapack)
-    scalapack_install_library(scalapack-F)
- endif (UNIX)
--add_subdirectory(TESTING)
- 
- # --------------------------------------------------
- # CPACK Packaging 
-diff -Naur scalapack-2.0.2.orig/PBLAS/CMakeLists.txt scalapack-2.0.2/PBLAS/CMakeLists.txt
---- scalapack-2.0.2.orig/PBLAS/CMakeLists.txt	2011-11-08 21:48:31.000000000 +0100
-+++ scalapack-2.0.2/PBLAS/CMakeLists.txt	2014-07-01 18:29:02.766208418 +0200
-@@ -1,3 +1,1 @@
- add_subdirectory(SRC)
--add_subdirectory(TESTING)
--add_subdirectory(TIMING)
-diff -Naur scalapack-2.0.2.orig/REDIST/CMakeLists.txt scalapack-2.0.2/REDIST/CMakeLists.txt
---- scalapack-2.0.2.orig/REDIST/CMakeLists.txt	2011-11-08 21:48:31.000000000 +0100
-+++ scalapack-2.0.2/REDIST/CMakeLists.txt	2014-07-01 18:29:02.770208294 +0200
-@@ -1,2 +1,1 @@
- add_subdirectory(SRC)
--add_subdirectory(TESTING)
-
diff --git a/third-party/scotch_5.1.12b.patch b/third-party/scotch_5.1.12b.patch
deleted file mode 100644
index c18d53ba1..000000000
--- a/third-party/scotch_5.1.12b.patch
+++ /dev/null
@@ -1,193 +0,0 @@
-This patch change the makefiles of scotch to build shared libraries (It is based on the on from debian):
-Index: scotch/src/Makefile
-===================================================================
---- scotch.orig/src/Makefile
-+++ scotch/src/Makefile
-@@ -102,10 +102,10 @@
- 					(cd esmumps ;        $(MAKE)                                                                ptscotch && $(MAKE) ptinstall)
- 
- install				:	required	$(bindir)	$(includedir)	$(libdir)	$(mandir)/man1
--					-$(CP) -f ../bin/[agm]*$(EXE) $(bindir)
--					-$(CP) -f ../include/*scotch*.h $(includedir)
--					-$(CP) -f ../lib/*scotch*$(LIB) $(libdir)
--					-$(CP) -Rf ../man/* $(mandir)
-+					-$(CP) -af  ../include/* $(includedir)
-+					-$(CP) -af  ../bin/*     $(bindir)
-+					-$(CP) -af  ../lib/*     $(libdir)
-+					-$(CP) -af ../man/*     $(mandir)
- 
- clean				:	required
- 					(cd libscotch ;      $(MAKE) clean)
-Index: scotch/src/libscotchmetis/Makefile
-===================================================================
---- scotch.orig/src/libscotchmetis/Makefile
-+++ scotch/src/libscotchmetis/Makefile
-@@ -61,15 +61,15 @@
- 					libptscotchparmetis$(LIB)
- 
- install				:	scotch
--					-$(CP) metis.h $(includedir)
--					-$(CP) libscotchmetis$(LIB) $(libdir)
-+					$(CP) -a metis.h $(includedir)
-+					$(CP) -a libscotchmetis$(LIB) libscotchmetis*$(SHLIB) $(libdir)
- 
- ptinstall			:	ptscotch
--					-$(CP) parmetis.h $(includedir)
--					-$(CP) libptscotchparmetis$(LIB) $(libdir)
-+					$(CP) -a parmetis.h $(includedir)
-+					$(CP) -a libptscotchparmetis$(LIB) libptscotchparmetis*$(SHLIB) $(libdir)
- 
- clean				:
--					-$(RM) *~ *$(OBJ) lib*$(LIB)
-+					-$(RM) *~ *$(OBJ) lib*$(LIB) lib*$(SHLIB)
- 
- realclean			:	clean
- 
-@@ -129,6 +129,7 @@
- 					parmetis_dgraph_order_f$(OBJ)		\
- 					parmetis_dgraph_part$(OBJ)		\
- 					parmetis_dgraph_part_f$(OBJ)
-+					$(CC) -shared  $^ -L../libscotch -lptscotch -lscotch -o libptscotchparmetis$(SHLIB)
- 					$(AR) $(ARFLAGS) $(@) $(^)
- 					-$(RANLIB) $(@)
- 
-@@ -136,5 +138,6 @@
- 					metis_graph_order_f$(OBJ)		\
- 					metis_graph_part$(OBJ)			\
- 					metis_graph_part_f$(OBJ)
-+					$(CC) -shared $^ -L../libscotch -lscotch -lscotcherr -o libscotchmetis$(SHLIB)
- 					$(AR) $(ARFLAGS) $(@) $(^)
- 					-$(RANLIB) $(@)
-Index: scotch/src/libscotch/Makefile
-===================================================================
---- scotch.orig/src/libscotch/Makefile
-+++ scotch/src/libscotch/Makefile
-@@ -69,16 +69,16 @@
- 					libptscotcherrexit$(LIB)
- 
- install				:
--					-$(CP) scotch.h scotchf.h $(includedir)
--					-$(CP) libscotch$(LIB) libscotcherr*$(LIB) $(libdir)
-+					$(CP) -a scotch.h scotchf.h $(includedir)
-+					$(CP) -a libscotch*$(LIB) libscotch*$(SHLIB) $(libdir)
- 
- ptinstall			:
--					-$(CP) scotch.h $(includedir)/ptscotch.h
--					-$(CP) scotchf.h $(includedir)/ptscotchf.h
--					-$(CP) libptscotch*$(LIB) $(libdir)
-+					$(CP) -a scotch.h $(includedir)/ptscotch.h
-+					$(CP) -a scotchf.h $(includedir)/ptscotchf.h
-+					$(CP) -a libptscotch*$(LIB) libptscotch*$(SHLIB) $(libdir)
- 
- clean				:
--					-$(RM) *~ *$(OBJ) lib*$(LIB) parser_yy.c parser_ly.h parser_ll.c *scotch.h *scotchf.h y.output dummysizes$(EXE)
-+					-$(RM) *~ *$(OBJ) lib*.a lib*$(SHLIB) lib*$(LIB) parser_yy.c parser_ly.h parser_ll.c *scotch.h *scotchf.h y.output dummysizes$(EXE)
- 
- realclean			:	clean
- 
-@@ -2553,26 +2553,32 @@
- 					libraryf.h
- 					./dummysizes$(EXE) libraryf.h scotchf.h
- 
--libptscotch$(LIB)		:	$(LIBPTSCOTCHDEPS) $(LIBSCOTCHDEPS)
--					$(AR) $(ARFLAGS) $(@) $(?)
-+libptscotch$(LIB)		:	$(LIBPTSCOTCHDEPS) $(LIBSCOTCHDEPS) libptscotcherr$(LIB)
-+					$(CC) -shared $(LIBPTSCOTCHDEPS) $(LIBSCOTCHDEPS) -L. -lptscotcherr $(LDFLAGS) -o libptscotch$(SHLIB)
-+					$(AR) $(ARFLAGS) $(@) $(LIBPTSCOTCHDEPS) $(LIBSCOTCHDEPS)
- 					-$(RANLIB) $(@)
- 
--libscotch$(LIB)			:	$(LIBSCOTCHDEPS)
--					$(AR) $(ARFLAGS) $(@) $(?)
-+libscotch$(LIB)			:	$(LIBSCOTCHDEPS) libscotcherr$(LIB)
-+					$(CC) -shared $(LIBSCOTCHDEPS) -L. -lscotcherr $(LDFLAGS) -o libscotch$(SHLIB)
-+					$(AR) $(ARFLAGS) $(@) $(LIBSCOTCHDEPS)
- 					-$(RANLIB) $(@)
- 
- libptscotcherr$(LIB)		:	library_error$(OBJ)
-+					$(CC) -shared $^ -o libptscotcherr$(SHLIB)
- 					$(AR) $(ARFLAGS) $(@) $(?)
- 					-$(RANLIB) $(@)
- 
- libptscotcherrexit$(LIB)	:	library_error_exit$(OBJ)
-+					$(CC) -shared $^ -o libptscotcherrexit$(SHLIB)
- 					$(AR) $(ARFLAGS) $(@) $(?)
- 					-$(RANLIB) $(@)
- 
- libscotcherr$(LIB)		:	library_error$(OBJ)
-+					$(CC) -shared $^ -o libscotcherr$(SHLIB)
- 					$(AR) $(ARFLAGS) $(@) $(?)
- 					-$(RANLIB) $(@)
- 
- libscotcherrexit$(LIB)		:	library_error_exit$(OBJ)
-+					$(CC) -shared $^ -o libscotcherrexit$(SHLIB)
- 					$(AR) $(ARFLAGS) $(@) $(?)
- 					-$(RANLIB) $(@)
-Index: scotch/src/esmumps/Makefile
-===================================================================
---- scotch.orig/src/esmumps/Makefile
-+++ scotch/src/esmumps/Makefile
-@@ -44,7 +44,7 @@
- 				$(CC) $(CFLAGS) $(CLIBFLAGS) -I$(includedir) -c $(<) -o $(@)
- 
- %$(EXE)	:	%.c
--		 		$(CC) $(CFLAGS) -I$(includedir) $(<) -o $(@) -L$(libdir) $(LDFLAGS) -L. -l$(ESMUMPSLIB) -l$(SCOTCHLIB) -l$(SCOTCHLIB)errexit
-+		 		$(CC) $(CFLAGS) -I$(includedir) $(<) -o $(@) -L$(libdir) -L. -l$(ESMUMPSLIB) -l$(SCOTCHLIB) -l$(SCOTCHLIB)errexit $(LDFLAGS) -lscotch
- 
- ##
- ##  Project rules.
-@@ -59,19 +59,21 @@
- 
- ptscotch			:	clean
- 					$(MAKE) CFLAGS="$(CFLAGS) -DSCOTCH_PTSCOTCH" CC=$(CCP) SCOTCHLIB=ptscotch ESMUMPSLIB=ptesmumps	\
--					libesmumps$(LIB)										\
-+					libptesmumps$(LIB)										\
- 					main_esmumps$(EXE)
- 
- install				:
- 					-$(CP) esmumps.h $(includedir)
--					-$(CP) libesmumps$(LIB) $(libdir)
-+					-$(CP) -a libesmumps* $(libdir)
-+					-$(CP) -a main_esmumps$(EXE) $(bindir)/scotch_esmumps
- 
- ptinstall			:
- 					-$(CP) esmumps.h $(includedir)
--					-$(CP) libptesmumps$(LIB) $(libdir)
-+					-$(CP) -a libptesmumps* $(libdir)
-+					-$(CP) -a main_esmumps$(EXE) $(bindir)/ptscotch_esmumps
- 
- clean				:
--					-$(RM) *~ common.h *$(OBJ) lib*$(LIB) main_esmumps$(EXE)
-+					-$(RM) *~ common.h *$(OBJ) lib*$(LIB) lib*$(SHLIB) main_esmumps$(EXE)
- 
- realclean			:	clean
- 
-@@ -142,7 +144,7 @@
- 					common.h				\
- 					esmumps.h
- 
--libesmumps$(LIB)		:	graph_graph$(OBJ)			\
-+lib$(ESMUMPSLIB)$(LIB)		: 	graph_graph$(OBJ)			\
- 					order$(OBJ)				\
- 					order_scotch_graph$(OBJ)		\
- 					dof$(OBJ)				\
-@@ -151,6 +153,7 @@
- 					esmumps$(OBJ)				\
- 					esmumps_f$(OBJ)				\
- 					esmumps_strats$(OBJ)
-+					$(CC) -shared $^ -L../libscotch -lscotch -lscotcherr -o lib$(ESMUMPSLIB)$(SHLIB)
- 					$(AR) $(ARFLAGS) lib$(ESMUMPSLIB)$(LIB) $(?)
- 					-$(RANLIB) lib$(ESMUMPSLIB)$(LIB)
- 
-Index: scotch/src/scotch/Makefile
-===================================================================
---- scotch.orig/src/scotch/Makefile
-+++ scotch/src/scotch/Makefile
-@@ -47,7 +47,7 @@
- 				$(CC) $(CFLAGS) -I$(includedir) -I../libscotch -c $(<) -o $(@)
- 
- %$(EXE)	:	%.c
--		 		$(CC) $(CFLAGS) -I$(includedir) -I../libscotch $(<) -o $(@) -L$(libdir) -l$(SCOTCHLIB) -l$(SCOTCHLIB)errexit $(LDFLAGS)
-+		 		$(CC) $(CFLAGS) -I$(includedir) -I../libscotch $(<) -o $(@) -L$(libdir) -l$(SCOTCHLIB) -l$(SCOTCHLIB)errexit $(LDFLAGS) -lscotch
- 
- ##
- ##  Project rules.
diff --git a/third-party/scotch_5.1.12b_make.inc.cmake b/third-party/scotch_5.1.12b_make.inc.cmake
deleted file mode 100644
index 4ccdbc966..000000000
--- a/third-party/scotch_5.1.12b_make.inc.cmake
+++ /dev/null
@@ -1,22 +0,0 @@
-EXE		=
-LIB		= @CMAKE_STATIC_LIBRARY_SUFFIX@
-SHLIB		= @CMAKE_SHARED_LIBRARY_SUFFIX@
-OBJ		= @CMAKE_C_OUTPUT_EXTENSION@
-
-MAKE		= '@CMAKE_MAKE_PROGRAM@'
-AR		= '@CMAKE_AR@'
-ARFLAGS		= -ruv
-CAT		= cat
-CCS		= '@CMAKE_C_COMPILER@'
-CCP		= '@CMAKE_C_COMPILER@'
-CCD		= '@CMAKE_C_COMPILER@'
-CFLAGS		= @AKANTU_SCOTCH_CFLAGS@
-CLIBFLAGS	= -fPIC
-LDFLAGS		= @AKANTU_SCOTCH_LDFLAGS@
-CP		= cp
-LEX		= '@FLEX_EXECUTABLE@' -Pscotchyy -olex.yy.c
-LN		= '@CMAKE_COMMAND@' -E create_symlink
-MKDIR		= '@CMAKE_COMMAND@' -E make_directory
-MV		= '@CMAKE_COMMAND@' -E rename
-RANLIB		= '@CMAKE_RANLIB@'
-YACC		= '@BISON_EXECUTABLE@' -pscotchyy -y -b y
diff --git a/versioneer.py b/versioneer.py
new file mode 100644
index 000000000..480c4ab6b
--- /dev/null
+++ b/versioneer.py
@@ -0,0 +1,1861 @@
+
+# Version: 0.19
+
+"""The Versioneer - like a rocketeer, but for versions.
+
+The Versioneer
+==============
+
+* like a rocketeer, but for versions!
+* https://github.com/python-versioneer/python-versioneer
+* Brian Warner
+* License: Public Domain
+* Compatible with: Python 3.6, 3.7, 3.8, 3.9 and pypy3
+* [![Latest Version][pypi-image]][pypi-url]
+* [![Build Status][travis-image]][travis-url]
+
+This is a tool for managing a recorded version number in distutils-based
+python projects. The goal is to remove the tedious and error-prone "update
+the embedded version string" step from your release process. Making a new
+release should be as easy as recording a new tag in your version-control
+system, and maybe making new tarballs.
+
+
+## Quick Install
+
+* `pip install versioneer` to somewhere in your $PATH
+* add a `[versioneer]` section to your setup.cfg (see [Install](INSTALL.md))
+* run `versioneer install` in your source tree, commit the results
+* Verify version information with `python setup.py version`
+
+## Version Identifiers
+
+Source trees come from a variety of places:
+
+* a version-control system checkout (mostly used by developers)
+* a nightly tarball, produced by build automation
+* a snapshot tarball, produced by a web-based VCS browser, like github's
+  "tarball from tag" feature
+* a release tarball, produced by "setup.py sdist", distributed through PyPI
+
+Within each source tree, the version identifier (either a string or a number,
+this tool is format-agnostic) can come from a variety of places:
+
+* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows
+  about recent "tags" and an absolute revision-id
+* the name of the directory into which the tarball was unpacked
+* an expanded VCS keyword ($Id$, etc)
+* a `_version.py` created by some earlier build step
+
+For released software, the version identifier is closely related to a VCS
+tag. Some projects use tag names that include more than just the version
+string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool
+needs to strip the tag prefix to extract the version identifier. For
+unreleased software (between tags), the version identifier should provide
+enough information to help developers recreate the same tree, while also
+giving them an idea of roughly how old the tree is (after version 1.2, before
+version 1.3). Many VCS systems can report a description that captures this,
+for example `git describe --tags --dirty --always` reports things like
+"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the
+0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has
+uncommitted changes).
+
+The version identifier is used for multiple purposes:
+
+* to allow the module to self-identify its version: `myproject.__version__`
+* to choose a name and prefix for a 'setup.py sdist' tarball
+
+## Theory of Operation
+
+Versioneer works by adding a special `_version.py` file into your source
+tree, where your `__init__.py` can import it. This `_version.py` knows how to
+dynamically ask the VCS tool for version information at import time.
+
+`_version.py` also contains `$Revision$` markers, and the installation
+process marks `_version.py` to have this marker rewritten with a tag name
+during the `git archive` command. As a result, generated tarballs will
+contain enough information to get the proper version.
+
+To allow `setup.py` to compute a version too, a `versioneer.py` is added to
+the top level of your source tree, next to `setup.py` and the `setup.cfg`
+that configures it. This overrides several distutils/setuptools commands to
+compute the version when invoked, and changes `setup.py build` and `setup.py
+sdist` to replace `_version.py` with a small static file that contains just
+the generated version data.
+
+## Installation
+
+See [INSTALL.md](./INSTALL.md) for detailed installation instructions.
+
+## Version-String Flavors
+
+Code which uses Versioneer can learn about its version string at runtime by
+importing `_version` from your main `__init__.py` file and running the
+`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can
+import the top-level `versioneer.py` and run `get_versions()`.
+
+Both functions return a dictionary with different flavors of version
+information:
+
+* `['version']`: A condensed version string, rendered using the selected
+  style. This is the most commonly used value for the project's version
+  string. The default "pep440" style yields strings like `0.11`,
+  `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section
+  below for alternative styles.
+
+* `['full-revisionid']`: detailed revision identifier. For Git, this is the
+  full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac".
+
+* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the
+  commit date in ISO 8601 format. This will be None if the date is not
+  available.
+
+* `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that
+  this is only accurate if run in a VCS checkout, otherwise it is likely to
+  be False or None
+
+* `['error']`: if the version string could not be computed, this will be set
+  to a string describing the problem, otherwise it will be None. It may be
+  useful to throw an exception in setup.py if this is set, to avoid e.g.
+  creating tarballs with a version string of "unknown".
+
+Some variants are more useful than others. Including `full-revisionid` in a
+bug report should allow developers to reconstruct the exact code being tested
+(or indicate the presence of local changes that should be shared with the
+developers). `version` is suitable for display in an "about" box or a CLI
+`--version` output: it can be easily compared against release notes and lists
+of bugs fixed in various releases.
+
+The installer adds the following text to your `__init__.py` to place a basic
+version in `YOURPROJECT.__version__`:
+
+    from ._version import get_versions
+    __version__ = get_versions()['version']
+    del get_versions
+
+## Styles
+
+The setup.cfg `style=` configuration controls how the VCS information is
+rendered into a version string.
+
+The default style, "pep440", produces a PEP440-compliant string, equal to the
+un-prefixed tag name for actual releases, and containing an additional "local
+version" section with more detail for in-between builds. For Git, this is
+TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags
+--dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the
+tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and
+that this commit is two revisions ("+2") beyond the "0.11" tag. For released
+software (exactly equal to a known tag), the identifier will only contain the
+stripped tag, e.g. "0.11".
+
+Other styles are available. See [details.md](details.md) in the Versioneer
+source tree for descriptions.
+
+## Debugging
+
+Versioneer tries to avoid fatal errors: if something goes wrong, it will tend
+to return a version of "0+unknown". To investigate the problem, run `setup.py
+version`, which will run the version-lookup code in a verbose mode, and will
+display the full contents of `get_versions()` (including the `error` string,
+which may help identify what went wrong).
+
+## Known Limitations
+
+Some situations are known to cause problems for Versioneer. This details the
+most significant ones. More can be found on Github
+[issues page](https://github.com/python-versioneer/python-versioneer/issues).
+
+### Subprojects
+
+Versioneer has limited support for source trees in which `setup.py` is not in
+the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are
+two common reasons why `setup.py` might not be in the root:
+
+* Source trees which contain multiple subprojects, such as
+  [Buildbot](https://github.com/buildbot/buildbot), which contains both
+  "master" and "slave" subprojects, each with their own `setup.py`,
+  `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI
+  distributions (and upload multiple independently-installable tarballs).
+* Source trees whose main purpose is to contain a C library, but which also
+  provide bindings to Python (and perhaps other languages) in subdirectories.
+
+Versioneer will look for `.git` in parent directories, and most operations
+should get the right version string. However `pip` and `setuptools` have bugs
+and implementation details which frequently cause `pip install .` from a
+subproject directory to fail to find a correct version string (so it usually
+defaults to `0+unknown`).
+
+`pip install --editable .` should work correctly. `setup.py install` might
+work too.
+
+Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in
+some later version.
+
+[Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking
+this issue. The discussion in
+[PR #61](https://github.com/python-versioneer/python-versioneer/pull/61) describes the
+issue from the Versioneer side in more detail.
+[pip PR#3176](https://github.com/pypa/pip/pull/3176) and
+[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve
+pip to let Versioneer work correctly.
+
+Versioneer-0.16 and earlier only looked for a `.git` directory next to the
+`setup.cfg`, so subprojects were completely unsupported with those releases.
+
+### Editable installs with setuptools <= 18.5
+
+`setup.py develop` and `pip install --editable .` allow you to install a
+project into a virtualenv once, then continue editing the source code (and
+test) without re-installing after every change.
+
+"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a
+convenient way to specify executable scripts that should be installed along
+with the python package.
+
+These both work as expected when using modern setuptools. When using
+setuptools-18.5 or earlier, however, certain operations will cause
+`pkg_resources.DistributionNotFound` errors when running the entrypoint
+script, which must be resolved by re-installing the package. This happens
+when the install happens with one version, then the egg_info data is
+regenerated while a different version is checked out. Many setup.py commands
+cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into
+a different virtualenv), so this can be surprising.
+
+[Bug #83](https://github.com/python-versioneer/python-versioneer/issues/83) describes
+this one, but upgrading to a newer version of setuptools should probably
+resolve it.
+
+
+## Updating Versioneer
+
+To upgrade your project to a new release of Versioneer, do the following:
+
+* install the new Versioneer (`pip install -U versioneer` or equivalent)
+* edit `setup.cfg`, if necessary, to include any new configuration settings
+  indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details.
+* re-run `versioneer install` in your source tree, to replace
+  `SRC/_version.py`
+* commit any changed files
+
+## Future Directions
+
+This tool is designed to make it easily extended to other version-control
+systems: all VCS-specific components are in separate directories like
+src/git/ . The top-level `versioneer.py` script is assembled from these
+components by running make-versioneer.py . In the future, make-versioneer.py
+will take a VCS name as an argument, and will construct a version of
+`versioneer.py` that is specific to the given VCS. It might also take the
+configuration arguments that are currently provided manually during
+installation by editing setup.py . Alternatively, it might go the other
+direction and include code from all supported VCS systems, reducing the
+number of intermediate scripts.
+
+## Similar projects
+
+* [setuptools_scm](https://github.com/pypa/setuptools_scm/) - a non-vendored build-time
+  dependency
+* [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of
+  versioneer
+
+## License
+
+To make Versioneer easier to embed, all its code is dedicated to the public
+domain. The `_version.py` that it creates is also in the public domain.
+Specifically, both are released under the Creative Commons "Public Domain
+Dedication" license (CC0-1.0), as described in
+https://creativecommons.org/publicdomain/zero/1.0/ .
+
+[pypi-image]: https://img.shields.io/pypi/v/versioneer.svg
+[pypi-url]: https://pypi.python.org/pypi/versioneer/
+[travis-image]:
+https://img.shields.io/travis/com/python-versioneer/python-versioneer.svg
+[travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer
+
+"""
+
+import configparser
+import errno
+import json
+import os
+import re
+import subprocess
+import sys
+
+
+class VersioneerConfig:
+    """Container for Versioneer configuration parameters."""
+
+
+def get_root():
+    """Get the project root directory.
+
+    We require that all commands are run from the project root, i.e. the
+    directory that contains setup.py, setup.cfg, and versioneer.py .
+    """
+    root = os.path.realpath(os.path.abspath(os.getcwd()))
+    setup_py = os.path.join(root, "setup.py")
+    versioneer_py = os.path.join(root, "versioneer.py")
+    if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):
+        # allow 'python path/to/setup.py COMMAND'
+        root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0])))
+        setup_py = os.path.join(root, "setup.py")
+        versioneer_py = os.path.join(root, "versioneer.py")
+    if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)):
+        err = ("Versioneer was unable to run the project root directory. "
+               "Versioneer requires setup.py to be executed from "
+               "its immediate directory (like 'python setup.py COMMAND'), "
+               "or in a way that lets it use sys.argv[0] to find the root "
+               "(like 'python path/to/setup.py COMMAND').")
+        raise VersioneerBadRootError(err)
+    try:
+        # Certain runtime workflows (setup.py install/develop in a setuptools
+        # tree) execute all dependencies in a single python process, so
+        # "versioneer" may be imported multiple times, and python's shared
+        # module-import table will cache the first one. So we can't use
+        # os.path.dirname(__file__), as that will find whichever
+        # versioneer.py was first imported, even in later projects.
+        me = os.path.realpath(os.path.abspath(__file__))
+        me_dir = os.path.normcase(os.path.splitext(me)[0])
+        vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0])
+        if me_dir != vsr_dir:
+            print("Warning: build in %s is using versioneer.py from %s"
+                  % (os.path.dirname(me), versioneer_py))
+    except NameError:
+        pass
+    return root
+
+
+def get_config_from_root(root):
+    """Read the project setup.cfg file to determine Versioneer config."""
+    # This might raise EnvironmentError (if setup.cfg is missing), or
+    # configparser.NoSectionError (if it lacks a [versioneer] section), or
+    # configparser.NoOptionError (if it lacks "VCS="). See the docstring at
+    # the top of versioneer.py for instructions on writing your setup.cfg .
+    setup_cfg = os.path.join(root, "setup.cfg")
+    parser = configparser.ConfigParser()
+    with open(setup_cfg, "r") as f:
+        parser.read_file(f)
+    VCS = parser.get("versioneer", "VCS")  # mandatory
+
+    def get(parser, name):
+        if parser.has_option("versioneer", name):
+            return parser.get("versioneer", name)
+        return None
+    cfg = VersioneerConfig()
+    cfg.VCS = VCS
+    cfg.style = get(parser, "style") or ""
+    cfg.versionfile_source = get(parser, "versionfile_source")
+    cfg.versionfile_build = get(parser, "versionfile_build")
+    cfg.tag_prefix = get(parser, "tag_prefix")
+    if cfg.tag_prefix in ("''", '""'):
+        cfg.tag_prefix = ""
+    cfg.parentdir_prefix = get(parser, "parentdir_prefix")
+    cfg.verbose = get(parser, "verbose")
+    cfg.vcs_root = get(parser, "vcs_root")
+    return cfg
+
+
+class NotThisMethod(Exception):
+    """Exception raised if a method is not valid for the current scenario."""
+
+
+# these dictionaries contain VCS-specific tools
+LONG_VERSION_PY = {}
+HANDLERS = {}
+
+
+def register_vcs_handler(vcs, method):  # decorator
+    """Create decorator to mark a method as the handler of a VCS."""
+    def decorate(f):
+        """Store f in HANDLERS[vcs][method]."""
+        if vcs not in HANDLERS:
+            HANDLERS[vcs] = {}
+        HANDLERS[vcs][method] = f
+        return f
+    return decorate
+
+
+def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
+                env=None):
+    """Call the given command(s)."""
+    assert isinstance(commands, list)
+    p = None
+    for c in commands:
+        try:
+            dispcmd = str([c] + args)
+            # remember shell=False, so use git.cmd on windows, not just git
+            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
+                                 stdout=subprocess.PIPE,
+                                 stderr=(subprocess.PIPE if hide_stderr
+                                         else None))
+            break
+        except EnvironmentError:
+            e = sys.exc_info()[1]
+            if e.errno == errno.ENOENT:
+                continue
+            if verbose:
+                print("unable to run %s" % dispcmd)
+                print(e)
+            return None, None
+    else:
+        if verbose:
+            print("unable to find command, tried %s" % (commands,))
+        return None, None
+    stdout = p.communicate()[0].strip().decode()
+    if p.returncode != 0:
+        if verbose:
+            print("unable to run %s (error)" % dispcmd)
+            print("stdout was %s" % stdout)
+        return None, p.returncode
+    return stdout, p.returncode
+
+
+LONG_VERSION_PY['git'] = r'''
+# This file helps to compute a version number in source trees obtained from
+# git-archive tarball (such as those provided by githubs download-from-tag
+# feature). Distribution tarballs (built by setup.py sdist) and build
+# directories (produced by setup.py build) will contain a much shorter file
+# that just contains the computed version number.
+
+# This file is released into the public domain. Generated by
+# versioneer-0.19 (https://github.com/python-versioneer/python-versioneer)
+
+"""Git implementation of _version.py."""
+
+import errno
+import os
+import re
+import subprocess
+import sys
+
+
+def get_keywords():
+    """Get the keywords needed to look up the version information."""
+    # these strings will be replaced by git during git-archive.
+    # setup.py/versioneer.py will grep for the variable names, so they must
+    # each be defined on a line of their own. _version.py will just call
+    # get_keywords().
+    git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s"
+    git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s"
+    git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s"
+    keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
+    return keywords
+
+
+class VersioneerConfig:
+    """Container for Versioneer configuration parameters."""
+
+
+def get_config():
+    """Create, populate and return the VersioneerConfig() object."""
+    # these strings are filled in when 'setup.py versioneer' creates
+    # _version.py
+    cfg = VersioneerConfig()
+    cfg.VCS = "git"
+    cfg.style = "%(STYLE)s"
+    cfg.tag_prefix = "%(TAG_PREFIX)s"
+    cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s"
+    cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s"
+    cfg.verbose = False
+    return cfg
+
+
+class NotThisMethod(Exception):
+    """Exception raised if a method is not valid for the current scenario."""
+
+
+LONG_VERSION_PY = {}
+HANDLERS = {}
+
+
+def register_vcs_handler(vcs, method):  # decorator
+    """Create decorator to mark a method as the handler of a VCS."""
+    def decorate(f):
+        """Store f in HANDLERS[vcs][method]."""
+        if vcs not in HANDLERS:
+            HANDLERS[vcs] = {}
+        HANDLERS[vcs][method] = f
+        return f
+    return decorate
+
+
+def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
+                env=None):
+    """Call the given command(s)."""
+    assert isinstance(commands, list)
+    p = None
+    for c in commands:
+        try:
+            dispcmd = str([c] + args)
+            # remember shell=False, so use git.cmd on windows, not just git
+            p = subprocess.Popen([c] + args, cwd=cwd, env=env,
+                                 stdout=subprocess.PIPE,
+                                 stderr=(subprocess.PIPE if hide_stderr
+                                         else None))
+            break
+        except EnvironmentError:
+            e = sys.exc_info()[1]
+            if e.errno == errno.ENOENT:
+                continue
+            if verbose:
+                print("unable to run %%s" %% dispcmd)
+                print(e)
+            return None, None
+    else:
+        if verbose:
+            print("unable to find command, tried %%s" %% (commands,))
+        return None, None
+    stdout = p.communicate()[0].strip().decode()
+    if p.returncode != 0:
+        if verbose:
+            print("unable to run %%s (error)" %% dispcmd)
+            print("stdout was %%s" %% stdout)
+        return None, p.returncode
+    return stdout, p.returncode
+
+
+def versions_from_parentdir(parentdir_prefix, root, verbose):
+    """Try to determine the version from the parent directory name.
+
+    Source tarballs conventionally unpack into a directory that includes both
+    the project name and a version string. We will also support searching up
+    two directory levels for an appropriately named parent directory
+    """
+    rootdirs = []
+
+    for i in range(3):
+        dirname = os.path.basename(root)
+        if dirname.startswith(parentdir_prefix):
+            return {"version": dirname[len(parentdir_prefix):],
+                    "full-revisionid": None,
+                    "dirty": False, "error": None, "date": None}
+        else:
+            rootdirs.append(root)
+            root = os.path.dirname(root)  # up a level
+
+    if verbose:
+        print("Tried directories %%s but none started with prefix %%s" %%
+              (str(rootdirs), parentdir_prefix))
+    raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
+
+
+@register_vcs_handler("git", "get_keywords")
+def git_get_keywords(versionfile_abs):
+    """Extract version information from the given file."""
+    # the code embedded in _version.py can just fetch the value of these
+    # keywords. When used from setup.py, we don't want to import _version.py,
+    # so we do it with a regexp instead. This function is not used from
+    # _version.py.
+    keywords = {}
+    try:
+        f = open(versionfile_abs, "r")
+        for line in f.readlines():
+            if line.strip().startswith("git_refnames ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["refnames"] = mo.group(1)
+            if line.strip().startswith("git_full ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["full"] = mo.group(1)
+            if line.strip().startswith("git_date ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["date"] = mo.group(1)
+        f.close()
+    except EnvironmentError:
+        pass
+    return keywords
+
+
+@register_vcs_handler("git", "keywords")
+def git_versions_from_keywords(keywords, tag_prefix, verbose):
+    """Get version information from git keywords."""
+    if not keywords:
+        raise NotThisMethod("no keywords at all, weird")
+    date = keywords.get("date")
+    if date is not None:
+        # Use only the last line.  Previous lines may contain GPG signature
+        # information.
+        date = date.splitlines()[-1]
+
+        # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant
+        # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601
+        # -like" string, which we must then edit to make compliant), because
+        # it's been around since git-1.5.3, and it's too difficult to
+        # discover which version we're using, or to work around using an
+        # older one.
+        date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
+    refnames = keywords["refnames"].strip()
+    if refnames.startswith("$Format"):
+        if verbose:
+            print("keywords are unexpanded, not using")
+        raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
+    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
+    # just "foo-1.0". If we see a "tag: " prefix, prefer those.
+    TAG = "tag: "
+    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    if not tags:
+        # Either we're using git < 1.8.3, or there really are no tags. We use
+        # a heuristic: assume all version tags have a digit. The old git %%d
+        # expansion behaves like git log --decorate=short and strips out the
+        # refs/heads/ and refs/tags/ prefixes that would let us distinguish
+        # between branches and tags. By ignoring refnames without digits, we
+        # filter out many common branch names like "release" and
+        # "stabilization", as well as "HEAD" and "master".
+        tags = set([r for r in refs if re.search(r'\d', r)])
+        if verbose:
+            print("discarding '%%s', no digits" %% ",".join(refs - tags))
+    if verbose:
+        print("likely tags: %%s" %% ",".join(sorted(tags)))
+    for ref in sorted(tags):
+        # sorting will prefer e.g. "2.0" over "2.0rc1"
+        if ref.startswith(tag_prefix):
+            r = ref[len(tag_prefix):]
+            if verbose:
+                print("picking %%s" %% r)
+            return {"version": r,
+                    "full-revisionid": keywords["full"].strip(),
+                    "dirty": False, "error": None,
+                    "date": date}
+    # no suitable tags, so version is "0+unknown", but full hex is still there
+    if verbose:
+        print("no suitable tags, using unknown + full revision id")
+    return {"version": "0+unknown",
+            "full-revisionid": keywords["full"].strip(),
+            "dirty": False, "error": "no suitable tags", "date": None}
+
+
+@register_vcs_handler("git", "pieces_from_vcs")
+def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+    """Get version from 'git describe' in the root of the source tree.
+
+    This only gets called if the git-archive 'subst' keywords were *not*
+    expanded, and _version.py hasn't already been rewritten with a short
+    version string, meaning we're inside a checked out source tree.
+    """
+    GITS = ["git"]
+    if sys.platform == "win32":
+        GITS = ["git.cmd", "git.exe"]
+
+    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                          hide_stderr=True)
+    if rc != 0:
+        if verbose:
+            print("Directory %%s not under git control" %% root)
+        raise NotThisMethod("'git rev-parse --git-dir' returned error")
+
+    # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
+    # if there isn't one, this yields HEX[-dirty] (no NUM)
+    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
+                                          "--always", "--long",
+                                          "--match", "%%s*" %% tag_prefix],
+                                   cwd=root)
+    # --long was added in git-1.5.5
+    if describe_out is None:
+        raise NotThisMethod("'git describe' failed")
+    describe_out = describe_out.strip()
+    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    if full_out is None:
+        raise NotThisMethod("'git rev-parse' failed")
+    full_out = full_out.strip()
+
+    pieces = {}
+    pieces["long"] = full_out
+    pieces["short"] = full_out[:7]  # maybe improved later
+    pieces["error"] = None
+
+    # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
+    # TAG might have hyphens.
+    git_describe = describe_out
+
+    # look for -dirty suffix
+    dirty = git_describe.endswith("-dirty")
+    pieces["dirty"] = dirty
+    if dirty:
+        git_describe = git_describe[:git_describe.rindex("-dirty")]
+
+    # now we have TAG-NUM-gHEX or HEX
+
+    if "-" in git_describe:
+        # TAG-NUM-gHEX
+        mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
+        if not mo:
+            # unparseable. Maybe git-describe is misbehaving?
+            pieces["error"] = ("unable to parse git-describe output: '%%s'"
+                               %% describe_out)
+            return pieces
+
+        # tag
+        full_tag = mo.group(1)
+        if not full_tag.startswith(tag_prefix):
+            if verbose:
+                fmt = "tag '%%s' doesn't start with prefix '%%s'"
+                print(fmt %% (full_tag, tag_prefix))
+            pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'"
+                               %% (full_tag, tag_prefix))
+            return pieces
+        pieces["closest-tag"] = full_tag[len(tag_prefix):]
+
+        # distance: number of commits since tag
+        pieces["distance"] = int(mo.group(2))
+
+        # commit: short hex revision ID
+        pieces["short"] = mo.group(3)
+
+    else:
+        # HEX: no tags
+        pieces["closest-tag"] = None
+        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
+                                    cwd=root)
+        pieces["distance"] = int(count_out)  # total number of commits
+
+    # commit date: see ISO-8601 comment in git_versions_from_keywords()
+    date = run_command(GITS, ["show", "-s", "--format=%%ci", "HEAD"],
+                       cwd=root)[0].strip()
+    # Use only the last line.  Previous lines may contain GPG signature
+    # information.
+    date = date.splitlines()[-1]
+    pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
+
+    return pieces
+
+
+def plus_or_dot(pieces):
+    """Return a + if we don't already have one, else return a ."""
+    if "+" in pieces.get("closest-tag", ""):
+        return "."
+    return "+"
+
+
+def render_pep440(pieces):
+    """Build up version string, with post-release "local version identifier".
+
+    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
+    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
+
+    Exceptions:
+    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += plus_or_dot(pieces)
+            rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def render_pep440_pre(pieces):
+    """TAG[.post0.devDISTANCE] -- No -dirty.
+
+    Exceptions:
+    1: no tags. 0.post0.devDISTANCE
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"]:
+            rendered += ".post0.dev%%d" %% pieces["distance"]
+    else:
+        # exception #1
+        rendered = "0.post0.dev%%d" %% pieces["distance"]
+    return rendered
+
+
+def render_pep440_post(pieces):
+    """TAG[.postDISTANCE[.dev0]+gHEX] .
+
+    The ".dev0" means dirty. Note that .dev0 sorts backwards
+    (a dirty tree will appear "older" than the corresponding clean one),
+    but you shouldn't be releasing software with -dirty anyways.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%%d" %% pieces["distance"]
+            if pieces["dirty"]:
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%%s" %% pieces["short"]
+    else:
+        # exception #1
+        rendered = "0.post%%d" %% pieces["distance"]
+        if pieces["dirty"]:
+            rendered += ".dev0"
+        rendered += "+g%%s" %% pieces["short"]
+    return rendered
+
+
+def render_pep440_old(pieces):
+    """TAG[.postDISTANCE[.dev0]] .
+
+    The ".dev0" means dirty.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%%d" %% pieces["distance"]
+            if pieces["dirty"]:
+                rendered += ".dev0"
+    else:
+        # exception #1
+        rendered = "0.post%%d" %% pieces["distance"]
+        if pieces["dirty"]:
+            rendered += ".dev0"
+    return rendered
+
+
+def render_git_describe(pieces):
+    """TAG[-DISTANCE-gHEX][-dirty].
+
+    Like 'git describe --tags --dirty --always'.
+
+    Exceptions:
+    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"]:
+            rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"])
+    else:
+        # exception #1
+        rendered = pieces["short"]
+    if pieces["dirty"]:
+        rendered += "-dirty"
+    return rendered
+
+
+def render_git_describe_long(pieces):
+    """TAG-DISTANCE-gHEX[-dirty].
+
+    Like 'git describe --tags --dirty --always -long'.
+    The distance/hash is unconditional.
+
+    Exceptions:
+    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"])
+    else:
+        # exception #1
+        rendered = pieces["short"]
+    if pieces["dirty"]:
+        rendered += "-dirty"
+    return rendered
+
+
+def render(pieces, style):
+    """Render the given version pieces into the requested style."""
+    if pieces["error"]:
+        return {"version": "unknown",
+                "full-revisionid": pieces.get("long"),
+                "dirty": None,
+                "error": pieces["error"],
+                "date": None}
+
+    if not style or style == "default":
+        style = "pep440"  # the default
+
+    if style == "pep440":
+        rendered = render_pep440(pieces)
+    elif style == "pep440-pre":
+        rendered = render_pep440_pre(pieces)
+    elif style == "pep440-post":
+        rendered = render_pep440_post(pieces)
+    elif style == "pep440-old":
+        rendered = render_pep440_old(pieces)
+    elif style == "git-describe":
+        rendered = render_git_describe(pieces)
+    elif style == "git-describe-long":
+        rendered = render_git_describe_long(pieces)
+    else:
+        raise ValueError("unknown style '%%s'" %% style)
+
+    return {"version": rendered, "full-revisionid": pieces["long"],
+            "dirty": pieces["dirty"], "error": None,
+            "date": pieces.get("date")}
+
+
+def get_versions():
+    """Get version information or return default if unable to do so."""
+    # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
+    # __file__, we can work backwards from there to the root. Some
+    # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
+    # case we can only use expanded keywords.
+
+    cfg = get_config()
+    verbose = cfg.verbose
+
+    try:
+        return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
+                                          verbose)
+    except NotThisMethod:
+        pass
+
+    try:
+        root = os.path.realpath(__file__)
+        # versionfile_source is the relative path from the top of the source
+        # tree (where the .git directory might live) to this file. Invert
+        # this to find the root from __file__.
+        for i in cfg.versionfile_source.split('/'):
+            root = os.path.dirname(root)
+    except NameError:
+        return {"version": "0+unknown", "full-revisionid": None,
+                "dirty": None,
+                "error": "unable to find root of source tree",
+                "date": None}
+
+    try:
+        pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
+        return render(pieces, cfg.style)
+    except NotThisMethod:
+        pass
+
+    try:
+        if cfg.parentdir_prefix:
+            return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
+    except NotThisMethod:
+        pass
+
+    return {"version": "0+unknown", "full-revisionid": None,
+            "dirty": None,
+            "error": "unable to compute version", "date": None}
+'''
+
+
+@register_vcs_handler("git", "get_keywords")
+def git_get_keywords(versionfile_abs):
+    """Extract version information from the given file."""
+    # the code embedded in _version.py can just fetch the value of these
+    # keywords. When used from setup.py, we don't want to import _version.py,
+    # so we do it with a regexp instead. This function is not used from
+    # _version.py.
+    keywords = {}
+    try:
+        f = open(versionfile_abs, "r")
+        for line in f.readlines():
+            if line.strip().startswith("git_refnames ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["refnames"] = mo.group(1)
+            if line.strip().startswith("git_full ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["full"] = mo.group(1)
+            if line.strip().startswith("git_date ="):
+                mo = re.search(r'=\s*"(.*)"', line)
+                if mo:
+                    keywords["date"] = mo.group(1)
+        f.close()
+    except EnvironmentError:
+        pass
+    return keywords
+
+
+@register_vcs_handler("git", "keywords")
+def git_versions_from_keywords(keywords, tag_prefix, verbose):
+    """Get version information from git keywords."""
+    if not keywords:
+        raise NotThisMethod("no keywords at all, weird")
+    date = keywords.get("date")
+    if date is not None:
+        # Use only the last line.  Previous lines may contain GPG signature
+        # information.
+        date = date.splitlines()[-1]
+
+        # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
+        # datestamp. However we prefer "%ci" (which expands to an "ISO-8601
+        # -like" string, which we must then edit to make compliant), because
+        # it's been around since git-1.5.3, and it's too difficult to
+        # discover which version we're using, or to work around using an
+        # older one.
+        date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
+    refnames = keywords["refnames"].strip()
+    if refnames.startswith("$Format"):
+        if verbose:
+            print("keywords are unexpanded, not using")
+        raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
+    refs = set([r.strip() for r in refnames.strip("()").split(",")])
+    # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
+    # just "foo-1.0". If we see a "tag: " prefix, prefer those.
+    TAG = "tag: "
+    tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
+    if not tags:
+        # Either we're using git < 1.8.3, or there really are no tags. We use
+        # a heuristic: assume all version tags have a digit. The old git %d
+        # expansion behaves like git log --decorate=short and strips out the
+        # refs/heads/ and refs/tags/ prefixes that would let us distinguish
+        # between branches and tags. By ignoring refnames without digits, we
+        # filter out many common branch names like "release" and
+        # "stabilization", as well as "HEAD" and "master".
+        tags = set([r for r in refs if re.search(r'\d', r)])
+        if verbose:
+            print("discarding '%s', no digits" % ",".join(refs - tags))
+    if verbose:
+        print("likely tags: %s" % ",".join(sorted(tags)))
+    for ref in sorted(tags):
+        # sorting will prefer e.g. "2.0" over "2.0rc1"
+        if ref.startswith(tag_prefix):
+            r = ref[len(tag_prefix):]
+            if verbose:
+                print("picking %s" % r)
+            return {"version": r,
+                    "full-revisionid": keywords["full"].strip(),
+                    "dirty": False, "error": None,
+                    "date": date}
+    # no suitable tags, so version is "0+unknown", but full hex is still there
+    if verbose:
+        print("no suitable tags, using unknown + full revision id")
+    return {"version": "0+unknown",
+            "full-revisionid": keywords["full"].strip(),
+            "dirty": False, "error": "no suitable tags", "date": None}
+
+
+@register_vcs_handler("git", "pieces_from_vcs")
+def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
+    """Get version from 'git describe' in the root of the source tree.
+
+    This only gets called if the git-archive 'subst' keywords were *not*
+    expanded, and _version.py hasn't already been rewritten with a short
+    version string, meaning we're inside a checked out source tree.
+    """
+    GITS = ["git"]
+    if sys.platform == "win32":
+        GITS = ["git.cmd", "git.exe"]
+
+    out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
+                          hide_stderr=True)
+    if rc != 0:
+        if verbose:
+            print("Directory %s not under git control" % root)
+        raise NotThisMethod("'git rev-parse --git-dir' returned error")
+
+    # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
+    # if there isn't one, this yields HEX[-dirty] (no NUM)
+    describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
+                                          "--always", "--long",
+                                          "--match", "%s*" % tag_prefix],
+                                   cwd=root)
+    # --long was added in git-1.5.5
+    if describe_out is None:
+        raise NotThisMethod("'git describe' failed")
+    describe_out = describe_out.strip()
+    full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
+    if full_out is None:
+        raise NotThisMethod("'git rev-parse' failed")
+    full_out = full_out.strip()
+
+    pieces = {}
+    pieces["long"] = full_out
+    pieces["short"] = full_out[:7]  # maybe improved later
+    pieces["error"] = None
+
+    # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
+    # TAG might have hyphens.
+    git_describe = describe_out
+
+    # look for -dirty suffix
+    dirty = git_describe.endswith("-dirty")
+    pieces["dirty"] = dirty
+    if dirty:
+        git_describe = git_describe[:git_describe.rindex("-dirty")]
+
+    # now we have TAG-NUM-gHEX or HEX
+
+    if "-" in git_describe:
+        # TAG-NUM-gHEX
+        mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
+        if not mo:
+            # unparseable. Maybe git-describe is misbehaving?
+            pieces["error"] = ("unable to parse git-describe output: '%s'"
+                               % describe_out)
+            return pieces
+
+        # tag
+        full_tag = mo.group(1)
+        if not full_tag.startswith(tag_prefix):
+            if verbose:
+                fmt = "tag '%s' doesn't start with prefix '%s'"
+                print(fmt % (full_tag, tag_prefix))
+            pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"
+                               % (full_tag, tag_prefix))
+            return pieces
+        pieces["closest-tag"] = full_tag[len(tag_prefix):]
+
+        # distance: number of commits since tag
+        pieces["distance"] = int(mo.group(2))
+
+        # commit: short hex revision ID
+        pieces["short"] = mo.group(3)
+
+    else:
+        # HEX: no tags
+        pieces["closest-tag"] = None
+        count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
+                                    cwd=root)
+        pieces["distance"] = int(count_out)  # total number of commits
+
+    # commit date: see ISO-8601 comment in git_versions_from_keywords()
+    date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
+                       cwd=root)[0].strip()
+    # Use only the last line.  Previous lines may contain GPG signature
+    # information.
+    date = date.splitlines()[-1]
+    pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
+
+    return pieces
+
+
+def do_vcs_install(manifest_in, versionfile_source, ipy):
+    """Git-specific installation logic for Versioneer.
+
+    For Git, this means creating/changing .gitattributes to mark _version.py
+    for export-subst keyword substitution.
+    """
+    GITS = ["git"]
+    if sys.platform == "win32":
+        GITS = ["git.cmd", "git.exe"]
+    files = [manifest_in, versionfile_source]
+    if ipy:
+        files.append(ipy)
+    try:
+        me = __file__
+        if me.endswith(".pyc") or me.endswith(".pyo"):
+            me = os.path.splitext(me)[0] + ".py"
+        versioneer_file = os.path.relpath(me)
+    except NameError:
+        versioneer_file = "versioneer.py"
+    files.append(versioneer_file)
+    present = False
+    try:
+        f = open(".gitattributes", "r")
+        for line in f.readlines():
+            if line.strip().startswith(versionfile_source):
+                if "export-subst" in line.strip().split()[1:]:
+                    present = True
+        f.close()
+    except EnvironmentError:
+        pass
+    if not present:
+        f = open(".gitattributes", "a+")
+        f.write("%s export-subst\n" % versionfile_source)
+        f.close()
+        files.append(".gitattributes")
+    run_command(GITS, ["add", "--"] + files)
+
+
+def versions_from_parentdir(parentdir_prefix, root, verbose):
+    """Try to determine the version from the parent directory name.
+
+    Source tarballs conventionally unpack into a directory that includes both
+    the project name and a version string. We will also support searching up
+    two directory levels for an appropriately named parent directory
+    """
+    rootdirs = []
+
+    for i in range(3):
+        dirname = os.path.basename(root)
+        if dirname.startswith(parentdir_prefix):
+            return {"version": dirname[len(parentdir_prefix):],
+                    "full-revisionid": None,
+                    "dirty": False, "error": None, "date": None}
+        else:
+            rootdirs.append(root)
+            root = os.path.dirname(root)  # up a level
+
+    if verbose:
+        print("Tried directories %s but none started with prefix %s" %
+              (str(rootdirs), parentdir_prefix))
+    raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
+
+
+SHORT_VERSION_PY = """
+# This file was generated by 'versioneer.py' (0.19) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+%s
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)
+"""
+
+
+def versions_from_file(filename):
+    """Try to determine the version from _version.py if present."""
+    try:
+        with open(filename) as f:
+            contents = f.read()
+    except EnvironmentError:
+        raise NotThisMethod("unable to read _version.py")
+    mo = re.search(r"version_json = '''\n(.*)'''  # END VERSION_JSON",
+                   contents, re.M | re.S)
+    if not mo:
+        mo = re.search(r"version_json = '''\r\n(.*)'''  # END VERSION_JSON",
+                       contents, re.M | re.S)
+    if not mo:
+        raise NotThisMethod("no version_json in _version.py")
+    return json.loads(mo.group(1))
+
+
+def write_to_version_file(filename, versions):
+    """Write the given version number to the given _version.py file."""
+    os.unlink(filename)
+    contents = json.dumps(versions, sort_keys=True,
+                          indent=1, separators=(",", ": "))
+    with open(filename, "w") as f:
+        f.write(SHORT_VERSION_PY % contents)
+
+    print("set %s to '%s'" % (filename, versions["version"]))
+
+
+def plus_or_dot(pieces):
+    """Return a + if we don't already have one, else return a ."""
+    if "+" in pieces.get("closest-tag", ""):
+        return "."
+    return "+"
+
+
+def render_pep440(pieces):
+    """Build up version string, with post-release "local version identifier".
+
+    Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
+    get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
+
+    Exceptions:
+    1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += plus_or_dot(pieces)
+            rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
+            if pieces["dirty"]:
+                rendered += ".dirty"
+    else:
+        # exception #1
+        rendered = "0+untagged.%d.g%s" % (pieces["distance"],
+                                          pieces["short"])
+        if pieces["dirty"]:
+            rendered += ".dirty"
+    return rendered
+
+
+def render_pep440_pre(pieces):
+    """TAG[.post0.devDISTANCE] -- No -dirty.
+
+    Exceptions:
+    1: no tags. 0.post0.devDISTANCE
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"]:
+            rendered += ".post0.dev%d" % pieces["distance"]
+    else:
+        # exception #1
+        rendered = "0.post0.dev%d" % pieces["distance"]
+    return rendered
+
+
+def render_pep440_post(pieces):
+    """TAG[.postDISTANCE[.dev0]+gHEX] .
+
+    The ".dev0" means dirty. Note that .dev0 sorts backwards
+    (a dirty tree will appear "older" than the corresponding clean one),
+    but you shouldn't be releasing software with -dirty anyways.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%d" % pieces["distance"]
+            if pieces["dirty"]:
+                rendered += ".dev0"
+            rendered += plus_or_dot(pieces)
+            rendered += "g%s" % pieces["short"]
+    else:
+        # exception #1
+        rendered = "0.post%d" % pieces["distance"]
+        if pieces["dirty"]:
+            rendered += ".dev0"
+        rendered += "+g%s" % pieces["short"]
+    return rendered
+
+
+def render_pep440_old(pieces):
+    """TAG[.postDISTANCE[.dev0]] .
+
+    The ".dev0" means dirty.
+
+    Exceptions:
+    1: no tags. 0.postDISTANCE[.dev0]
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"] or pieces["dirty"]:
+            rendered += ".post%d" % pieces["distance"]
+            if pieces["dirty"]:
+                rendered += ".dev0"
+    else:
+        # exception #1
+        rendered = "0.post%d" % pieces["distance"]
+        if pieces["dirty"]:
+            rendered += ".dev0"
+    return rendered
+
+
+def render_git_describe(pieces):
+    """TAG[-DISTANCE-gHEX][-dirty].
+
+    Like 'git describe --tags --dirty --always'.
+
+    Exceptions:
+    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        if pieces["distance"]:
+            rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
+    else:
+        # exception #1
+        rendered = pieces["short"]
+    if pieces["dirty"]:
+        rendered += "-dirty"
+    return rendered
+
+
+def render_git_describe_long(pieces):
+    """TAG-DISTANCE-gHEX[-dirty].
+
+    Like 'git describe --tags --dirty --always -long'.
+    The distance/hash is unconditional.
+
+    Exceptions:
+    1: no tags. HEX[-dirty]  (note: no 'g' prefix)
+    """
+    if pieces["closest-tag"]:
+        rendered = pieces["closest-tag"]
+        rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
+    else:
+        # exception #1
+        rendered = pieces["short"]
+    if pieces["dirty"]:
+        rendered += "-dirty"
+    return rendered
+
+
+def render(pieces, style):
+    """Render the given version pieces into the requested style."""
+    if pieces["error"]:
+        return {"version": "unknown",
+                "full-revisionid": pieces.get("long"),
+                "dirty": None,
+                "error": pieces["error"],
+                "date": None}
+
+    if not style or style == "default":
+        style = "pep440"  # the default
+
+    if style == "pep440":
+        rendered = render_pep440(pieces)
+    elif style == "pep440-pre":
+        rendered = render_pep440_pre(pieces)
+    elif style == "pep440-post":
+        rendered = render_pep440_post(pieces)
+    elif style == "pep440-old":
+        rendered = render_pep440_old(pieces)
+    elif style == "git-describe":
+        rendered = render_git_describe(pieces)
+    elif style == "git-describe-long":
+        rendered = render_git_describe_long(pieces)
+    else:
+        raise ValueError("unknown style '%s'" % style)
+
+    return {"version": rendered, "full-revisionid": pieces["long"],
+            "dirty": pieces["dirty"], "error": None,
+            "date": pieces.get("date")}
+
+
+class VersioneerBadRootError(Exception):
+    """The project root directory is unknown or missing key files."""
+
+
+def get_versions(verbose=False):
+    """Get the project version from whatever source is available.
+
+    Returns dict with two keys: 'version' and 'full'.
+    """
+    if "versioneer" in sys.modules:
+        # see the discussion in cmdclass.py:get_cmdclass()
+        del sys.modules["versioneer"]
+
+    root = get_root()
+    cfg = get_config_from_root(root)
+
+    assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg"
+    handlers = HANDLERS.get(cfg.VCS)
+    assert handlers, "unrecognized VCS '%s'" % cfg.VCS
+    verbose = verbose or cfg.verbose
+    assert cfg.versionfile_source is not None, \
+        "please set versioneer.versionfile_source"
+    assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix"
+
+    versionfile_abs = os.path.join(root, cfg.versionfile_source)
+
+    # extract version from first of: _version.py, VCS command (e.g. 'git
+    # describe'), parentdir. This is meant to work for developers using a
+    # source checkout, for users of a tarball created by 'setup.py sdist',
+    # and for users of a tarball/zipball created by 'git archive' or github's
+    # download-from-tag feature or the equivalent in other VCSes.
+
+    get_keywords_f = handlers.get("get_keywords")
+    from_keywords_f = handlers.get("keywords")
+    if get_keywords_f and from_keywords_f:
+        try:
+            keywords = get_keywords_f(versionfile_abs)
+            ver = from_keywords_f(keywords, cfg.tag_prefix, verbose)
+            if verbose:
+                print("got version from expanded keyword %s" % ver)
+            return ver
+        except NotThisMethod:
+            pass
+
+    try:
+        ver = versions_from_file(versionfile_abs)
+        if verbose:
+            print("got version from file %s %s" % (versionfile_abs, ver))
+        return ver
+    except NotThisMethod:
+        pass
+
+    from_vcs_f = handlers.get("pieces_from_vcs")
+    if from_vcs_f:
+        try:
+            if cfg.vcs_root:
+                root = cfg.vcs_root
+                if not os.path.isabs(root) and 'CI_PROJECT_DIR' in os.environ:
+                    root = os.path.join(os.environ['CI_PROJECT_DIR'], root)
+
+            pieces = from_vcs_f(cfg.tag_prefix, root, verbose)
+            ver = render(pieces, cfg.style)
+            if verbose:
+                print("got version from VCS %s" % ver)
+            return ver
+        except NotThisMethod:
+            pass
+
+    try:
+        if cfg.parentdir_prefix:
+            ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
+            if verbose:
+                print("got version from parentdir %s" % ver)
+            return ver
+    except NotThisMethod:
+        pass
+
+    if verbose:
+        print("unable to compute version")
+
+    return {"version": "0+unknown", "full-revisionid": None,
+            "dirty": None, "error": "unable to compute version",
+            "date": None}
+
+
+def get_version():
+    """Get the short version string for this project."""
+    return get_versions()["version"]
+
+
+def get_cmdclass(cmdclass=None):
+    """Get the custom setuptools/distutils subclasses used by Versioneer.
+
+    If the package uses a different cmdclass (e.g. one from numpy), it
+    should be provide as an argument.
+    """
+    if "versioneer" in sys.modules:
+        del sys.modules["versioneer"]
+        # this fixes the "python setup.py develop" case (also 'install' and
+        # 'easy_install .'), in which subdependencies of the main project are
+        # built (using setup.py bdist_egg) in the same python process. Assume
+        # a main project A and a dependency B, which use different versions
+        # of Versioneer. A's setup.py imports A's Versioneer, leaving it in
+        # sys.modules by the time B's setup.py is executed, causing B to run
+        # with the wrong versioneer. Setuptools wraps the sub-dep builds in a
+        # sandbox that restores sys.modules to it's pre-build state, so the
+        # parent is protected against the child's "import versioneer". By
+        # removing ourselves from sys.modules here, before the child build
+        # happens, we protect the child from the parent's versioneer too.
+        # Also see https://github.com/python-versioneer/python-versioneer/issues/52
+
+    cmds = {} if cmdclass is None else cmdclass.copy()
+
+    # we add "version" to both distutils and setuptools
+    from distutils.core import Command
+
+    class cmd_version(Command):
+        description = "report generated version string"
+        user_options = []
+        boolean_options = []
+
+        def initialize_options(self):
+            pass
+
+        def finalize_options(self):
+            pass
+
+        def run(self):
+            vers = get_versions(verbose=True)
+            print("Version: %s" % vers["version"])
+            print(" full-revisionid: %s" % vers.get("full-revisionid"))
+            print(" dirty: %s" % vers.get("dirty"))
+            print(" date: %s" % vers.get("date"))
+            if vers["error"]:
+                print(" error: %s" % vers["error"])
+    cmds["version"] = cmd_version
+
+    # we override "build_py" in both distutils and setuptools
+    #
+    # most invocation pathways end up running build_py:
+    #  distutils/build -> build_py
+    #  distutils/install -> distutils/build ->..
+    #  setuptools/bdist_wheel -> distutils/install ->..
+    #  setuptools/bdist_egg -> distutils/install_lib -> build_py
+    #  setuptools/install -> bdist_egg ->..
+    #  setuptools/develop -> ?
+    #  pip install:
+    #   copies source tree to a tempdir before running egg_info/etc
+    #   if .git isn't copied too, 'git describe' will fail
+    #   then does setup.py bdist_wheel, or sometimes setup.py install
+    #  setup.py egg_info -> ?
+
+    # we override different "build_py" commands for both environments
+    if 'build_py' in cmds:
+        _build_py = cmds['build_py']
+    elif "setuptools" in sys.modules:
+        from setuptools.command.build_py import build_py as _build_py
+    else:
+        from distutils.command.build_py import build_py as _build_py
+
+    class cmd_build_py(_build_py):
+        def run(self):
+            root = get_root()
+            cfg = get_config_from_root(root)
+            versions = get_versions()
+            _build_py.run(self)
+            # now locate _version.py in the new build/ directory and replace
+            # it with an updated value
+            if cfg.versionfile_build:
+                target_versionfile = os.path.join(self.build_lib,
+                                                  cfg.versionfile_build)
+                print("UPDATING %s" % target_versionfile)
+                write_to_version_file(target_versionfile, versions)
+    cmds["build_py"] = cmd_build_py
+
+    if "setuptools" in sys.modules:
+        from setuptools.command.build_ext import build_ext as _build_ext
+    else:
+        from distutils.command.build_ext import build_ext as _build_ext
+
+    class cmd_build_ext(_build_ext):
+        def run(self):
+            root = get_root()
+            cfg = get_config_from_root(root)
+            versions = get_versions()
+            _build_ext.run(self)
+            if self.inplace:
+                # build_ext --inplace will only build extensions in
+                # build/lib<..> dir with no _version.py to write to.
+                # As in place builds will already have a _version.py
+                # in the module dir, we do not need to write one.
+                return
+            # now locate _version.py in the new build/ directory and replace
+            # it with an updated value
+            target_versionfile = os.path.join(self.build_lib,
+                                              cfg.versionfile_build)
+            print("UPDATING %s" % target_versionfile)
+            write_to_version_file(target_versionfile, versions)
+    cmds["build_ext"] = cmd_build_ext
+
+    if "cx_Freeze" in sys.modules:  # cx_freeze enabled?
+        from cx_Freeze.dist import build_exe as _build_exe
+        # nczeczulin reports that py2exe won't like the pep440-style string
+        # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g.
+        # setup(console=[{
+        #   "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION
+        #   "product_version": versioneer.get_version(),
+        #   ...
+
+        class cmd_build_exe(_build_exe):
+            def run(self):
+                root = get_root()
+                cfg = get_config_from_root(root)
+                versions = get_versions()
+                target_versionfile = cfg.versionfile_source
+                print("UPDATING %s" % target_versionfile)
+                write_to_version_file(target_versionfile, versions)
+
+                _build_exe.run(self)
+                os.unlink(target_versionfile)
+                with open(cfg.versionfile_source, "w") as f:
+                    LONG = LONG_VERSION_PY[cfg.VCS]
+                    f.write(LONG %
+                            {"DOLLAR": "$",
+                             "STYLE": cfg.style,
+                             "TAG_PREFIX": cfg.tag_prefix,
+                             "PARENTDIR_PREFIX": cfg.parentdir_prefix,
+                             "VERSIONFILE_SOURCE": cfg.versionfile_source,
+                             })
+        cmds["build_exe"] = cmd_build_exe
+        del cmds["build_py"]
+
+    if 'py2exe' in sys.modules:  # py2exe enabled?
+        from py2exe.distutils_buildexe import py2exe as _py2exe
+
+        class cmd_py2exe(_py2exe):
+            def run(self):
+                root = get_root()
+                cfg = get_config_from_root(root)
+                versions = get_versions()
+                target_versionfile = cfg.versionfile_source
+                print("UPDATING %s" % target_versionfile)
+                write_to_version_file(target_versionfile, versions)
+
+                _py2exe.run(self)
+                os.unlink(target_versionfile)
+                with open(cfg.versionfile_source, "w") as f:
+                    LONG = LONG_VERSION_PY[cfg.VCS]
+                    f.write(LONG %
+                            {"DOLLAR": "$",
+                             "STYLE": cfg.style,
+                             "TAG_PREFIX": cfg.tag_prefix,
+                             "PARENTDIR_PREFIX": cfg.parentdir_prefix,
+                             "VERSIONFILE_SOURCE": cfg.versionfile_source,
+                             })
+        cmds["py2exe"] = cmd_py2exe
+
+    # we override different "sdist" commands for both environments
+    if 'sdist' in cmds:
+        _sdist = cmds['sdist']
+    elif "setuptools" in sys.modules:
+        from setuptools.command.sdist import sdist as _sdist
+    else:
+        from distutils.command.sdist import sdist as _sdist
+
+    class cmd_sdist(_sdist):
+        def run(self):
+            versions = get_versions()
+            self._versioneer_generated_versions = versions
+            # unless we update this, the command will keep using the old
+            # version
+            self.distribution.metadata.version = versions["version"]
+            return _sdist.run(self)
+
+        def make_release_tree(self, base_dir, files):
+            root = get_root()
+            cfg = get_config_from_root(root)
+            _sdist.make_release_tree(self, base_dir, files)
+            # now locate _version.py in the new base_dir directory
+            # (remembering that it may be a hardlink) and replace it with an
+            # updated value
+            target_versionfile = os.path.join(base_dir, cfg.versionfile_source)
+            print("UPDATING %s" % target_versionfile)
+            write_to_version_file(target_versionfile,
+                                  self._versioneer_generated_versions)
+    cmds["sdist"] = cmd_sdist
+
+    return cmds
+
+
+CONFIG_ERROR = """
+setup.cfg is missing the necessary Versioneer configuration. You need
+a section like:
+
+ [versioneer]
+ VCS = git
+ style = pep440
+ versionfile_source = src/myproject/_version.py
+ versionfile_build = myproject/_version.py
+ tag_prefix =
+ parentdir_prefix = myproject-
+
+You will also need to edit your setup.py to use the results:
+
+ import versioneer
+ setup(version=versioneer.get_version(),
+       cmdclass=versioneer.get_cmdclass(), ...)
+
+Please read the docstring in ./versioneer.py for configuration instructions,
+edit setup.cfg, and re-run the installer or 'python versioneer.py setup'.
+"""
+
+SAMPLE_CONFIG = """
+# See the docstring in versioneer.py for instructions. Note that you must
+# re-run 'versioneer.py setup' after changing this section, and commit the
+# resulting files.
+
+[versioneer]
+#VCS = git
+#style = pep440
+#versionfile_source =
+#versionfile_build =
+#tag_prefix =
+#parentdir_prefix =
+
+"""
+
+INIT_PY_SNIPPET = """
+from ._version import get_versions
+__version__ = get_versions()['version']
+del get_versions
+"""
+
+
+def do_setup():
+    """Do main VCS-independent setup function for installing Versioneer."""
+    root = get_root()
+    try:
+        cfg = get_config_from_root(root)
+    except (EnvironmentError, configparser.NoSectionError,
+            configparser.NoOptionError) as e:
+        if isinstance(e, (EnvironmentError, configparser.NoSectionError)):
+            print("Adding sample versioneer config to setup.cfg",
+                  file=sys.stderr)
+            with open(os.path.join(root, "setup.cfg"), "a") as f:
+                f.write(SAMPLE_CONFIG)
+        print(CONFIG_ERROR, file=sys.stderr)
+        return 1
+
+    print(" creating %s" % cfg.versionfile_source)
+    with open(cfg.versionfile_source, "w") as f:
+        LONG = LONG_VERSION_PY[cfg.VCS]
+        f.write(LONG % {"DOLLAR": "$",
+                        "STYLE": cfg.style,
+                        "TAG_PREFIX": cfg.tag_prefix,
+                        "PARENTDIR_PREFIX": cfg.parentdir_prefix,
+                        "VERSIONFILE_SOURCE": cfg.versionfile_source,
+                        })
+
+    ipy = os.path.join(os.path.dirname(cfg.versionfile_source),
+                       "__init__.py")
+    if os.path.exists(ipy):
+        try:
+            with open(ipy, "r") as f:
+                old = f.read()
+        except EnvironmentError:
+            old = ""
+        if INIT_PY_SNIPPET not in old:
+            print(" appending to %s" % ipy)
+            with open(ipy, "a") as f:
+                f.write(INIT_PY_SNIPPET)
+        else:
+            print(" %s unmodified" % ipy)
+    else:
+        print(" %s doesn't exist, ok" % ipy)
+        ipy = None
+
+    # Make sure both the top-level "versioneer.py" and versionfile_source
+    # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so
+    # they'll be copied into source distributions. Pip won't be able to
+    # install the package without this.
+    manifest_in = os.path.join(root, "MANIFEST.in")
+    simple_includes = set()
+    try:
+        with open(manifest_in, "r") as f:
+            for line in f:
+                if line.startswith("include "):
+                    for include in line.split()[1:]:
+                        simple_includes.add(include)
+    except EnvironmentError:
+        pass
+    # That doesn't cover everything MANIFEST.in can do
+    # (http://docs.python.org/2/distutils/sourcedist.html#commands), so
+    # it might give some false negatives. Appending redundant 'include'
+    # lines is safe, though.
+    if "versioneer.py" not in simple_includes:
+        print(" appending 'versioneer.py' to MANIFEST.in")
+        with open(manifest_in, "a") as f:
+            f.write("include versioneer.py\n")
+    else:
+        print(" 'versioneer.py' already in MANIFEST.in")
+    if cfg.versionfile_source not in simple_includes:
+        print(" appending versionfile_source ('%s') to MANIFEST.in" %
+              cfg.versionfile_source)
+        with open(manifest_in, "a") as f:
+            f.write("include %s\n" % cfg.versionfile_source)
+    else:
+        print(" versionfile_source already in MANIFEST.in")
+
+    # Make VCS-specific changes. For git, this means creating/changing
+    # .gitattributes to mark _version.py for export-subst keyword
+    # substitution.
+    do_vcs_install(manifest_in, cfg.versionfile_source, ipy)
+    return 0
+
+
+def scan_setup_py():
+    """Validate the contents of setup.py against Versioneer's expectations."""
+    found = set()
+    setters = False
+    errors = 0
+    with open("setup.py", "r") as f:
+        for line in f.readlines():
+            if "import versioneer" in line:
+                found.add("import")
+            if "versioneer.get_cmdclass()" in line:
+                found.add("cmdclass")
+            if "versioneer.get_version()" in line:
+                found.add("get_version")
+            if "versioneer.VCS" in line:
+                setters = True
+            if "versioneer.versionfile_source" in line:
+                setters = True
+    if len(found) != 3:
+        print("")
+        print("Your setup.py appears to be missing some important items")
+        print("(but I might be wrong). Please make sure it has something")
+        print("roughly like the following:")
+        print("")
+        print(" import versioneer")
+        print(" setup( version=versioneer.get_version(),")
+        print("        cmdclass=versioneer.get_cmdclass(),  ...)")
+        print("")
+        errors += 1
+    if setters:
+        print("You should remove lines like 'versioneer.VCS = ' and")
+        print("'versioneer.versionfile_source = ' . This configuration")
+        print("now lives in setup.cfg, and should be removed from setup.py")
+        print("")
+        errors += 1
+    return errors
+
+
+if __name__ == "__main__":
+    cmd = sys.argv[1]
+    if cmd == "setup":
+        errors = do_setup()
+        errors += scan_setup_py()
+        if errors:
+            sys.exit(1)