diff --git a/CMakeLists.txt b/CMakeLists.txt
index 383ae3ecd..98b8bebba 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,187 +1,190 @@
 #===============================================================================
 # @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: Fri Jan 22 2016
 #
 # @brief  main configuration file
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 # @section DESCRIPTION
 #-------------------------------------------------------------------------------
 #                      _               _
 #                     | |             | |
 #                 __ _| | ____ _ _ __ | |_ _   _
 #                / _` | |/ / _` | '_ \| __| | | |
 #               | (_| |   < (_| | | | | |_| |_| |
 #                \__,_|_|\_\__,_|_| |_|\__|\__,_|
 #
 #===============================================================================
 
 #===============================================================================
 # CMake Project
 #===============================================================================
 cmake_minimum_required(VERSION 3.1.3)
 
 # add this options before PROJECT keyword
 set(CMAKE_DISABLE_SOURCE_CHANGES ON)
 set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
 
 project(Akantu)
 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.")
 mark_as_advanced(BUILD_SHARED_LIBS)
 
 if(NOT AKANTU_TARGETS_EXPORT)
   set(AKANTU_TARGETS_EXPORT AkantuLibraryDepends)
 endif()
 
 include(CMakeVersionGenerator)
 include(CMakePackagesSystem)
 include(CMakeFlagsHandling)
 
 include(AkantuPackagesSystem)
 include(AkantuMacros)
 include(AkantuCleaning)
 
 #cmake_activate_debug_message()
 
 #===============================================================================
 # Version Number
 #===============================================================================
 # AKANTU version number.  An even minor number corresponds to releases.
 set(AKANTU_MAJOR_VERSION 3)
 set(AKANTU_MINOR_VERSION 0)
 set(AKANTU_PATCH_VERSION 0)
 define_project_version()
 
 #===============================================================================
 # Options
 #===============================================================================
 # Debug
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -DAKANTU_NDEBUG"
   CACHE STRING "Flags used by the compiler during release builds" FORCE)
 
 #add_flags(cxx "-Wall -Wextra -pedantic -Werror")
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   add_flags(cxx "-Wall -Wextra -pedantic") # -Weffc++
 else()
   add_flags(cxx "-Wall")
 endif()
 
 option(AKANTU_EXAMPLES "Activate examples" OFF)
 option(AKANTU_TESTS "Activate tests" OFF)
 
+set(AKANTU_PREFERRED_PYTHON_VERSION 3 CACHE STRING "Preferred version for python related things")
+mark_as_advanced(AKANTU_PREFERED_PYTHON_VERSION)
+
 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)
 
 #===============================================================================
 # Documentation
 #===============================================================================
 if(AKANTU_DOCUMENTATION_DOXYGEN OR AKANTU_DOCUMENTATION_MANUAL)
   add_subdirectory(doc)
 else()
   set(AKANTU_DOC_EXCLUDE_FILES "${PROJECT_SOURCE_DIR}/doc/manual" CACHE INTERNAL "")
 endif()
 
 #===============================================================================
 # Examples and tests
 #===============================================================================
 include(AkantuTestsMacros)
 include(AkantuExampleMacros)
 
 if(AKANTU_TESTS)
   option(AKANTU_BUILD_ALL_TESTS "Build all tests" ON)
   find_package(GMSH REQUIRED)
   # package_is_activated(pybind11 _pybind11_act)
   # if(_pybind11_act)
   #   find_package(pybind11 CONFIG REQUIRED QUIET) # to get the pybind11_add_module macro
   # endif()
 endif()
 
 if(AKANTU_EXAMPLES)
   find_package(GMSH REQUIRED)
   add_subdirectory(examples)
 endif()
 
 # tests
 add_test_tree(test)
 
 #===============================================================================
 # Python interface
 #===============================================================================
 package_is_activated(python_interface _python_act)
 if(_python_act)
   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()
 
 #===============================================================================
 # Install and Packaging
 #===============================================================================
 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)
 endif()
