diff --git a/.gitignore b/.gitignore
index 4bfb6b1b1..9d56fc628 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,31 +1,31 @@
 build*
 .dir-locals.el
 TAGS
 third-party/*/
 !third-party/cmake/*
-!third-party/akantu-iterators
+!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
 .vscode
 .auctex*
 .clangd
 .ccls-cache
diff --git a/third-party/akantu_iterators/include/aka_named_tuple.hh b/third-party/akantu_iterators/include/aka_named_tuple.hh
new file mode 100644
index 000000000..c04075d7f
--- /dev/null
+++ b/third-party/akantu_iterators/include/aka_named_tuple.hh
@@ -0,0 +1,275 @@
+/**
+ * @file   aka_tuple_tools.hh
+ *
+ * @author Nicolas Richart <nicolas.richart@epfl.ch>
+ *
+ * @date creation: Fri Aug 11 2017
+ * @date last modification: Mon Jan 29 2018
+ *
+ * @brief  iterator interfaces
+ *
+ *
+ * Copyright 2019 EPFL (Ecole Polytechnique Fédérale de Lausanne)
+ * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
+ *
+ * Akantu is free  software: you can redistribute it and/or  modify it under the
+ * terms  of the  GNU Lesser  General Public  License as published by  the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
+ * details.
+ *
+ * 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_compatibilty_with_cpp_standard.hh"
+#include "aka_str_hash.hh"
+/* -------------------------------------------------------------------------- */
+#include <tuple>
+/* -------------------------------------------------------------------------- */
+
+#ifndef AKANTU_AKA_NAMED_TUPLE_HH
+#define AKANTU_AKA_NAMED_TUPLE_HH
+
+#ifndef AKANTU_ITERATORS_NAMESPACE
+#define AKANTU_ITERATORS_NAMESPACE akantu
+#endif
+
+namespace AKANTU_ITERATORS_NAMESPACE {
+
+namespace tuple {
+  using hash_type = uint64_t;
+
+  /* ------------------------------------------------------------------------ */
+  template <typename tag, typename type> struct named_tag {
+    using _tag = tag;   ///< key
+    using _type = type; ///< value type
+
+    template <
+        typename T,
+        std::enable_if_t<not std::is_same<named_tag, T>::value> * = nullptr>
+    named_tag(T && value) // NOLINT
+        : _value(std::forward<T>(value)) {}
+
+    type _value;
+  };
+
+  namespace details {
+/* -------------------------------------------------------------------------- */
+#if (defined(__GNUC__) || defined(__GNUG__))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Weffc++"
+#endif
+    template <typename tag> struct named_tag_proxy {
+      using _tag = tag;
+
+      template <typename T> auto operator=(T && value) -> decltype(auto) {
+        return named_tag<_tag, T>{std::forward<T>(value)};
+      }
+    };
+#if (defined(__GNUC__) || defined(__GNUG__))
+#pragma GCC diagnostic pop
+#endif
+  } // namespace details
+
+  /* ------------------------------------------------------------------------ */
+  template <typename T> struct is_named_tag : public std::false_type {};
+  template <typename tag>
+  struct is_named_tag<details::named_tag_proxy<tag>> : public std::true_type {};
+  template <typename tag, typename type>
+  struct is_named_tag<named_tag<tag, type>> : public std::true_type {};
+  /* ------------------------------------------------------------------------ */
+
+  template <class... Params>
+  struct named_tuple : public std::tuple<typename Params::_type...> {
+    using Names_t = std::tuple<typename Params::_tag...>;
+    using parent = std::tuple<typename Params::_type...>;
+
+    named_tuple(Params &&... params)
+        : parent(std::forward<typename Params::_type>(params._value)...) {}
+
+    named_tuple(typename Params::_type &&... args)
+        : parent(std::forward<typename Params::_type>(args)...) {}
+
+  private:
+    template <typename tag, std::size_t Idx,
+              std::enable_if_t<Idx == sizeof...(Params)> * = nullptr>
+    static constexpr auto get_element_index_() noexcept -> std::size_t {
+      return -1;
+    }
+
+    template <typename tag, std::size_t Idx,
+              std::enable_if_t<(Idx < sizeof...(Params))> * = nullptr>
+    static constexpr auto get_element_index_() noexcept -> std::size_t {
+      using _tag = std::tuple_element_t<Idx, Names_t>;
+      return (std::is_same<_tag, tag>::value)
+                 ? Idx
+                 : get_element_index_<tag, Idx + 1>();
+    }
+
+  public:
+    template <typename NT>
+    static constexpr auto get_element_index() noexcept -> std::size_t {
+      return get_element_index_<typename NT::_tag, 0>();
+    }
+
+    template <typename NT>
+    static constexpr auto get_element_index(NT && /*unused*/) noexcept
+        -> std::size_t {
+      return get_element_index_<typename NT::_tag, 0>();
+    }
+
+    template <typename NT,
+              std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
+    constexpr auto get(NT && /*unused*/) noexcept -> decltype(auto) {
+      const auto index = get_element_index<NT>();
+      static_assert((index != std::size_t(-1)), "wrong named_tag");
+      return (std::get<index>(*this));
+    }
+
+    template <typename NT,
+              std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
+    constexpr auto get(NT && /*unused*/) const noexcept -> decltype(auto) {
+      const auto index = get_element_index<NT>();
+      static_assert((index != std::size_t(-1)), "wrong named_tag");
+      return (std::get<index>(*this));
+    }
+
+    template <typename NT,
+              std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
+    constexpr auto has(NT && /*unused*/) const noexcept -> bool {
+      const auto index = get_element_index<NT>();
+      return (index != std::size_t(-1));
+    }
+
+    template <typename NT,
+              std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
+    static constexpr auto has() noexcept -> bool {
+      constexpr auto index = get_element_index<NT>();
+      return (index != std::size_t(-1));
+    }
+
+    template <hash_type HashCode> static constexpr auto has() noexcept -> bool {
+      constexpr auto index =
+          get_element_index_<std::integral_constant<hash_type, HashCode>, 0>();
+      return (index != std::size_t(-1));
+    }
+  };
+
+  /* ---------------------------------------------------------------------- */
+  template <typename T> struct is_named_tuple : public std::false_type {};
+  template <typename... Params>
+  struct is_named_tuple<named_tuple<Params...>> : public std::true_type {};
+  /* ---------------------------------------------------------------------- */
+
+  template <typename... Params>
+  constexpr auto make_named_tuple(Params &&... params) noexcept
+      -> decltype(auto) {
+    return named_tuple<Params...>(std::forward<Params>(params)...);
+  }
+
+  template <typename tag>
+  constexpr auto make_named_tag() noexcept -> decltype(auto) {
+    return details::named_tag_proxy<tag>{};
+  }
+
+  template <hash_type HashCode> constexpr auto get() -> decltype(auto) {
+    return make_named_tag<std::integral_constant<hash_type, HashCode>>();
+  }
+
+  template <hash_type HashCode, class Tuple>
+  constexpr auto get(Tuple && tuple) -> decltype(auto) {
+    return tuple.get(get<HashCode>());
+  }
+
+  template <hash_type HashCode, class Tuple> struct has_helper {
+    using type =
+        aka::bool_constant<std::decay_t<Tuple>::template has<HashCode>()>;
+  };
+
+  template <hash_type HashCode, class Tuple>
+  using has_t = typename has_helper<HashCode, Tuple>::type;
+
+  template <hash_type HashCode, class Tuple>
+  constexpr auto has(Tuple && /*tuple*/) -> bool {
+    return has_t<HashCode, Tuple>::value;
+  }
+
+  template <hash_type HashCode, class Tuple> constexpr auto has() -> bool {
+    return has_t<HashCode, Tuple>::value;
+  }
+
+  template <typename Param, typename Tuple,
+            std::enable_if_t<is_named_tag<Param>::value> * = nullptr>
+  constexpr auto get(Tuple && tuple) noexcept -> decltype(auto) {
+    return tuple.template get<typename Param::hash>();
+  }
+
+  template <std::size_t I, class Tuple> struct tuple_name_tag {
+    using type = std::decay_t<
+        std::tuple_element_t<I, typename std::decay_t<Tuple>::Names_t>>;
+  };
+
+  template <std::size_t I, class Tuple>
+  using tuple_name_tag_t = typename tuple_name_tag<I, Tuple>::type;
+
+  template <std::size_t I, class Tuple> struct tuple_element {
+    using type = std::tuple_element_t<I, typename Tuple::parent>;
+  };
+
+  template <std::size_t I, class Tuple>
+  using tuple_element_t = typename tuple_element<I, Tuple>::type;
+
+#if defined(__INTEL_COMPILER)
+// intel warnings here
+#elif defined(__clang__)
+// clang warnings here
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
+#elif (defined(__GNUC__) || defined(__GNUG__))
+// gcc warnings here
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+  /// this is a GNU exstension
+  /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3599.html
+  template <class CharT, CharT... chars>
+  constexpr auto operator"" _n() -> decltype(auto) {
+    return make_named_tag<std::integral_constant<
+        std::size_t, string_literal<CharT, chars...>::hash>>();
+  }
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif (defined(__GNUC__) || defined(__GNUG__))
+#pragma GCC diagnostic pop
+#endif
+
+} // namespace tuple
+
+} // namespace AKANTU_ITERATORS_NAMESPACE
+
+namespace aka {
+template <typename tag, typename type_>
+struct size_type<AKANTU_ITERATORS_NAMESPACE::tuple::named_tag<tag, type_>> {
+  using type = typename std::decay_t<type_>::size_type;
+};
+} // namespace aka
+
+/* -------------------------------------------------------------------------- */
+#include <iterator>
+/* -------------------------------------------------------------------------- */
+
+namespace std {
+template <typename tag, typename type>
+struct iterator_traits<
+    ::AKANTU_ITERATORS_NAMESPACE::tuple::named_tag<tag, type>>
+    : public iterator_traits<type> {};
+} // namespace std
+
+#endif /* AKANTU_AKA_NAMED_TUPLE_HH */