diff --git a/cmake/Modules/CMakePackagesSystem.cmake b/cmake/Modules/CMakePackagesSystem.cmake
index 381683730..101e9f3ae 100644
--- a/cmake/Modules/CMakePackagesSystem.cmake
+++ b/cmake/Modules/CMakePackagesSystem.cmake
@@ -1,1070 +1,1064 @@
 #===============================================================================
 # @file   CMakePackagesSystem.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Wed Nov 05 2014
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  Set of macros used by akantu to handle the package system
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu is free  software: you can redistribute it and/or  modify it under the
 # terms  of the  GNU Lesser  General Public  License as  published by  the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 # A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
 # details.
 #
 # You should  have received  a copy  of the GNU  Lesser General  Public License
 # along with Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #[=======================================================================[.rst:
 #CMakePackagesSystem
 #-------------------
 #
 #This package defines multiple function to handle packages. This packages can
 #be of two kinds regular ones and extra_packages (ex: in akantu the LGPL part
 #is regular packages and extra packages are on Propetary license)
 #
 #Package are loaded with the help of the command:
 #
 #.. command:: package_list_packages
 #
 #     package_list_packages(<regular_package_folder>
 #       [ EXTRA_PACKAGE_FOLDER <extra_package_folder> ]
 #       [ SOURCE_FOLDER <source_folder>]
 #       [ TEST_FOLDER <test_folder> ]
 #       [ MANUAL_FOLDER <manual_folder> ]
 #       )
 #
 #     This command will look for packages name like ``<regular_package_folder>/<package>.cmake``
 #     OR ``<extra_package_folder>/<package>/package.cmake``
 #
 #A package is a cmake script that should contain at list the declaration of a
 #package
 #
 #.. command:: package_declare
 #
 #     package_declare(<package real name>
 #       [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #       [DESCRIPTION <description>] [DEFAULT <default_value>]
 #       [DEPENDS <pkg> ...]
 #       [BOOST_COMPONENTS <pkg> ...]
 #       [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #       [COMPILE_FLAGS <lang> <flags>]
 #       [SYSTEM <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> <retval>)
 #.. command:: package_add_dependencies
 #     package_add_dependencies(<pkg> <dep1> <dep2> ... <depn>)
 #     package_remove_dependencies(<pkg> <dep1> <dep2> ... <depn>)
 #     package_remove_dependency(<pkg> <dep>)
 #
 #.. command:: package_on_enabled_script
 #     package_on_enabled_script(<pkg> <script>)
 #
 #.. command:: package_get_all_source_files
 #     package_get_all_source_files(<srcs> <public_headers> <private_headers>)
 #.. command:: package_get_all_include_directories
 #     package_get_all_include_directories(<inc_dirs>)
 #.. command:: package_get_all_external_informations
 #     package_get_all_external_informations(<include_dir> <libraries>)
 #.. command:: package_get_all_definitions
 #     package_get_all_definitions(<definitions>)
 #.. command:: package_get_all_extra_dependencies
 #     package_get_all_extra_dependencies(<dependencies>)
 #.. command:: package_get_all_test_folders
 #     package_get_all_test_folders(<test_dirs>)
 #.. command:: package_get_all_documentation_files
 #     package_get_all_documentation_files(<doc_files>)
 #.. command:: package_get_all_activated_packages
 #     package_get_all_activated_packages(<activated_list>)
 #.. command:: package_get_all_deactivated_packages
 #     package_get_all_deactivated_packages(<deactivated_list>)
 #.. command:: package_get_all_packages
 #     package_get_all_packages(<packages_list>)
 #.. command:: package_get_all_features_public
 #     package_get_all_features_public(<features>)
 #.. command:: package_get_all_features_private
 #     package_get_all_features_private(<features>)
 #
 #
 #     .. command:: package_set_package_system_dependency
 #
 #     package_set_package_system_dependency(<pkg> <system> <dep1>
 #                                           <dep2> ... <depn>)
 #
 #                                       .. command:: package_get_package_system_dependency
 #
 #     package_get_package_system_dependency(<pkg> <var>)
 #
 #
 #]=======================================================================]
 
 
 include(CMakeParseArguments)
 
 #===============================================================================
 # Package Management
 #===============================================================================
 if(__CMAKE_PACKAGES_SYSTEM)
   return()
 endif()
 set(__CMAKE_PACKAGES_SYSTEM TRUE)
 
 if(CMAKE_VERSION VERSION_GREATER 3.1.2)
   cmake_policy(SET CMP0054 NEW)
 endif()
 
 #===============================================================================
 option(AUTO_MOVE_UNKNOWN_FILES
   "Give to cmake the permission to move the unregistered files to the ${PROJECT_SOURCE_DIR}/tmp directory" FALSE)
 mark_as_advanced(AUTO_MOVE_UNKNOWN_FILES)
 
 
 include(CMakePackagesSystemGlobalFunctions)
 include(CMakePackagesSystemPrivateFunctions)
 
 # ==============================================================================
 # "Public" Accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Package name
 # ------------------------------------------------------------------------------
 function(package_get_name pkg pkg_name)
   string(TOUPPER ${PROJECT_NAME} _project)
   string(REPLACE "-" "_" _str_pkg "${pkg}")
   string(TOUPPER ${_str_pkg} _u_package)
   set(${pkg_name} ${_project}_PKG_${_u_package} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Real name
 # ------------------------------------------------------------------------------
 function(package_get_real_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_real_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Option name
 # ------------------------------------------------------------------------------
 function(package_get_option_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_option_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_use_system pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_use_system(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_third_party_script_variable pkg var)
   package_get_name(${pkg} _pkg_name)
   _package_add_third_party_script_variable(${_pkg_name} ${var} ${ARGN})
   set(${var} ${ARGN} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_add_to_export_list pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_export_list(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Nature
 # ------------------------------------------------------------------------------
 function(package_get_nature pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_nature(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Description
 # ------------------------------------------------------------------------------
 function(package_get_description pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_description(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Package file name
 # ------------------------------------------------------------------------------
 function(package_get_filename pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_filename(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source files
 # ------------------------------------------------------------------------------
 function(package_get_source_files pkg ret_srcs ret_pub ret_priv)
   package_get_name(${pkg} _pkg_name)
   _package_get_source_files(${_pkg_name} _tmp_srcs _tmp_pub _tmp_priv)
   set(${ret_srcs} ${_tmp_srcs} PARENT_SCOPE)
   set(${ret_pub}  ${_tmp_pub}  PARENT_SCOPE)
   set(${ret_priv} ${_tmp_pric} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source folder
 # ------------------------------------------------------------------------------
 function(package_get_sources_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_sources_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Test folder
 # ------------------------------------------------------------------------------
 function(package_get_tests_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_tests_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Manual folder
 # ------------------------------------------------------------------------------
 function(package_get_manual_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_manual_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra option for the find_package
 # ------------------------------------------------------------------------------
 function(package_get_find_package_extra_options pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_find_package_extra_options(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_find_package_extra_options pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_find_package_extra_options(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_compile_flags pkg lang ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_compile_flags(${_pkg_name} ${lang} _tmp)
   set(${ret} "${_tmp}" PARENT_SCOPE)
 endfunction()
 
 function(package_set_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_set_compile_flags(${_pkg_name} ${lang} ${ARGN})
 endfunction()
 
 function(package_unset_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_unset_compile_flags(${_pkg_name} ${lang})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Include dir
 # ------------------------------------------------------------------------------
 function(package_get_include_dir pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_include_dir(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Libraries
 # ------------------------------------------------------------------------------
 function(package_get_libraries pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_libraries(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_libraries pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_libraries(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra dependencies like custom commands of ExternalProject
 # ------------------------------------------------------------------------------
 function(package_add_extra_dependency pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_extra_dependency(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_rm_extra_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   _package_rm_extra_dependency(${_pkg_name} ${dep})
 endfunction()
 
 function(package_get_extra_dependencies pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_extra_dependencies(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Activate/deactivate
 # ------------------------------------------------------------------------------
 function(package_is_activated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_activated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_is_deactivated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_deactivated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Direct dependencies
 # ------------------------------------------------------------------------------
 function(package_get_dependencies pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_dependencies(${_pkg_name} _tmp_name)
   _package_get_real_name(${_tmp_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_dependencies pkg)
   package_get_name(${pkg} _pkg_name)
   foreach(_dep ${ARGN})
     package_get_name(${_dep} _dep_pkg_name)
     list(APPEND _tmp_deps ${_dep_pkg_name})
   endforeach()
 
   _package_add_dependencies(${_pkg_name} ${_tmp_deps})
 endfunction()
 
 function(package_remove_dependencies pkg)
   foreach(_dep ${ARGN})
     package_remove_dependency(${pkg} _dep)
   endforeach()
 endfunction()
 
 function(package_remove_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   package_get_name(${dep} _dep_pkg_name)
   _package_remove_dependency(${_pkg_name} ${_dep_pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation related functions
 # ------------------------------------------------------------------------------
 function(package_declare_documentation pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_declare_documentation_files pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation_files(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set any user variables needed
 # ------------------------------------------------------------------------------
 function(package_set_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_to_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_get_variable variable pkg value)
   package_get_name(${pkg} _pkg_name)
   _package_get_variable(${variable} ${_pkg_name} _value_tmp)
   if(_value_tmp)
     set(${value} ${_value_tmp} PARENT_SCOPE)
   else()
     unset(${value} PARENT_SCOPE)
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Exteral package system as apt rpm dependencies
 # ------------------------------------------------------------------------------
 function(package_set_package_system_dependency pkg system)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${system} ${ARGN})
 endfunction()
 
 function(package_get_package_system_dependency pkg system var)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${sytem} _tmp)
   set(${var} ${_tmp} PARENT_SCOPE)
 endfunction()
 # ------------------------------------------------------------------------------
 
 # ==============================================================================
 # Global accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # get the list of source files
 # ------------------------------------------------------------------------------
 function(package_get_all_source_files SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   unset(_tmp_srcs)
   unset(_tmp_public_headers)
   unset(_tmp_private_headers)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_source_files(${_pkg_name}
       _pkg_srcs
       _pkg_public_headers
       _pkg_private_headers
       )
     list(APPEND _tmp_srcs ${_pkg_srcs})
     list(APPEND _tmp_public_headers ${_pkg_public_headers})
     list(APPEND _tmp_private_headers ${_pkg_private_headers})
   endforeach()
 
   set(${SRCS}            ${_tmp_srcs}            PARENT_SCOPE)
   set(${PUBLIC_HEADERS}  ${_tmp_public_headers}  PARENT_SCOPE)
   set(${PRIVATE_HEADERS} ${_tmp_private_headers} PARENT_SCOPE)
 endfunction()
 
 
 # ------------------------------------------------------------------------------
 # Get include directories
 # ------------------------------------------------------------------------------
 function(package_get_all_include_directories inc_dirs)
   set(_tmp)
   package_get_all_activated_packages(_activated_list)
 
   foreach(_pkg_name ${_activated_list})
     foreach(_type SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
       foreach(_file ${${_pkg_name}_${_type}})
         get_filename_component(_path "${_file}" PATH)
         list(APPEND _tmp "${_path}")
       endforeach()
     endforeach()
   endforeach()
 
   if(_tmp)
     list(REMOVE_DUPLICATES _tmp)
   endif()
 
   set(${inc_dirs} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get external libraries informations
 # ------------------------------------------------------------------------------
 function(package_get_all_external_informations INCLUDE_DIR LIBRARIES)
   _package_get_variable_for_activated(INCLUDE_DIR tmp_INCLUDE_DIR)
   _package_get_variable_for_activated(LIBRARIES tmp_LIBRARIES)
 
   set(${INCLUDE_DIR} ${tmp_INCLUDE_DIR} PARENT_SCOPE)
   set(${LIBRARIES}   ${tmp_LIBRARIES}   PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get export list for all activated packages
 # ------------------------------------------------------------------------------
 function(package_get_all_export_list export_list)
   _package_get_variable_for_activated(EXPORT_LIST _tmp)
   set(${export_list} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get definitions like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_definitions definitions)
   _package_get_variable_for_activated(OPTION_NAME _tmp)
   set(${definitions} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra dependencies like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_extra_dependencies deps)
   _package_get_variable_for_activated(EXTRA_DEPENDENCY _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra infos
 # ------------------------------------------------------------------------------
 function(package_get_all_test_folders TEST_DIRS)
   _package_get_variable_for_activated(TEST_FOLDER _tmp)
   set(${TEST_DIRS} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_all_compilation_flags LANG FLAGS)
   _package_get_variable_for_activated(COMPILE_${LANG}_FLAGS _tmp_flags)
   string(REPLACE ";" " " _flags "${_tmp_flags}")
   set(${FLAGS} ${_flags} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation informations
 # ------------------------------------------------------------------------------
 function(package_get_all_documentation_files doc_files)
   set(_tmp_DOC_FILES)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_manual_folder(${_pkg_name} _doc_dir)
     _package_get_documentation_files(${_pkg_name} _doc_files)
 
     foreach(_doc_file ${_doc_files})
       list(APPEND _tmp_DOC_FILES ${_doc_dir}/${_doc_file})
     endforeach()
   endforeach()
 
   if(_tmp_DOC_FILES)
     list(REMOVE_DUPLICATES _tmp_DOC_FILES)
   endif()
 
   set(${doc_files} ${_tmp_DOC_FILES} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get package systems dependencies
 # ------------------------------------------------------------------------------
 function(package_get_all_package_system_dependency system deps)
   string(TOUPPER ${system} _u_system)
   _package_get_variable_for_activated(PACKAGE_SYSTEM_${_u_system} _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List packages
 # ------------------------------------------------------------------------------
 function(package_get_all_activated_packages activated_list)
   package_get_project_variable(ACTIVATED_PACKAGE_LIST _activated_list)
   set(${activated_list} ${_activated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_deactivated_packages deactivated_list)
   package_get_project_variable(DEACTIVATED_PACKAGE_LIST _deactivated_list)
   set(${deactivated_list} ${_deactivated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_packages packages_list)
   package_get_project_variable(ALL_PACKAGES_LIST _packages_list)
   set(${packages_list} ${_packages_list} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List all the needed features
 # ------------------------------------------------------------------------------
 function(package_get_all_features_public features)
   _package_get_variable_for_activated(FEATURES_PUBLIC _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_features_private features)
   _package_get_variable_for_activated(FEATURES_PRIVATE _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Callbacks
 # ------------------------------------------------------------------------------
 function(package_on_enabled_script pkg script)
   package_get_name(${pkg} _pkg_name)
   _package_on_enable_script(${_pkg_name} "${script}")
 endfunction()
 
 # ------------------------------------------------------------------------------
 # list all the packages in the PACKAGE_FOLDER
 # extra packages can be given with an EXTRA_PACKAGE_FOLDER
 # <package_folder>/<package>.cmake
 #
 # Extra packages folder structure
 # <extra_package_folder>/<package>/package.cmake
 #                                 /src
 #                                 /test
 #                                 /manual
 #
 # ------------------------------------------------------------------------------
 function(package_list_packages PACKAGE_FOLDER)
   cmake_parse_arguments(_opt_pkg
     "NO_AUTO_COMPILE_FLAGS"
     "SOURCE_FOLDER;EXTRA_PACKAGES_FOLDER;TEST_FOLDER;MANUAL_FOLDER"
     ""
     ${ARGN})
 
   string(TOUPPER ${PROJECT_NAME} _project)
 
   # Cleaning some states to start correctly
   package_get_all_packages(_already_loaded_pkg)
   foreach(_pkg_name ${_already_loaded_pkg})
     _package_unset_extra_dependencies(${_pkg_name})
     _package_unset_dependencies(${_pkg_name})
     _package_unset_activated(${_pkg_name})
   endforeach()
 
 
   if(_opt_pkg_SOURCE_FOLDER)
     set(_src_folder "${_opt_pkg_SOURCE_FOLDER}")
   else()
     set(_src_folder "src/")
   endif()
 
   get_filename_component(_abs_src_folder ${_src_folder} ABSOLUTE)
 
   if(_opt_pkg_TEST_FOLDER)
     set(_test_folder "${_opt_pkg_TEST_FOLDER}")
   else()
     set(_test_folder "test/")
   endif()
 
   if(_opt_pkg_MANUAL_FOLDER)
     set(_manual_folder "${_opt_pkg_MANUAL_FOLDER}")
   else()
     set(_manual_folder "doc/manual")
   endif()
 
   if(_opt_pkg_NO_AUTO_COMPILE_FLAGS)
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS TRUE)
   else()
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS FALSE)
   endif()
 
 
   get_filename_component(_abs_test_folder ${_test_folder} ABSOLUTE)
   get_filename_component(_abs_manual_folder ${_manual_folder} ABSOLUTE)
 
   # check all the packages in the <package_folder>
   file(GLOB _package_list "${PACKAGE_FOLDER}/*.cmake")
 
   set(_package_files)
   foreach(_pkg ${_package_list})
     get_filename_component(_basename ${_pkg} NAME)
     if(NOT _basename MATCHES "^\\.#.*")
       list(APPEND _package_files ${_basename})
     endif()
   endforeach()
 
   if(_package_files)
     list(SORT _package_files)
   endif()
 
   # check all packages
   set(_packages_list_all)
   foreach(_pkg_file ${_package_files})
     string(REGEX REPLACE "[0-9]+_" "" _pkg_file_stripped ${_pkg_file})
     string(REGEX REPLACE "\\.cmake" "" _pkg ${_pkg_file_stripped})
 
     set(_current_src_folder "${_abs_src_folder}" CACHE INTERNAL "" FORCE)
     set(_current_test_folder "${_abs_test_folder}" CACHE INTERNAL "" FORCE)
     set(_current_manual_folder "${_abs_manual_folder}" CACHE INTERNAL "" FORCE)
 
     include("${PACKAGE_FOLDER}/${_pkg_file}")
 
     unset(_current_src_folder CACHE)
     unset(_current_test_folder CACHE)
     unset(_current_manual_folder CACHE)
   endforeach()
 
   # check the extra_packages if they exists
   if(_opt_pkg_EXTRA_PACKAGES_FOLDER)
     file(GLOB _extra_package_list RELATIVE
       "${_opt_pkg_EXTRA_PACKAGES_FOLDER}" "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/*")
     foreach(_pkg ${_extra_package_list})
       if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         package_get_name(${_pkg} _pkg_name)
 
         _package_set_filename(${_pkg_name}
           "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         set(_current_src_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src" CACHE INTERNAL "" FORCE)
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test")
           set(_current_test_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test" CACHE INTERNAL "" FORCE)
         endif()
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual")
           set(_current_manual_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual" CACHE INTERNAL "" FORCE)
         endif()
 
         list(APPEND _extra_pkg_src_folders "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src")
 
         include("${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         unset(_current_src_folder CACHE)
         unset(_current_test_folder CACHE)
         unset(_current_manual_folder CACHE)
       endif()
     endforeach()
   endif()
 
   _package_build_rdependencies()
   _package_load_packages()
   _package_check_files_exists()
   _package_check_files_registered(${_abs_src_folder} ${_extra_pkg_src_folders})
 
   # Load boost components if boost was loaded
   package_is_activated(Boost _ret)
   if(_ret)
     _package_load_boost_components()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # macro to include internal/external packages packages
 # package_declare(<package real name>
 #                 [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #                 [DESCRIPTION <description>] [DEFAULT <default_value>]
 #                 [DEPENDS <pkg> ...]
 #                 [BOOST_COMPONENTS <pkg> ...]
 #                 [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #                 [COMPILE_FLAGS <lang> <flags>]
 #                 [SYSTEM <bool> [ <script_to_compile> ]]
 #                 [FEATURES_PUBLIC <feature> ...]
 #                 [FEATURES_PRIVATE <feature> ...])
 # ------------------------------------------------------------------------------
 function(package_declare pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_real_name(${_pkg_name} ${pkg})
   _package_set_filename(${_pkg_name} "${CMAKE_CURRENT_LIST_FILE}")
 
   _package_set_sources_folder(${_pkg_name} "${_current_src_folder}")
 
   _package_variable_unset(SRCS ${_pkg_name})
   _package_variable_unset(PUBLIC_HEADERS ${_pkg_name})
   _package_variable_unset(PRIVATE_HEADERS ${_pkg_name})
 
   if(_current_test_folder)
     _package_set_tests_folder(${_pkg_name} "${_current_test_folder}")
   endif()
 
   if(_current_manual_folder)
     _package_set_manual_folder(${_pkg_name} "${_current_manual_folder}")
   endif()
 
   package_get_project_variable(ALL_PACKAGES_LIST _tmp_pkg_list)
   list(APPEND _tmp_pkg_list ${_pkg_name})
   list(REMOVE_DUPLICATES _tmp_pkg_list)
   package_set_project_variable(ALL_PACKAGES_LIST ${_tmp_pkg_list})
 
   set(_options
     EXTERNAL
     NOT_OPTIONAL
     META
-    ADVANCED)
+    ADVANCED
+    EXCLUDE_FROM_ALL)
   set(_one_valued_options
     DEFAULT
-    DESCRIPTION
-    FALLBACK_ON_SYSTEM_MISSING
-    EXCLUDE_FROM_ALL)
+    DESCRIPTION)
   set(_multi_valued_options
     DEPENDS
     EXTRA_PACKAGE_OPTIONS
     COMPILE_FLAGS
     BOOST_COMPONENTS
     SYSTEM
     FEATURES_PUBLIC
     FEATURES_PRIVATE)
 
   cmake_parse_arguments(_opt_pkg
     "${_options}"
     "${_one_valued_options}"
     "${_multi_valued_options}"
     ${ARGN})
 
   if(_opt_pkg_UNPARSED_ARGUMENTS)
     message("You gave to many arguments while registering the package ${pkg} \"${_opt_pkg_UNPARSED_ARGUMENTS}\"")
   endif()
 
   # set the nature
   if(_opt_pkg_EXTERNAL)
     _package_set_nature(${_pkg_name} "external")
   elseif(_opt_pkg_META)
     _package_set_nature(${_pkg_name} "meta")
   else()
     _package_set_nature(${_pkg_name} "internal")
   endif()
 
   _package_declare_option(${_pkg_name})
 
   # set description
   if(_opt_pkg_DESCRIPTION)
     _package_set_description(${_pkg_name} ${_opt_pkg_DESCRIPTION})
   else()
     _package_set_description(${_pkg_name} "")
   endif()
 
   _package_get_option_name(${_pkg_name} _option_name)
   _package_get_description(${_pkg_name} _description)
 
   # get the default value
   if(DEFINED _opt_pkg_DEFAULT)
     set(_default ${_opt_pkg_DEFAULT})
   else()
     if(_opt_pkg_NOT_OPTIONAL)
       set(_default ON)
     else()
       set(_default OFF)
     endif()
   endif()
 
   # set the option if needed
   if(_opt_pkg_NOT_OPTIONAL)
     _package_get_nature(${_pkg_name} _nature)
     _package_set_nature(${_pkg_name} "${_nature}_not_optional")
     set(${_option_name} ${_default} CACHE INTERNAL "${_description}" FORCE)
   else()
     option(${_option_name} "${_description}" ${_default})
     if(_opt_pkg_ADVANCED OR _opt_pkg_EXTERNAL)
       mark_as_advanced(${_option_name})
     endif()
   endif()
 
   # Set the option for third-partie that can be compiled as an ExternalProject
   if(DEFINED _opt_pkg_SYSTEM)
     list(LENGTH _opt_pkg_SYSTEM _length)
     list(GET _opt_pkg_SYSTEM 0 _bool)
     _package_set_system_option(${_pkg_name} ${_bool})
     if(_length GREATER 1)
       list(GET _opt_pkg_SYSTEM 1 _script)
       _package_set_system_script(${_pkg_name} ${_script})
     endif()
   endif()
 
-  if(_opt_pkg_EXCLUDE_FROM_ALL)
-    _package_set_variable(EXCLUDE_FROM_ALL ${_pkg_name} ${_opt_pkg_EXCLUDE_FROM_ALL})
-  endif()
-
   # set the dependecies
   if(_opt_pkg_DEPENDS)
     set(_depends)
     foreach(_dep ${_opt_pkg_DEPENDS})
       package_get_name(${_dep} _dep_pkg_name)
       list(APPEND _depends ${_dep_pkg_name})
     endforeach()
     _package_add_dependencies(${_pkg_name} ${_depends})
   endif()
 
   # keep the extra option for the future find package
   if(_opt_pkg_EXTRA_PACKAGE_OPTIONS)
     _package_set_find_package_extra_options(${_pkg_name} "${_opt_pkg_EXTRA_PACKAGE_OPTIONS}")
   endif()
 
   # register the compilation flags
   if(_opt_pkg_COMPILE_FLAGS)
     set(_languages C CXX Fortran)
     cmake_parse_arguments(_compile_flags
       "" "" "${_languages}"
       ${_opt_pkg_COMPILE_FLAGS}
       )
 
 
     # this is done to maintain backward compatibility
     if(_compile_flags_UNPARSED_ARGUMENTS)
       set(_compile_flags_CXX ${_compile_flags_UNPARSED_ARGUMENTS})
     endif()
 
     foreach(_lang ${_languages})
       if(_compile_flags_${_lang})
         _package_set_compile_flags(${_pkg_name} ${_lang} ${_compile_flags_${_lang}})
       else()
         _package_unset_compile_flags(${_pkg_name} ${_lang})
       endif()
     endforeach()
   endif()
 
   # set the boost dependencies
   if(_opt_pkg_BOOST_COMPONENTS)
     _package_set_boost_component_needed(${_pkg_name} "${_opt_pkg_BOOST_COMPONENTS}")
   endif()
 
-  if(_opt_pkg_FEATURES_PUBLIC)
-    _package_set_variable(FEATURES_PUBLIC ${_pkg_name} "${_opt_pkg_FEATURES_PUBLIC}")
-  endif()
-
-  if(_opt_pkg_FEATURES_PRIVATE)
-    _package_set_variable(FEATURES_PRIVATE ${_pkg_name} "${_opt_pkg_FEATURES_PRIVATE}")
-  endif()
+  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
       list(APPEND ${_type} "${_src_folder}/${_file}")
     endforeach()
   endforeach()
 
   set(${_pkg_name}_SRCS "${_srcs}"
     CACHE INTERNAL "List of sources files" FORCE)
   set(${_pkg_name}_PUBLIC_HEADERS  "${_pub_hdrs}"
     CACHE INTERNAL "List of public header files" FORCE)
   set(${_pkg_name}_PRIVATE_HEADERS "${_pri_hdrs}"
     CACHE INTERNAL "List of private header files" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
diff --git a/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake b/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
index 666377eb8..082700566 100644
--- a/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
+++ b/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
@@ -1,962 +1,958 @@
 #===============================================================================
 # @file   CMakePackagesSystemPrivateFunctions.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sat Jul 18 2015
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  Set of macros used by the package system, internal functions
 #
 # @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/>.
 #
 #===============================================================================
 
 # ==============================================================================
 # "Private" Accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Real name
 # ------------------------------------------------------------------------------
 function(_package_get_real_name pkg_name real_name)
   set(${real_name} ${${pkg_name}} PARENT_SCOPE)
 endfunction()
 
 function(_package_set_real_name pkg_name real_name)
   set(${pkg_name} ${real_name} CACHE INTERNAL "" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Option name
 # ------------------------------------------------------------------------------
 function(_package_declare_option pkg_name)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
   _package_get_nature(${pkg_name} _nature)
 
   if(${_nature} MATCHES "internal" OR ${_nature} MATCHES "meta")
     set(_opt_name ${_project}_${_u_package})
   elseif(${_nature} MATCHES "external")
     set(_opt_name ${_project}_USE_${_u_package})
   else()
     set(_opt_name UNKNOWN_NATURE_${_project}_${_u_package})
   endif()
 
   _package_set_variable(OPTION_NAME ${pkg_name} ${_opt_name})
 endfunction()
 
 function(_package_get_option_name pkg_name opt_name)
   _package_get_variable(OPTION_NAME ${pkg_name} _opt_name)
   set(${opt_name} ${_opt_name} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(_package_set_system_option pkg_name default)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
   set(${_project}_USE_SYSTEM_${_u_package} ${default} CACHE STRING
     "Should akantu compile the third-party: \"${_real_name}\"")
   mark_as_advanced(${_project}_USE_SYSTEM_${_u_package})
   set_property(CACHE ${_project}_USE_SYSTEM_${_u_package} PROPERTY STRINGS ON OFF AUTO)
 endfunction()
 
 function(_package_use_system pkg_name use)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
   if(DEFINED ${_project}_USE_SYSTEM_${_u_package})
     if(${${_project}_USE_SYSTEM_${_u_package}} MATCHES "(ON|AUTO)")
       set(${use} TRUE PARENT_SCOPE)
     else()
       set(${use} FALSE PARENT_SCOPE)
     endif()
   else()
     set(${use} TRUE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_has_system_fallback pkg_name fallback)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
-
   if(DEFINED ${_project}_USE_SYSTEM_${_u_package})
-    message("${_project}_USE_SYSTEM_${_u_package} ${${_project}_USE_SYSTEM_${_u_package}}")
     if(${${_project}_USE_SYSTEM_${_u_package}} MATCHES "AUTO")
       set(${fallback} TRUE PARENT_SCOPE)
     else()
       set(${fallback} FALSE PARENT_SCOPE)
     endif()
   else()
     set(${fallback} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_set_system_script pkg_name script)
   _package_set_variable(COMPILE_SCRIPT ${pkg_name} "${script}")
 endfunction()
 
 function(_package_add_third_party_script_variable pkg_name var)
   _package_set_variable(VARIABLE_${var} ${pkg_name} "${ARGN}")
   set(${var} ${ARGN} PARENT_SCOPE)
 endfunction()
 
+# ------------------------------------------------------------------------------
 function(_package_load_third_party_script pkg_name)
   if(${pkg_name}_COMPILE_SCRIPT)
     # set the stored variable
     get_cmake_property(_all_vars VARIABLES)
     foreach(_var ${_all_vars})
       if(_var MATCHES "^${pkg_name}_VARIABLE_.*")
         string(REPLACE "${pkg_name}_VARIABLE_" "" _orig_var "${_var}")
         set(${_orig_var} ${${_var}})
       endif()
     endforeach()
 
     _package_get_real_name(${pkg_name} _name)
     string(TOUPPER "${_name}" _u_name)
 
     _package_get_option_name(${pkg_name} _opt_name)
     if(${_opt_name}_VERSION)
       set(_version "${${_opt_name}_VERSION}")
       set(${_u_name}_VERSION "${_version}" CACHE INTERNAL "" FORCE)
     elseif(${_u_name}_VERSION)
       set(_version "${${_u_name}_VERSION}")
     endif()
 
     # load the script
     include(ExternalProject)
     include(${${pkg_name}_COMPILE_SCRIPT})
 
     if(${_u_name}_LIBRARIES)
       _package_set_libraries(${pkg_name} ${${_u_name}_LIBRARIES})
       list(APPEND _required_vars ${_u_name}_LIBRARIES)
     endif()
     if(${_u_name}_INCLUDE_DIR)
       _package_set_include_dir(${pkg_name} ${${_u_name}_INCLUDE_DIR})
       list(APPEND _required_vars ${_u_name}_INCLUDE_DIR)
     endif()
 
     include(FindPackageHandleStandardArgs)
     if(CMAKE_VERSION VERSION_GREATER 2.8.12)
       find_package_handle_standard_args(${_name}
         REQUIRED_VARS ${_required_vars}
         VERSION_VAR _version
         FAIL_MESSAGE "Something was not configured by a the third-party script for ${_name}"
         )
     else()
       find_package_handle_standard_args(${_name}
         "Something was not configured by a the third-party script for ${_name}"
         ${_required_vars}
         )
     endif()
   endif()
   set(${pkg_name}_USE_SYSTEM_PREVIOUS FALSE CACHE INTERNAL "" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Nature
 # ------------------------------------------------------------------------------
 function(_package_set_nature pkg_name nature)
   _package_set_variable(NATURE ${pkg_name} ${nature})
 endfunction()
 
 function(_package_get_nature pkg_name nature)
   _package_get_variable(NATURE ${pkg_name} _nature "unknown")
   set(${nature} ${_nature} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Description
 # ------------------------------------------------------------------------------
 function(_package_set_description pkg_name desc)
   _package_set_variable(DESC ${pkg_name} ${desc})
 endfunction()
 
 function(_package_get_description pkg_name desc)
   _package_get_variable(DESC ${pkg_name} _desc "No description set for the package ${${pkg_name}} (${pkg_name})")
   set(${desc} ${_desc} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Package file name
 # ------------------------------------------------------------------------------
 function(_package_set_filename pkg_name file)
   _package_set_variable(FILE ${pkg_name} ${file})
 endfunction()
 
 function(_package_get_filename pkg_name file)
   _package_get_variable(FILE ${pkg_name} _file "No filename set for the package ${${pkg_name}}")
   set(${file} ${_file} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source folder
 # ------------------------------------------------------------------------------
 function(_package_set_sources_folder pkg_name src_folder)
   _package_set_variable(SRC_FOLDER ${pkg_name} ${src_folder})
 endfunction()
 
 function(_package_get_sources_folder pkg_name src_folder)
   _package_get_variable(SRC_FOLDER ${pkg_name} _src_folder)
   set(${src_folder} ${_src_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Test folder
 # ------------------------------------------------------------------------------
 function(_package_set_tests_folder pkg_name test_folder)
   _package_set_variable(TEST_FOLDER ${pkg_name} ${test_folder})
 endfunction()
 
 function(_package_get_tests_folder pkg_name test_folder)
   _package_get_variable(TEST_FOLDER ${pkg_name} _test_folder)
   set(${test_folder} ${_test_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Manual folder
 # ------------------------------------------------------------------------------
 function(_package_set_manual_folder pkg_name manual_folder)
   _package_set_variable(MANUAL_FOLDER ${pkg_name} ${manual_folder})
 endfunction()
 
 function(_package_get_manual_folder pkg_name manual_folder)
   _package_get_variable(MANUAL_FOLDER ${pkg_name} _manual_folder)
   set(${manual_folder} ${_manual_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra option for the find_package
 # ------------------------------------------------------------------------------
 function(_package_set_find_package_extra_options pkg_name)
   _package_set_variable(FIND_PKG_OPTIONS ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_find_package_extra_options pkg_name options)
   _package_get_variable(FIND_PKG_OPTIONS ${pkg_name} _options)
   set(${options} ${_options} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Compilation flags
 # ------------------------------------------------------------------------------
 function(_package_set_compile_flags pkg_name lang)
   _package_set_variable(COMPILE_${lang}_FLAGS ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_unset_compile_flags pkg_name lang)
   _package_variable_unset(COMPILE_${lang}_FLAGS ${pkg_name})
 endfunction()
 
 function(_package_get_compile_flags pkg_name lang flags)
   _package_get_variable(COMPILE_${lang}_FLAGS ${pkg_name} _tmp_flags)
   string(REPLACE ";" " " _flags "${_tmp_flags}")
   set(${flags} "${_flags}" PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Include dir
 # ------------------------------------------------------------------------------
 function(_package_set_include_dir pkg_name)
   _package_set_variable(INCLUDE_DIR ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_include_dir pkg_name include_dir)
   _package_get_variable(INCLUDE_DIR ${pkg_name} _include_dir "")
   set(${include_dir} ${_include_dir} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_include_dir pkg_name)
   _package_add_to_variable(INCLUDE_DIR ${pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Libraries
 # ------------------------------------------------------------------------------
 function(_package_set_libraries pkg_name)
   _package_set_variable(LIBRARIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_libraries pkg_name libraries)
   _package_get_variable(LIBRARIES ${pkg_name} _libraries "")
   set(${libraries} ${_libraries} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_libraries pkg_name)
   _package_add_to_variable(LIBRARIES ${pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra dependencies like custom commands of ExternalProject
 # ------------------------------------------------------------------------------
 function(_package_add_extra_dependency pkg_name)
   _package_add_to_variable(EXTRA_DEPENDENCY ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_rm_extra_dependency pkg_name dep)
   _package_remove_from_variable(EXTRA_DEPENDENCY ${pkg_name} ${dep})
 endfunction()
 
 function(_package_set_extra_dependencies pkg)
   _package_set_variable(EXTRA_DEPENDENCY ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_extra_dependencies pkg deps)
   _package_get_variable(EXTRA_DEPENDENCY ${pkg_name} _deps "")
   set(${deps} ${_deps} PARENT_SCOPE)
 endfunction()
 
 function(_package_unset_extra_dependencies pkg_name)
   _package_variable_unset(EXTRA_DEPENDENCY ${pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Activate/deactivate
 # ------------------------------------------------------------------------------
 function(_package_activate pkg_name)
   _package_set_variable(STATE ${pkg_name} ON)
 endfunction()
 
 function(_package_deactivate pkg_name)
   _package_set_variable(STATE ${pkg_name} OFF)
 endfunction()
 
 function(_package_is_activated pkg_name act)
   _package_get_variable(STATE ${pkg_name} _state OFF)
   if(_state)
     set(${act} TRUE PARENT_SCOPE)
   else()
     set(${act} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_is_deactivated pkg_name act)
   _package_get_variable(STATE ${pkg_name} _state OFF)
   if(NOT _state)
     set(${act} TRUE PARENT_SCOPE)
   else()
     set(${act} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_unset_activated pkg_name)
   _package_variable_unset(STATE ${pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Callbacks
 # ------------------------------------------------------------------------------
 function(_package_on_enable_script pkg_name script)
   string(TOLOWER "${pkg_name}" _l_pkg_name)
   set(_output_file "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_l_pkg_name}.cmake")
   file(WRITE "${_output_file}"
     "${script}")
   _package_set_variable(CALLBACK_SCRIPT ${pkg_name} "${_output_file}")
 endfunction()
 
 function(_package_get_callback_script pkg_name filename)
   _package_get_variable(CALLBACK_SCRIPT ${pkg_name} _filename NOTFOUND)
   set(${filename} ${_filename} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Export list
 # ------------------------------------------------------------------------------
 function(_package_add_to_export_list pkg_name)
   _package_add_to_variable(EXPORT_LIST ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_export_list pkg_name export_list)
   _package_get_variable(EXPORT_LIST ${pkg_name} _export_list)
   set(${export_list} ${_export_list} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Direct dependencies
 # ------------------------------------------------------------------------------
 function(_package_add_dependencies pkg_name)
   _package_add_to_variable(DEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_dependencies pkg_name dependencies)
   _package_get_variable(DEPENDENCIES ${pkg_name} _dependencies)
   set(${dependencies} ${_dependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_unset_dependencies pkg_name)
   _package_variable_unset(DEPENDENCIES ${pkg_name})
 endfunction()
 
 function(_package_remove_dependency pkg_name dep)
   set(_deps ${${pkg_name}_DEPENDENCIES})
 
   _package_get_fdependencies(${dep} _fdeps)
 
   # check if this is the last reverse dependency
   list(LENGTH _fdeps len)
   list(FIND _fdeps ${pkg_name} pos)
   if((len EQUAL 1) AND (NOT pos EQUAL -1))
     _package_get_description(${dep} _dep_desc)
     _package_get_option_name(${dep} _dep_option_name)
     set(${_dep_option_name} ${${dep}_OLD} CACHE BOOL "${_dep_desc}" FORCE)
     unset(${dep}_OLD CACHE)
   endif()
 
   # remove the pkg_name form the reverse dependency
   _package_remove_fdependency(${dep} ${pkg_name})
 
   list(FIND _deps ${dep} pos)
   if(NOT pos EQUAL -1)
     list(REMOVE_AT _deps ${pos})
     _package_set_variable(DEPENDENCIES ${pkg_name} ${_deps})
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Functions to handle reverse dependencies
 # ------------------------------------------------------------------------------
 function(_package_set_rdependencies pkg_name)
   _package_set_variable(RDEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_rdependencies pkg_name rdependencies)
   _package_get_variable(RDEPENDENCIES ${pkg_name} _rdependencies)
   set(${rdependencies} ${_rdependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_rdependency pkg_name rdep)
   # store the reverse dependency
   _package_add_to_variable(RDEPENDENCIES ${pkg_name} ${rdep})
 endfunction()
 
 function(_package_remove_rdependency pkg_name rdep)
   _package_remove_from_variable(RDEPENDENCIES ${pkg_name} ${rdep})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Function to handle forcing dependencies (Package turn ON that enforce their
 # dependencies ON)
 # ------------------------------------------------------------------------------
 function(_package_set_fdependencies pkg_name)
   _package_set_variable(FDEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_fdependencies pkg_name fdependencies)
   _package_get_variable(FDEPENDENCIES ${pkg_name} _fdependencies)
   set(${fdependencies} ${_fdependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_fdependency pkg_name fdep)
   # store the reverse dependency
   _package_add_to_variable(FDEPENDENCIES ${pkg_name} ${fdep})
 endfunction()
 
 function(_package_remove_fdependency pkg_name fdep)
   _package_remove_from_variable(FDEPENDENCIES ${pkg_name} ${fdep})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Exteral package system as apt rpm dependencies
 # ------------------------------------------------------------------------------
 function(_package_set_package_system_dependency pkg system)
   string(TOUPPER "${_system}" _u_system)
   _package_set_variable(PACKAGE_SYSTEM_${_u_system} ${_pkg_name} ${ARGN})
 endfunction()
 
 
 function(_package_get_package_system_dependency pkg system var)
   string(TOUPPER "${_system}" _u_system)
   _package_get_variable(PACKAGE_SYSTEM_${_u_system} ${_pkg_name} ${_deps})
   set(${var} ${_deps} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation related functions
 # ------------------------------------------------------------------------------
 function(_package_set_documentation_files pkg_name)
   _package_set_variable(DOCUMENTATION_FILES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_documentation_files pkg_name doc_files)
   _package_get_variable(DOCUMENTATION_FILES ${pkg_name} _doc_files "")
   set(${doc_files} ${_doc_files} PARENT_SCOPE)
 endfunction()
 
 function(_package_set_documentation pkg_name)
   # \n replaced by && and \\ by ££ to avoid cache problems
   set(_doc_str "")
   foreach(_str ${ARGN})
     set(_doc_str "${_doc_str}&&${_str}")
   endforeach()
 
   string(REPLACE "\\" "££" _doc_escaped "${_doc_str}")
 
   _package_set_variable(DOCUMENTATION ${pkg_name} "${_doc_str}")
 endfunction()
 
 function(_package_get_documentation pkg_name _doc)
   # \n replaced by && and \\ by ££ to avoid cache problems
   _package_get_variable(DOCUMENTATION ${pkg_name} _doc_tmp "")
 
   string(REPLACE "££" "\\" _doc_escaped "${_doc_tmp}")
   string(REPLACE "&&" "\n" _doc_newlines "${_doc_escaped}")
   set(${_doc} "${_doc_newlines}" PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Special boost thingy
 # ------------------------------------------------------------------------------
 function(_package_set_boost_component_needed pkg_name)
   _package_add_to_variable(BOOST_COMPONENTS_NEEDED ${pkg_name} ${ARGN})
   package_get_name(Boost _boost_pkg_name)
   _package_add_dependencies(${pkg_name} ${_boost_pkg_name})
 endfunction()
 
 function(_package_get_boost_component_needed pkg_name needed)
   _package_get_variable(BOOST_COMPONENTS_NEEDED ${pkg_name} _needed)
   set(${needed} ${_needed} PARENT_SCOPE)
 endfunction()
 
 function(_package_load_boost_components)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   _package_get_variable_for_activated(BOOST_COMPONENTS_NEEDED _boost_needed_components)
   package_get_name(Boost _pkg_name)
 
   if(_boost_needed_components)
     message(STATUS "Looking for Boost liraries: ${_boost_needed_components}")
     foreach(_comp ${_boost_needed_components})
       find_package(Boost COMPONENTS ${_comp} QUIET)
       string(TOUPPER ${_comp} _u_comp)
       if(Boost_${_u_comp}_FOUND)
         message(STATUS "   ${_comp}: FOUND")
         package_set_project_variable(BOOST_${_u_comp} TRUE)
 
         # Generate the libraries for the package
         _package_add_libraries(${_pkg_name} ${Boost_${_u_comp}_LIBRARY})
       else()
         message(STATUS "   ${_comp}: NOT FOUND")
       endif()
     endforeach()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # get the list of source files for a given package
 # ------------------------------------------------------------------------------
 function(_package_get_source_files pkg_name SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   set(tmp_SRCS)
   set(tmp_PUBLIC_HEADERS)
   set(tmp_PRIVATE_HEADERS)
 
   foreach(_type SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
     foreach(_file ${${pkg_name}_${_type}})
       string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" _rel_file "${_file}")
       list(APPEND tmp_${_type} "${_rel_file}")
     endforeach()
   endforeach()
 
   set(${SRCS}            ${tmp_SRCS}            PARENT_SCOPE)
   set(${PUBLIC_HEADERS}  ${tmp_PUBLIC_HEADERS}  PARENT_SCOPE)
   set(${PRIVATE_HEADERS} ${tmp_PRIVATE_HEADERS} PARENT_SCOPE)
 endfunction()
 
 # ==============================================================================
 # Internal functions
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Build the reverse dependencies from the dependencies
 # ------------------------------------------------------------------------------
 function(_package_build_rdependencies)
   package_get_all_packages(_pkg_list)
 
   # set empty lists
   foreach(_pkg_name ${_pkg_list})
     set(${_pkg_name}_rdeps)
   endforeach()
 
   # fill the dependencies list
   foreach(_pkg_name ${_pkg_list})
     _package_get_dependencies(${_pkg_name} _deps)
     foreach(_dep_name ${_deps})
       list(APPEND ${_dep_name}_rdeps ${_pkg_name})
     endforeach()
   endforeach()
 
   # clean and set the reverse dependencies
   foreach(_pkg_name ${_pkg_list})
     if(${_pkg_name}_rdeps)
       list(REMOVE_DUPLICATES ${_pkg_name}_rdeps)
       _package_set_rdependencies(${_pkg_name} ${${_pkg_name}_rdeps})
     endif()
   endforeach()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # This function resolve the dependance order run the needed find_packages
 # ------------------------------------------------------------------------------
 function(_package_load_packages)
   package_get_all_packages(_pkg_list)
 
   # Activate the dependencies of activated package and generate an ordered list
   # of dependencies
   set(ordered_loading_list)
   foreach(_pkg_name ${_pkg_list})
     _package_load_dependencies_package(${_pkg_name} ordered_loading_list)
   endforeach()
 
   # Load the packages in the propoer order
   foreach(_pkg_name ${ordered_loading_list})
     _package_get_option_name(${_pkg_name} _option_name)
 
     if(${_option_name})
       _package_load_package(${_pkg_name})
     else()
       # deactivate the packages than can already be deactivated
       _package_deactivate(${_pkg_name})
     endif()
   endforeach()
 
   # generates the activated and unactivated lists of packages
   set(_packages_activated)
   set(_packages_deactivated)
   foreach(_pkg_name ${_pkg_list})
     _package_is_activated(${_pkg_name} _active)
     set(_exclude FALSE)
     _package_get_variable(EXCLUDE_FROM_ALL ${_pkg_name} _exclude)
     if(_active AND NOT _exclude)
       list(APPEND _packages_activated ${_pkg_name})
     else()
       list(APPEND _packages_deactivated ${_pkg_name})
     endif()
   endforeach()
 
   # generate the list usable by the calling code
   package_set_project_variable(ACTIVATED_PACKAGE_LIST "${_packages_activated}")
   package_set_project_variable(DEACTIVATED_PACKAGE_LIST "${_packages_deactivated}")
 endfunction()
 
 
 
 # ------------------------------------------------------------------------------
 # This load an external package and recursively all its dependencies
 # ------------------------------------------------------------------------------
 function(_package_load_dependencies_package pkg_name loading_list)
   # Get packages informations
   _package_get_option_name(${pkg_name} _pkg_option_name)
   _package_get_dependencies(${pkg_name} _dependencies)
 
   # handle the dependencies
   foreach(_dep_name ${_dependencies})
     _package_get_description(${_dep_name} _dep_desc)
     _package_get_option_name(${_dep_name} _dep_option_name)
 
     _package_get_fdependencies(${_dep_name} _fdeps)
     if(${_pkg_option_name})
       if("${_fdeps}" STREQUAL "")
         set(${_dep_name}_OLD ${${_dep_option_name}} CACHE INTERNAL "" FORCE)
       endif()
 
       # set the option to on
       set(${_dep_option_name} ON CACHE BOOL "${_dep_desc}" FORCE)
 
       # store the reverse dependency
       _package_add_fdependency(${_dep_name} ${pkg_name})
     else()
       # check if this is the last reverse dependency
       list(LENGTH _fdeps len)
       list(FIND _fdeps ${pkg_name} pos)
       if((len EQUAL 1) AND (NOT pos EQUAL -1))
         set(${_dep_option_name} ${${_dep_name}_OLD} CACHE BOOL "${_dep_desc}" FORCE)
         unset(${_dep_name}_OLD CACHE)
       endif()
 
       # remove the pkg_name form the reverse dependency
       _package_remove_fdependency(${_dep_name} ${pkg_name})
     endif()
 
     # recusively load the dependencies
     _package_load_dependencies_package(${_dep_name} ${loading_list})
   endforeach()
 
   # get the compile flags
   _package_get_compile_flags(${pkg_name} CXX _pkg_compile_flags)
   package_get_project_variable(NO_AUTO_COMPILE_FLAGS _no_auto_compile_flags)
 
   # if package option is on add it in the list
   if(${_pkg_option_name})
     list(FIND ${loading_list} ${pkg_name} _pos)
     if(_pos EQUAL -1)
       set(_tmp_loading_list ${${loading_list}})
       list(APPEND _tmp_loading_list ${pkg_name})
       set(${loading_list} "${_tmp_loading_list}" PARENT_SCOPE)
     endif()
 
     #add the comilation flags if needed
     if(_pkg_compile_flags AND NOT _no_auto_compile_flags)
       add_flags(cxx ${_pkg_compile_flags})
     endif()
   else()
     #remove the comilation flags if needed
     if(_pkg_comile_flags AND NOT _no_auto_compile_flags)
       remove_flags(cxx ${_pkg_compile_flags})
     endif()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Load the package if it is an external one
 # ------------------------------------------------------------------------------
 function(_package_load_package pkg_name)
   # load the package if it is an external
   _package_get_nature(${pkg_name} _nature)
   if(${_nature} MATCHES "external")
     _package_use_system(${pkg_name} _use_system)
 
     set(_activated TRUE)
     if(_use_system)
       _package_load_external_package(${pkg_name} _activated)
     endif()
 
-
     _package_has_system_fallback(${pkg_name} _fallback)
-
-    message("${pkg_name} fb ${_fallback} sys ${_use_system} acti ${_activated}" )
     if((NOT _use_system) OR (_fallback AND (NOT _activated)))
       _package_load_third_party_script(${pkg_name})
     endif()
 
     if(_activated)
       _package_activate(${pkg_name})
     elseif()
       _package_deactivate(${pkg_name})
     endif()
-  else(${_nature})
+  else()
     _package_activate(${pkg_name})
   endif()
 endfunction()
 
 
 # ------------------------------------------------------------------------------
 # Load external packages
 # ------------------------------------------------------------------------------
 function(_package_load_external_package pkg_name activate)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER ${_real_name} _u_package)
 
   if(NOT ${pkg_name}_USE_SYSTEM_PREVIOUS)
     #if system was off before clear the cache of preset variables
     get_cmake_property(_all_vars VARIABLES)
     foreach(_var ${_all_vars})
       if(_var MATCHES "^${_u_package}_.*")
         unset(${_var} CACHE)
       endif()
     endforeach()
     set(${pkg_name}_USE_SYSTEM_PREVIOUS TRUE CACHE INTERNAL "" FORCE)
   endif()
 
   _package_get_find_package_extra_options(${pkg_name} _options)
   if(_options)
     cmake_parse_arguments(_opt_pkg "" "LANGUAGE" "LINK_LIBRARIES;PREFIX;FOUND;ARGS" ${_options})
     if(_opt_pkg_UNPARSED_ARGUMENTS)
       message("You passed too many options for the find_package related to ${${pkg_name}} \"${_opt_pkg_UNPARSED_ARGUMENTS}\"")
     endif()
   endif()
 
   if(_opt_pkg_LANGUAGE)
     foreach(_language ${_opt_pkg_LANGUAGE})
       enable_language(${_language})
     endforeach()
   endif()
 
   # find the package
   set(_required REQUIRED)
   _package_has_system_fallback(${pkg_name} _fallback)
   if(_fallback)
     set(_required QUIET)
   endif()
 
   find_package(${_real_name} ${_required} ${_opt_pkg_ARGS})
 
   # check if the package is found
   if(_opt_pkg_PREFIX)
     set(_package_prefix ${_opt_pkg_PREFIX})
   else()
     set(_package_prefix ${_u_package})
   endif()
 
   set(_act FALSE)
   set(_prefix_to_consider)
   if(DEFINED _opt_pkg_FOUND)
     if(${_opt_pkg_FOUND})
       set(_act TRUE)
       set(_prefix_to_consider ${_package_prefix})
     endif()
   else()
     foreach(_prefix ${_package_prefix})
       if(${_prefix}_FOUND)
         set(_act TRUE)
         list(APPEND _prefix_to_consider ${_prefix})
       endif()
     endforeach()
   endif()
 
   if(_act)
     foreach(_prefix ${_prefix_to_consider})
       # Generate the include dir for the package
       if(DEFINED ${_prefix}_INCLUDE_DIRS)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_DIRS})
       elseif(DEFINED ${_prefix}_INCLUDE_DIR)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_DIR})
       elseif(DEFINED ${_prefix}_INCLUDE_PATH)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_PATH})
       endif()
 
       # Generate the libraries for the package
       if(_opt_pkg_LINK_LIBRARIES)
         _package_set_libraries(${pkg_name} ${_opt_pkg_LINK_LIBRARIES})
       elseif(DEFINED ${_prefix}_LIBRARIES)
         _package_set_libraries(${pkg_name} ${${_prefix}_LIBRARIES})
       elseif(DEFINED ${_prefix}_LIBRARY)
         _package_set_libraries(${pkg_name} ${${_prefix}_LIBRARY})
       endif()
     endforeach()
 
     _package_get_callback_script(${pkg_name} _script_file)
     if(_script_file)
       include("${_script_file}")
     endif()
   endif()
   set(${activate} ${_act} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Sanity check functions
 # ------------------------------------------------------------------------------
 function(_package_check_files_exists)
   set(_message FALSE)
 
   package_get_all_packages(_pkg_list)
   foreach(_pkg_name ${_pkg_list})
     set(_pkg_files
       ${${_pkg_name}_SRCS}
       ${${_pkg_name}_PUBLIC_HEADERS}
       ${${_pkg_name}_PRIVATE_HEADERS}
       )
 
     _package_get_real_name(${_pkg_name} _real_name)
 
     foreach(_file ${_pkg_files})
       if(NOT EXISTS "${_file}")
         if(NOT _message)
           set(_message TRUE)
           message("This file(s) is(are) present in a package but are not present on disk.")
         endif()
 
         message(" PACKAGE ${_real_name} FILE ${_file}")
       endif()
     endforeach()
   endforeach()
 
   if(_message)
     message(SEND_ERROR "Please check the content of your packages to correct this warnings")
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 function(_package_check_files_registered)
   set(_pkg_files)
   package_get_all_packages(_pkg_list)
   # generates a file list of registered files
   foreach(_pkg_name ${_pkg_list})
     list(APPEND _pkg_files
       ${${_pkg_name}_SRCS}
       ${${_pkg_name}_PUBLIC_HEADERS}
       ${${_pkg_name}_PRIVATE_HEADERS}
       )
   endforeach()
 
   # generates the list of files in the source folders
   set(_all_src_files)
   foreach(_src_folder ${ARGN})
     foreach(_ext "cc" "hh" "c" "h" "hpp")
       file(GLOB_RECURSE _src_files "${_src_folder}/*.${_ext}")
       list(APPEND _all_src_files ${_src_files})
     endforeach()
   endforeach()
 
   if(_all_src_files)
     list(REMOVE_DUPLICATES _all_src_files)
   endif()
 
   set(_not_registerd_files)
   # check only sources files in the source folders
   foreach(_src_folder ${ARGN})
     foreach(_file ${_all_src_files})
       if("${_file}" MATCHES  "${_src_folder}")
         list(FIND _pkg_files "${_file}" _index)
         if (_index EQUAL -1)
           list(APPEND _not_registerd_files ${_file})
         endif()
       endif()
     endforeach()
   endforeach()
 
   if(AUTO_MOVE_UNKNOWN_FILES)
     file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/unknown_files)
   endif()
 
   # warn the user and move the files if needed
   if(_not_registerd_files)
     if(EXISTS ${PROJECT_BINARY_DIR}/missing_files_in_packages)
       file(REMOVE ${PROJECT_BINARY_DIR}/missing_files_in_packages)
     endif()
 
     message("This files are present in the source folders but are not registered in any package")
     foreach(_file ${_not_registerd_files})
       message(" ${_file}")
       if(AUTO_MOVE_UNKNOWN_FILES)
         get_filename_component(_file_name ${_file} NAME)
         file(RENAME ${_file} ${PROJECT_BINARY_DIR}/unknown_files/${_file_name})
       endif()
 
       file(APPEND ${PROJECT_BINARY_DIR}/missing_files_in_packages "${_file}
 ")
     endforeach()
 
     if(AUTO_MOVE_UNKNOWN_FILES)
       message(SEND_ERROR "The files where moved in the followinf folder ${PROJECT_BINARY_DIR}/unknown_files\n
 Please register them in the good package or clean the sources")
     else()
       message(SEND_ERROR "Please register them in the good package or clean the sources")
     endif()
 
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
diff --git a/packages/google-test.cmake b/packages/google-test.cmake
index 05af14af9..780afec72 100644
--- a/packages/google-test.cmake
+++ b/packages/google-test.cmake
@@ -1,14 +1,15 @@
 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")
 package_add_third_party_script_variable(google-test
   GTEST_GIT "https://github.com/google/googletest.git")
diff --git a/packages/pybind11.cmake b/packages/pybind11.cmake
index ba433204d..e86f42a26 100644
--- a/packages/pybind11.cmake
+++ b/packages/pybind11.cmake
@@ -1,13 +1,13 @@
-set(PYBIND11_PYTHON_VERSION 3)
+set(PYBIND11_PYTHON_VERSION ${AKANTU_PREFERRED_PYTHON_VERSION} CACHE INTERNAL "")
 
 package_declare(pybind11 EXTERNAL
   EXTRA_PACKAGE_OPTIONS ARGS "2.2;CONFIG" LINK_LIBRARIES pybind11::embed PREFIX pybind11
   DESCRIPTION "Akantu's pybind11 interface"
   SYSTEM AUTO third-party/cmake/pybind11.cmake
-  EXCLUDE_ALL
+  EXCLUDE_FROM_ALL
   )
 
 package_add_third_party_script_variable(pybind11
   PYBIND11_VERSION "v2.2")
 package_add_third_party_script_variable(pybind11
   PYBIND11_GIT "https://github.com/pybind/pybind11.git")
diff --git a/packages/pythonlibs.cmake b/packages/pythonlibs.cmake
index 8ab88defe..e3b36d6ae 100644
--- a/packages/pythonlibs.cmake
+++ b/packages/pythonlibs.cmake
@@ -1,51 +1,49 @@
 #===============================================================================
 # @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 Jan 22 2016
 #
 # @brief  package description for the python 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(Python_ADDITIONAL_VERSIONS 2.7)
-
+set(Python_ADDITIONAL_VERSIONS ${AKANTU_PREFERRED_PYTHON_VERSION})
 package_declare(PythonLibs EXTERNAL DESCRIPTION "Akantu's python interface"
   DEPENDS numpy
   EXTRA_PACKAGE_OPTIONS PREFIX PYTHON FOUND PYTHONLIBS_FOUND
   )
 
-package_set_package_system_dependency(PythonLibs deb libpython2.7)
-package_set_package_system_dependency(PythonLibs deb-src libpython2.7-dev)
+package_set_package_system_dependency(PythonLibs deb libpython3)
+package_set_package_system_dependency(PythonLibs deb-src libpython3-dev)
 
 package_declare_documentation(PythonLibs
   "This package is a dependency of the python interface"
   ""
   "Under Ubuntu (14.04 LTS) the installation can be performed using the commands:"
   "\\begin{command}"
   "  > sudo apt-get install libpython2.7-dev"
   "\\end{command}"
   ""
 )
diff --git a/third-party/cmake/gtest.cmake b/third-party/cmake/gtest.cmake
index b903e1201..7f6a9abb2 100644
--- a/third-party/cmake/gtest.cmake
+++ b/third-party/cmake/gtest.cmake
@@ -1,46 +1,47 @@
 set(_working_dir ${PROJECT_BINARY_DIR}/third-party/src/gtest-download)
 
 configure_file(${PROJECT_SOURCE_DIR}/third-party/gtest.cmake.in ${_working_dir}/CMakeLists.txt)
 
 set(GTEST_ROOT ${PROJECT_BINARY_DIR}/third-party)
 find_package(GTest QUIET)
 
 if(NOT GTEST_FOUND)
   if(NOT EXISTS ${PROJECT_SOURCE_DIR}/third-party/google-test)
     message(STATUS "Downloading googletest")
     execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
       RESULT_VARIABLE result WORKING_DIRECTORY ${_working_dir}
       OUTPUT_FILE ${_working_dir}/configure-out.log
       ERROR_FILE ${_working_dir}/configure-error.log)
 
     if(result)
       message(SEND_ERROR "CMake step for googletest failed: ${result}")
       return()
     endif()
 
     execute_process(COMMAND ${CMAKE_COMMAND} --build .
       RESULT_VARIABLE result WORKING_DIRECTORY ${_working_dir}
       OUTPUT_FILE ${_working_dir}/build-out.log
       ERROR_FILE ${_working_dir}/build-error.log)
 
     if(result)
       message(SEND_ERROR "Downloading googletest failed: ${result}")
       return()
     endif()
   endif()
 
   set(gtest_build_tests OFF CACHE INTERNAL "" FORCE)
   set(BUILD_GTEST ON CACHE INTERNAL "" FORCE)
   set(BUILD_GMOCK OFF CACHE INTERNAL "" FORCE)
 
+  set(Python_ADDITIONAL_VERSIONS ${AKANTU_PREFERRED_PYTHON_VERSION})
   add_subdirectory(third-party/google-test)
 
   add_library(GTest::Main ALIAS gtest_main)
   add_library(GTest::GTest ALIAS gtest)
 
   set(gtest_FOUND TRUE CACHE INTERNAL "" FORCE)
   set(GTEST_INCLUDE_DIRS third-party/google-test/googletest/include CACHE INTERNAL "" FORCE)
   set(GTEST_LIBRARIES GTest::Main CACHE INTERNAL "" FORCE)
 
   mask_package_options(gtest)
 endif()