diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
new file mode 100644
index 0000000000..258e93f66a
--- /dev/null
+++ b/mesh_handle/competence_pack.hxx
@@ -0,0 +1,51 @@
+/*
+  This file is part of t8code.
+  t8code is a C library to manage a collection (a forest) of multiple
+  connected adaptive space-trees of general element classes in parallel.
+
+  Copyright (C) 2025 the developers
+
+  t8code is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  t8code is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with t8code; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/** \file competence_pack.hxx
+ * Define to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ */
+#ifndef T8_COMPETENCE_PACK_HXX
+#define T8_COMPETENCE_PACK_HXX
+
+#include "competences.hxx"
+namespace t8_mesh_handle
+{
+/** Class to pack different competences into one template parameter for the \ref mesh class.
+ * \tparam TCompetence The competences to be packed.
+ */
+template <template <typename> class... TCompetence>
+struct competence_pack
+{
+  /** Apply the competence pack to a template class, e.g. the \ref element class.
+   * \tparam Target The target template class to apply the \a TCompetence pack to.
+   */
+  template <typename mesh_class, template <typename, template <typename> class...> class Target>
+  using apply = Target<mesh_class, TCompetence...>;
+
+  using is_competence_pack = void; /**< Tag to identify this class. */
+};
+
+/** Predefined competence pack combining all caching competences. */
+using cache_competences = competence_pack<cache_volume, cache_vertex_coordinates, cache_centroid, cache_neighbors>;
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_COMPETENCE_PACK_HXX */
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index d4bc37a5b0..c265c53035 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -48,6 +48,29 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 namespace t8_mesh_handle
 {
 
+/**
+ * Competence to cache the volume of an element at the first function call.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
+{
+ public:
+  /**
+   * Function that checks if the cache for the volume has been filled.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  volume_cache_filled () const
+  {
+    return m_volume.has_value ();
+  }
+
+ protected:
+  mutable std::optional<double>
+    m_volume; /**< Cache for the volume. Use optional to allow no value if cache is not filled. */
+};
+
 /**
  * Competence to cache the vertex coordinates of an element at the first function call.
  * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index 9c35440d54..cb74480d3e 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -39,11 +39,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 namespace t8_mesh_handle
 {
-/** Forward declaration of the \ref mesh class of the handle.
- */
-template <template <typename> class... TCompetence>
-class mesh;
-
 /** 
  * Definition of the mesh element class of the \ref mesh handle.
  * An element without specified template parameters provides default implementations for basic functionality 
@@ -62,11 +57,11 @@ class mesh;
  *
  * \tparam TCompetence The competences you want to add to the default functionality of the element.
  */
-template <template <typename> class... TCompetence>
-class element: public TCompetence<element<TCompetence...>>... {
+template <typename mesh_class, template <typename> class... TCompetence>
+class element: public TCompetence<element<mesh_class, TCompetence...>>... {
  private:
-  using SelfType = element<TCompetence...>; /**< Type of the current class with all template parameters specified. */
-  using mesh_class = mesh<TCompetence...>;  /**< Type of the mesh class used. */
+  using SelfType
+    = element<mesh_class, TCompetence...>; /**< Type of the current class with all template parameters specified. */
   friend mesh_class; /**< Define mesh_class as friend to be able to access e.g. the constructor. */
 
   /**
@@ -89,7 +84,7 @@ class element: public TCompetence<element<TCompetence...>>... {
       m_element = t8_forest_get_leaf_element_in_tree (m_mesh->m_forest, m_tree_id, m_element_id);
     }
 
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       // Resize neighbor caches for clean access to the caches.
       const int num_faces = this->get_num_faces ();
       this->m_num_neighbors.resize (num_faces);
@@ -99,6 +94,16 @@ class element: public TCompetence<element<TCompetence...>>... {
   }
 
   // --- Variables to check which functionality is defined in TCompetence. ---
+  /** Helper function to check if class T implements the function volume_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  volume_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
+  }
   /** Helper function to check if class T implements the function vertex_cache_filled.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
@@ -109,10 +114,6 @@ class element: public TCompetence<element<TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function vertex_cache_filled. */
-  static constexpr bool vertex_cache_exists = (false || ... || vertex_cache_defined<TCompetence> ());
-
   /** Helper function to check if class T implements the function centroid_cache_filled.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
@@ -123,10 +124,6 @@ class element: public TCompetence<element<TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function centroid_cache_filled. */
-  static constexpr bool centroid_cache_exists = (false || ... || centroid_cache_defined<TCompetence> ());
-
   /** Helper function to check if class T implements the function neighbor_cache_filled.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
@@ -137,12 +134,18 @@ class element: public TCompetence<element<TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function neighbor_cache_filled. */
-  static constexpr bool neighbor_cache_exists = (false || ... || neighbor_cache_defined<TCompetence> ());
 
  public:
   // --- Public functions to check if caches exist. ---
+  /**
+   * Function that checks if a cache for the element's volume exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_volume_cache ()
+  {
+    return (false || ... || volume_cache_defined<TCompetence> ());
+  }
   /**
    * Function that checks if a cache for the vertex coordinates exists.
    * \return true if a cache for the vertex coordinates exists, false otherwise.
@@ -150,7 +153,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   static constexpr bool
   has_vertex_cache ()
   {
-    return vertex_cache_exists;
+    return (false || ... || vertex_cache_defined<TCompetence> ());
   }
 
   /**
@@ -160,7 +163,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   static constexpr bool
   has_centroid_cache ()
   {
-    return centroid_cache_exists;
+    return (false || ... || centroid_cache_defined<TCompetence> ());
   }
 
   /**
@@ -170,7 +173,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   static constexpr bool
   has_face_neighbor_cache ()
   {
-    return neighbor_cache_exists;
+    return (false || ... || neighbor_cache_defined<TCompetence> ());
   }
 
   // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
@@ -209,6 +212,25 @@ class element: public TCompetence<element<TCompetence...>>... {
     return t8_forest_get_scheme (m_mesh->m_forest)->element_get_shape (get_tree_class (), get_element ());
   }
 
+  /**
+   * Getter for the element's volume.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * \return The volume of the element.
+   */
+  double
+  get_volume () const
+  {
+    if constexpr (has_volume_cache ()) {
+      if (this->volume_cache_filled ()) {
+        return this->m_volume.value ();
+      }
+      // Fill cache.
+      this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
+      return this->m_volume.value ();
+    }
+    return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
+  }
+
   /**
    * Getter for the vertex coordinates of the element.
    * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
@@ -218,7 +240,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   get_vertex_coordinates () const
   {
     // Check if we have a cached version and if the cache has already been filled.
-    if constexpr (vertex_cache_exists) {
+    if constexpr (has_vertex_cache ()) {
       if (this->vertex_cache_filled ()) {
         return this->m_vertex_coordinates;
       }
@@ -232,7 +254,7 @@ class element: public TCompetence<element<TCompetence...>>... {
       t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, element, icorner, vertex_coordinates[icorner].data ());
     }
     // Fill the cache in the cached version.
-    if constexpr (vertex_cache_exists) {
+    if constexpr (has_vertex_cache ()) {
       this->m_vertex_coordinates = std::move (vertex_coordinates);
       return this->m_vertex_coordinates;
     }
@@ -248,7 +270,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   get_centroid () const
   {
     // Check if we have a cached version and if the cache has already been filled.
-    if constexpr (centroid_cache_exists) {
+    if constexpr (has_centroid_cache ()) {
       if (this->centroid_cache_filled ()) {
         return this->m_centroid.value ();
       }
@@ -256,7 +278,7 @@ class element: public TCompetence<element<TCompetence...>>... {
     t8_3D_point coordinates;
     t8_forest_element_centroid (m_mesh->m_forest, m_tree_id, get_element (), coordinates.data ());
     // Fill the cache in the cached version.
-    if constexpr (centroid_cache_exists) {
+    if constexpr (has_centroid_cache ()) {
       this->m_centroid = coordinates;
     }
     return coordinates;
@@ -272,7 +294,7 @@ class element: public TCompetence<element<TCompetence...>>... {
   get_face_neighbors (int face, std::optional<std::reference_wrapper<std::vector<int>>> dual_faces = std::nullopt) const
   {
     SC_CHECK_ABORT (!m_is_ghost_element, "get_face_neighbors is not implemented for ghost elements.\n");
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       if (this->neighbor_cache_filled (face)) {
         if (dual_faces) {
           dual_faces->get () = this->m_dual_faces[face];
@@ -296,7 +318,7 @@ class element: public TCompetence<element<TCompetence...>>... {
     for (int ineighs = 0; ineighs < num_neighbors; ineighs++) {
       neighbors_handle.push_back (&((*m_mesh)[neighids[ineighs]]));
     }
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       // Also store num_neighbors in cache to indicate that the cache is filled if a face does not have any neighbor.
       this->m_num_neighbors[face] = num_neighbors;
       this->m_dual_faces[face].assign (dual_faces_internal, dual_faces_internal + num_neighbors);
@@ -309,7 +331,7 @@ class element: public TCompetence<element<TCompetence...>>... {
       T8_FREE (dual_faces_internal);
       T8_FREE (neighids);
     }
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       return this->m_neighbors[face];
     }
     return neighbors_handle;
@@ -320,7 +342,7 @@ class element: public TCompetence<element<TCompetence...>>... {
    */
   void
   fill_face_neighbor_cache () const
-    requires (neighbor_cache_exists)
+    requires (has_face_neighbor_cache ())
   {
     for (int iface = 0; iface < get_num_faces (); iface++) {
       get_face_neighbors (iface);
@@ -390,6 +412,34 @@ class element: public TCompetence<element<TCompetence...>>... {
     return m_is_ghost_element;
   }
 
+  // --- Getter and setter for element data. ---
+  /** Getter for the element data.
+   * For ghost elements ensure that \ref mesh::exchange_ghost_data is called on each process first.
+   * Element data for non-ghost elements can be accessed (if set) directly.
+   * \return Element data with data of Type mesh_class::ElementDataType.
+   */
+  template <typename E = typename mesh_class::ElementDataType, typename = std::enable_if_t<!std::is_void<E>::value>>
+  const E&
+  get_element_data () const
+  {
+    return m_mesh->m_element_data[get_element_handle_id ()];
+  }
+
+  /** 
+   * Set the element data for the element. 
+   * \note You can only set element data for non-ghost elements.
+   * \param [in] element_data The element data to be set.
+   */
+  template <typename E = typename mesh_class::ElementDataType, typename = std::enable_if_t<!std::is_void<E>::value>>
+  void
+  set_element_data (E element_data)
+  {
+    SC_CHECK_ABORT (!m_is_ghost_element, "Element data cannot be set for ghost elements.\n");
+    // Resize for the case that no data vector has been set previously.
+    m_mesh->m_element_data.resize (m_mesh->get_num_local_elements () + m_mesh->get_num_ghosts ());
+    m_mesh->m_element_data[get_element_handle_id ()] = element_data;
+  }
+
  private:
   //--- Private getter for internal use. ---
   /**
@@ -412,7 +462,7 @@ class element: public TCompetence<element<TCompetence...>>... {
     return t8_forest_get_tree_class (m_mesh->m_forest, m_tree_id);
   }
 
-  const mesh_class* m_mesh;       /**< Pointer to the mesh the element is defined for. */
+  mesh_class* m_mesh;             /**< Pointer to the mesh the element is defined for. */
   const t8_locidx_t m_tree_id;    /**< The tree id of the element in the forest defined in the mesh. */
   const t8_locidx_t m_element_id; /**< The element id of the element in the forest defined in the mesh. */
   const bool m_is_ghost_element;  /**< Flag to indicate if the element is a ghost element. */
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 152e2e2bd8..2dd8f52ed5 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -30,8 +30,10 @@
 #include <t8.h>
 #include <t8_forest/t8_forest_general.h>
 #include "element.hxx"
+#include "competence_pack.hxx"
 #include <t8_forest/t8_forest_ghost.h>
 #include <vector>
+#include <type_traits>
 
 namespace t8_mesh_handle
 {
@@ -40,21 +42,33 @@ namespace t8_mesh_handle
  * Wrapper for a forest that enables it to be handled as a simple mesh object.
  * \tparam TCompetence The competences you want to add to the default functionality of the mesh.
  *         \see element for more details on the choice of the template parameter.   
+ *         \note Please pack your competences using the \ref competence_pack class.
+ * \tparam TUserData The user data type you want to associate with the mesh. Use void (this is also the default) if you do not want to set user data.
+ * \tparam TElementData The element data type you want to use for each element of the mesh. 
+ *         Use void (this is also the default) if you do not want to set element data.
  */
-template <template <typename> class... TCompetence>
+template <typename TCompetencePack = competence_pack<>, typename TUserData = void, typename TElementData = void>
 class mesh {
  public:
-  using element_class = element<TCompetence...>; /**< The element class of the mesh with given competences. */
+  using SelfType = mesh<TCompetencePack, TUserData,
+                        TElementData>;  /**< Type of the current class with all template parameters specified. */
+  using UserDataType = TUserData;       /**< Make Type of the user data accessible. */
+  using ElementDataType = TElementData; /**< Make Type of the element data accessible. */
+  using element_class
+    = TCompetencePack::template apply<SelfType, element>; /**< The element class of the mesh with given competences. */
   friend element_class; /**< Element class as friend such that private members (e.g. the forest) can be accessed. */
   using mesh_const_iterator =
     typename std::vector<element_class>::const_iterator; /**< Constant iterator type for the mesh elements. */
+  using mesh_iterator =
+    typename std::vector<element_class>::iterator; /**< Non-const iterator type for the mesh elements. */
 
   /** 
    * Constructor for a mesh of the handle. 
-   * \param [in] input_forest The forest from which the mesh should be created. 
+   * \param [in] forest The forest from which the mesh should be created. 
    */
-  mesh (t8_forest_t input_forest): m_forest (input_forest)
+  mesh (t8_forest_t forest): m_forest (forest)
   {
+    T8_ASSERT ((std::is_same<typename TCompetencePack::is_competence_pack, void>::value));
     T8_ASSERT (t8_forest_is_committed (m_forest));
     update_elements ();
   }
@@ -94,7 +108,7 @@ class mesh {
    * \return Constant iterator to the first (local) mesh element.
    */
   mesh_const_iterator
-  begin () const
+  cbegin () const
   {
     return m_elements.cbegin ();
   }
@@ -104,18 +118,38 @@ class mesh {
    * \return Constant iterator to the mesh element following the last (local) element of the mesh.
    */
   mesh_const_iterator
-  end () const
+  cend () const
   {
     return m_elements.cend ();
   }
 
+  /**
+   * Non-const version of \ref cbegin.
+   * \return Iterator to the first (local) mesh element.
+   */
+  mesh_iterator
+  begin ()
+  {
+    return m_elements.begin ();
+  }
+
+  /**
+   * Non-const version of \ref end.
+   * \return Iterator to the mesh element following the last (local) element of the mesh.
+   */
+  mesh_iterator
+  end ()
+  {
+    return m_elements.end ();
+  }
+
   /**
    * Getter for an element given its local index. This could be a (local) mesh element or 
    *  a ghost element. 
    * The indices 0, 1, ... num_local_el - 1 refer to local mesh elements and 
    *    num_local_el , ... , num_local_el + num_ghosts - 1 refer to ghost elements.
    * \param [in] local_index The local index of the element to access.
-   * \return Reference to the element.
+   * \return Constant reference to the element.
    */
   const element_class&
   operator[] (t8_locidx_t local_index) const
@@ -129,6 +163,17 @@ class mesh {
     }
   }
 
+  /**
+   * Non const version of operator above.
+   * \param [in] local_index The local index of the element to access.
+   * \return Reference to the element.
+   */
+  element_class&
+  operator[] (t8_locidx_t local_index)
+  {
+    return const_cast<element_class&> (static_cast<const mesh*> (this)->operator[] (local_index));
+  }
+
   /**
    * Getter for the forest the mesh is defined for.
    * \return The forest the mesh is defined for.
@@ -140,15 +185,92 @@ class mesh {
   }
 
   /** 
-  * Setter for the forest. 
-  * \param [in] input_forest The forest from which the mesh should be a wrapper. 
-  */
+   * Setter for the forest. 
+   * \param [in] input_forest The forest from which the mesh should be a wrapper. 
+   */
   void
   set_forest (t8_forest_t input_forest)
   {
     T8_ASSERT (t8_forest_is_committed (input_forest));
     m_forest = input_forest;
     update_elements ();
+    if constexpr (!std::is_void<TElementData>::value) {
+      t8_global_infof (
+        "The elements of the mesh handle have been updated. Please note that the element data is not interpolated "
+        "automatically. Use the function set_element_data() to provide new adapted element data.\n");
+    }
+  }
+
+  /** 
+   * Set the user data of the mesh. This can i.e. be used to pass user defined arguments to the adapt routine.
+   * \param [in] data The user data of class TUserData. Data will never be touched by mesh handling routines.
+   */
+  template <typename U = TUserData, typename = std::enable_if_t<!std::is_void<U>::value>>
+  void
+  set_user_data (const U& data)
+  {
+    t8_forest_set_user_data (m_forest, data);
+  }
+
+  /** 
+   * Get the user data of the mesh. 
+   * \return The user data previously set using \ref set_user_data.   
+   */
+  template <typename U = TUserData, typename = std::enable_if_t<!std::is_void<U>::value>>
+  const U&
+  get_user_data () const
+  {
+    return *static_cast<const U*> (t8_forest_get_user_data (m_forest));
+  }
+
+  /** 
+   * Set the element data vector. The vector should have the length of num_local_elements.
+   * \param [in] element_data The element data vector to set with one entry of class TElementData 
+   *            for each local mesh element (excluding ghosts).
+   */
+  template <typename E = TElementData, typename = std::enable_if_t<!std::is_void<E>::value>>
+  void
+  set_element_data (const std::vector<E>& element_data)
+  {
+    T8_ASSERT (element_data.size () == get_num_local_elements ());
+    m_element_data.clear ();
+    m_element_data.resize (get_num_local_elements () + get_num_ghosts ());
+    std::copy (element_data.begin (), element_data.end (), m_element_data.begin ());
+  }
+
+  /** 
+   * Get the element data vector.
+   * The element data of the local mesh elements can be set using \ref set_element_data.
+   * If ghost entries should be filled, one should call \ref exchange_ghost_data on each process first.
+   * \return Element data vector with data of Type TElementData.
+   */
+  template <typename E = TElementData, typename = std::enable_if_t<!std::is_void<E>::value>>
+  const std::vector<E>&
+  get_element_data () const
+  {
+    return m_element_data;
+  }
+
+  /** 
+  * Exchange the element data for ghost elements between processes.
+  * This routine has to be called on each process after setting the element data for all local elements.
+  * \return The element data vector of size num_local_elements + num_local_ghosts with data of Type TElementData.
+  */
+  template <typename E = TElementData, typename = std::enable_if_t<!std::is_void<E>::value>>
+  const std::vector<E>&
+  exchange_ghost_data ()
+  {
+    // t8_forest_ghost_exchange_data expects an sc_array, so we need to wrap our data array to one.
+    sc_array* sc_array_wrapper;
+    T8_ASSERT (m_element_data.size () == get_num_local_elements () + get_num_ghosts ());
+    sc_array_wrapper = sc_array_new_data (m_element_data.data (), sizeof (TElementData),
+                                          get_num_local_elements () + get_num_ghosts ());
+
+    // Data exchange: entries with indices > num_local_elements will get overwritten.
+    t8_forest_ghost_exchange_data (m_forest, sc_array_wrapper);
+
+    sc_array_destroy (sc_array_wrapper);
+    return m_element_data;
   }
 
  private:
@@ -158,7 +280,6 @@ class mesh {
   void
   update_elements ()
   {
-    // Clear the element vector if already created.
     m_elements.clear ();
     m_elements.reserve (get_num_local_elements ());
     // Iterate through forest elements and fill the element vector with newly created mesh elements.
@@ -177,7 +298,6 @@ class mesh {
   void
   update_ghost_elements ()
   {
-    // Clear the ghost vector if already created.
     m_ghosts.clear ();
     m_ghosts.reserve (get_num_ghosts ());
     t8_locidx_t num_loc_trees = t8_forest_get_num_local_trees (m_forest);
@@ -193,6 +313,8 @@ class mesh {
   t8_forest_t m_forest;                  /**< The forest the mesh should be defined for. */
   std::vector<element_class> m_elements; /**< Vector storing the (local) mesh elements. */
   std::vector<element_class> m_ghosts;   /**< Vector storing the (local) ghost elements. */
+  std::conditional_t<!std::is_void_v<TElementData>, std::vector<TElementData>, std::nullptr_t>
+    m_element_data; /**< Vector storing the (local) element data. */
 };
 
 }  // namespace t8_mesh_handle
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index f292445e87..3a7ad0f181 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -216,6 +216,7 @@ if( T8CODE_BUILD_MESH_HANDLE )
   add_t8_cpp_test( NAME t8_gtest_handle_ghost_parallel            SOURCES mesh_handle/t8_gtest_ghost.cxx )
   add_t8_cpp_test( NAME t8_gtest_custom_competence_serial         SOURCES mesh_handle/t8_gtest_custom_competence.cxx )
   add_t8_cpp_test( NAME t8_gtest_cache_competence_serial          SOURCES mesh_handle/t8_gtest_cache_competence.cxx )
+  add_t8_cpp_test( NAME t8_gtest_handle_data_parallel             SOURCES mesh_handle/t8_gtest_handle_data.cxx )
 endif()
 
 copy_test_file( test_cube_unstructured_1.inp )
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index e5f315b2f3..15ae2e2038 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -30,6 +30,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -37,6 +38,21 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_types/t8_vec.hxx>
 #include <vector>
 
+/** Child class of \ref t8_mesh_handle::cache_volume that allows to modify the cache variable for test purposes. */
+template <typename TUnderlying>
+struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
+{
+ public:
+  /** Overwrites the cache variable for the volume.
+   * \param [in] new_volume New volume. 
+   */
+  void
+  overwrite_cache (double new_volume) const
+  {
+    this->m_volume = new_volume;
+  }
+};
+
 /** Child class of \ref t8_mesh_handle::cache_vertex_coordinates that allows to modify the cache variable for test purposes. */
 template <typename TUnderlying>
 struct cache_vertex_coordinates_overwrite: public t8_mesh_handle::cache_vertex_coordinates<TUnderlying>
@@ -89,20 +105,45 @@ class t8_gtest_cache_competence: public testing::Test {
   int level;
 };
 
+/** Use child class of \ref t8_mesh_handle::cache_volume class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST_F (t8_gtest_cache_competence, cache_volume)
+{
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_volume_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  const mesh_class mesh = mesh_class (forest);
+  EXPECT_TRUE (element_class::has_volume_cache ());
+
+  double unrealistic_volume = -3000;
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+    // Check that cache is empty at the beginning.
+    EXPECT_FALSE (it->volume_cache_filled ());
+    // Fill cache and check that volume is valid.
+    EXPECT_GE (it->get_volume (), 0);
+    // Check that cache is set.
+    EXPECT_TRUE (it->volume_cache_filled ());
+    // Overwrite the cache with unrealistic values.
+    it->overwrite_cache (unrealistic_volume);
+    // Check that the cache is actually used.
+    EXPECT_EQ (it->get_volume (), unrealistic_volume);
+  }
+}
+
 /** Use child class of \ref t8_mesh_handle::cache_vertex_coordinates class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
 TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
-  using mesh_class = t8_mesh_handle::mesh<cache_vertex_coordinates_overwrite>;
-  using element_class = mesh_class::element_class;
-  mesh_class mesh = mesh_class (forest);
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  const mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_vertex_cache ());
-  EXPECT_FALSE (element_class::has_centroid_cache ());
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->vertex_cache_filled ());
     // Check that values are valid.
@@ -128,14 +169,13 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
  */
 TEST_F (t8_gtest_cache_competence, cache_centroid)
 {
-  using mesh_class = t8_mesh_handle::mesh<cache_centroid_overwrite>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
   using element_class = mesh_class::element_class;
-  mesh_class mesh = mesh_class (forest);
-  EXPECT_FALSE (element_class::has_vertex_cache ());
+  const mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->centroid_cache_filled ());
     // Check that values are valid.
diff --git a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
index bd0e69f5a8..9a962fcc23 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -32,6 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
+#include <t8_forest/t8_forest_geometrical.h>
 #include <t8_schemes/t8_default/t8_default.hxx>
 
 /** Tests that the functionality of the handle gives the same results as if worked with the forest directly.
@@ -45,12 +46,12 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
   const t8_scheme *init_scheme = t8_scheme_new_default ();
   t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
 
-  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
 
   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results of different functions.
   const t8_scheme *scheme = t8_forest_get_scheme (forest);
   // Use iterator for the mesh handle and two nested for-loops for the forest.
-  auto mesh_iterator = mesh.begin ();
+  auto mesh_iterator = mesh.cbegin ();
   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
     const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
     for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
@@ -61,6 +62,7 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
       // --- Compare basics. ---
       EXPECT_EQ (mesh_iterator->get_level (), scheme->element_get_level (tree_class, elem));
       EXPECT_EQ (mesh_iterator->get_shape (), scheme->element_get_shape (tree_class, elem));
+      EXPECT_EQ (mesh_iterator->get_volume (), t8_forest_element_volume (forest, itree, elem));
       // --- Compare centroid. ---
       t8_3D_point centroid;
       t8_forest_element_centroid (forest, itree, elem, centroid.data ());
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 491556f2e1..bb73005e2a 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -30,6 +30,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -89,18 +90,20 @@ TEST (t8_gtest_custom_competence, custom_competence)
   t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
 
   // Check mesh with custom defined competence.
-  t8_mesh_handle::mesh<dummy_get_level> mesh = t8_mesh_handle::mesh<dummy_get_level> (forest);
+  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
+  const mesh_class_custom mesh = mesh_class_custom (forest);
 
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (level, it->get_level_dummy ());
   }
 
   // Test with two custom competences and a predefined competence.
-  using mesh_class = t8_mesh_handle::mesh<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using competences = t8_mesh_handle::competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using mesh_class = t8_mesh_handle::mesh<competences>;
   mesh_class mesh_more_competences = mesh_class (forest);
 
-  for (auto it = mesh_more_competences.begin (); it != mesh_more_competences.end (); ++it) {
+  for (auto it = mesh_more_competences.cbegin (); it != mesh_more_competences.cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (it->get_value_dummy (), 1);
     EXPECT_FALSE (it->centroid_cache_filled ());
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 8176e842cc..561e3b77a1 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -65,7 +66,7 @@ TEST_P (t8_mesh_ghost_test, check_ghosts)
 {
   t8_forest_ghost_print (forest);
 
-  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
   EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
   if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
     // Ensure that we actually have ghost elements in this test.
@@ -101,12 +102,12 @@ TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
 {
   ASSERT_TRUE (t8_forest_is_committed (forest));
 
-  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
   EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
 
   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
   const t8_scheme* scheme = t8_forest_get_scheme (forest);
-  auto mesh_iterator = mesh.begin ();
+  auto mesh_iterator = mesh.cbegin ();
   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
     const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
     for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
@@ -178,9 +179,9 @@ struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderl
  */
 TEST_P (t8_mesh_ghost_test, cache_neighbors)
 {
-  using mesh_class = t8_mesh_handle::mesh<cache_neighbors_overwrite>;
-  using element_class = mesh_class::element_class;
-  mesh_class mesh = mesh_class (forest);
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  const mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
   if (mesh.get_num_local_elements () == 0) {
@@ -189,7 +190,7 @@ TEST_P (t8_mesh_ghost_test, cache_neighbors)
   const std::vector<const element_class*> unrealistic_neighbors
     = { &mesh[0], &mesh[mesh.get_num_local_elements () - 1] };
   const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->neighbor_cache_filled_any ());
     it->fill_face_neighbor_cache ();
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
new file mode 100644
index 0000000000..17929ccce9
--- /dev/null
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -0,0 +1,152 @@
+/*
+This file is part of t8code.
+t8code is a C library to manage a collection (a forest) of multiple
+connected adaptive space-trees of general element classes in parallel.
+
+Copyright (C) 2025 the developers
+
+t8code is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+t8code is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with t8code; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/**
+ * \file t8_gtest_handle_data.cxx
+ * Tests to check that \ref t8_mesh_handle::mesh user data and element data functionality works as intended.
+ */
+
+#include <gtest/gtest.h>
+#include <t8.h>
+
+#include <mesh_handle/mesh.hxx>
+#include <mesh_handle/competence_pack.hxx>
+#include <t8_cmesh/t8_cmesh.h>
+#include <t8_cmesh/t8_cmesh_examples.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_schemes/t8_default/t8_default.hxx>
+#include <t8_types/t8_vec.hxx>
+#include <vector>
+
+// --- Test for user data. ---
+// Dummy user data taken from a tutorial for test purposes.
+struct dummy_user_data
+{
+  t8_3D_point midpoint;             /* The midpoint of our sphere. */
+  double refine_if_inside_radius;   /* if an element's center is smaller than this value, we refine the element. */
+  double coarsen_if_outside_radius; /* if an element's center is larger this value, we coarsen its family. */
+};
+
+/** Check that user data can be set and accesses for the handle.
+ */
+TEST (t8_gtest_handle_data, set_and_get_user_data)
+{
+  // Define forest and mesh handle.
+  const int level = 2;
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
+  const t8_scheme *init_scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
+
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
+  mesh_class mesh = mesh_class (forest);
+
+  struct dummy_user_data user_data = {
+    t8_3D_point ({ 41, 42, 43 }), /* Midpoints of the sphere. */
+    0.2,                          /* Refine if inside this radius. */
+    0.4                           /* Coarsen if outside this radius. */
+  };
+
+  // Set user data for the mesh handle and check that the getter returns the same data.
+  mesh.set_user_data (&user_data);
+  auto mesh_user_data = mesh.get_user_data ();
+  EXPECT_EQ (mesh_user_data.midpoint, user_data.midpoint);
+  EXPECT_EQ (mesh_user_data.refine_if_inside_radius, user_data.refine_if_inside_radius);
+  EXPECT_EQ (mesh_user_data.coarsen_if_outside_radius, user_data.coarsen_if_outside_radius);
+
+  // Unref the forest.
+  t8_forest_unref (&forest);
+}
+
+// --- Test for element data. ---
+/** Dummy element data taken from a tutorial for test purposes. */
+struct data_per_element
+{
+  int level;
+  double volume;
+};
+
+/** Check that element data can be set for the handle and 
+ * that the getter has exchanged data for the ghosts.
+ */
+TEST (t8_gtest_handle_data, set_and_get_element_data)
+{
+  // Define forest and mesh handle.
+  const int level = 2;
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
+  const t8_scheme *init_scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 1, sc_MPI_COMM_WORLD);
+
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, void, data_per_element>;
+  mesh_class mesh = mesh_class (forest);
+  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+    // Ensure that we actually test with ghost elements.
+    EXPECT_GT (mesh.get_num_ghosts (), 0);
+  }
+  // Create element data for all local mesh elements.
+  std::vector<data_per_element> element_data;
+  for (const auto &elem : mesh) {
+    element_data.push_back ({ elem.get_level (), elem.get_volume () });
+  }
+  mesh.set_element_data (element_data);
+  // Get element data and check that the data for all elements (including ghosts) is correct.
+  auto mesh_element_data = mesh.exchange_ghost_data ();
+  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements () + mesh.get_num_ghosts (); ielem++) {
+    EXPECT_EQ (mesh_element_data[ielem].level, level) << "ielem = " << ielem;
+    EXPECT_EQ (mesh_element_data[ielem].volume, mesh[ielem].get_volume ()) << "ielem = " << ielem;
+  }
+  t8_gloidx_t barrier = t8_forest_get_num_global_trees (forest) / 2.0;
+  const int newlevel = 42;
+  const double newvolume = 42.42;
+  for (auto &elem : mesh) {
+    if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
+      elem.set_element_data ({ newlevel, newvolume });
+    }
+  }
+  mesh.exchange_ghost_data ();
+  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements (); ielem++) {
+    if (t8_forest_global_tree_id (forest, mesh[ielem].get_local_tree_id ()) < barrier) {
+      EXPECT_EQ (mesh[ielem].get_element_data ().level, newlevel) << "ielem = " << ielem;
+      EXPECT_EQ (mesh[ielem].get_element_data ().volume, newvolume) << "ielem = " << ielem;
+    }
+    else {
+      EXPECT_EQ (mesh[ielem].get_element_data ().level, level) << "ielem = " << ielem;
+      EXPECT_EQ (mesh[ielem].get_element_data ().volume, mesh[ielem].get_volume ()) << "ielem = " << ielem;
+    }
+  }
+
+  for (t8_locidx_t ighost = mesh.get_num_local_elements ();
+       ighost < mesh.get_num_local_elements () + mesh.get_num_ghosts (); ighost++) {
+    if (t8_forest_ghost_get_global_treeid (forest,
+                                           mesh[ighost].get_local_tree_id () - t8_forest_get_num_local_trees (forest))
+        < barrier) {
+      EXPECT_EQ (mesh[ighost].get_element_data ().level, newlevel);
+      EXPECT_EQ (mesh[ighost].get_element_data ().volume, newvolume);
+    }
+    else {
+      EXPECT_EQ (mesh[ighost].get_element_data ().level, level);
+      EXPECT_EQ (mesh[ighost].get_element_data ().volume, mesh[ighost].get_volume ());
+    }
+  }
+
+  // Unref the forest.
+  t8_forest_unref (&forest);
+}
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index ad1ff606fe..542dcc684a 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
+#include <mesh_handle/competence_pack.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -63,13 +64,13 @@ TEST_P (t8_mesh_handle_test, test_iterator)
 {
   // --- Check default functionality. ---
   using mesh_class = t8_mesh_handle::mesh<>;
-  using element_class = mesh_class::element_class;
-  mesh_class mesh = mesh_class (forest);
+  using element_class = typename mesh_class::element_class;
+  const mesh_class mesh = mesh_class (forest);
   EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements and check some functionality.
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
     EXPECT_FALSE (it->has_vertex_cache ());
     EXPECT_FALSE (it->has_centroid_cache ());
     auto centroid = it->get_centroid ();
@@ -97,14 +98,15 @@ TEST_P (t8_mesh_handle_test, test_iterator)
 TEST_P (t8_mesh_handle_test, test_competences)
 {
   // --- Version with cached vertex coordinates. ---
-  using mesh_class_vertex = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates>;
-  using element_class_vertex = mesh_class_vertex::element_class;
-  mesh_class_vertex mesh_vertex = mesh_class_vertex (forest);
+  using competence_vertex_coordinates = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_vertex_coordinates>;
+  using mesh_class_vertex = t8_mesh_handle::mesh<competence_vertex_coordinates>;
+  using element_class_vertex = typename mesh_class_vertex::element_class;
+  const mesh_class_vertex mesh_vertex = mesh_class_vertex (forest);
   EXPECT_TRUE (element_class_vertex::has_vertex_cache ());
   EXPECT_FALSE (element_class_vertex::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements and check functionality.
-  for (auto it = mesh_vertex.begin (); it != mesh_vertex.end (); ++it) {
+  for (auto it = mesh_vertex.cbegin (); it != mesh_vertex.cend (); ++it) {
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
     auto centroid = it->get_centroid ();
@@ -121,7 +123,7 @@ TEST_P (t8_mesh_handle_test, test_competences)
     }
   }
   // Check cached value.
-  for (auto it = mesh_vertex.begin (); it != mesh_vertex.end (); ++it) {
+  for (auto it = mesh_vertex.cbegin (); it != mesh_vertex.cend (); ++it) {
     EXPECT_TRUE (it->vertex_cache_filled ());
     auto vertex_coordinates = it->get_vertex_coordinates ();
     for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
@@ -133,14 +135,15 @@ TEST_P (t8_mesh_handle_test, test_competences)
   }
 
   // --- Version with cached centroid variable. ---
-  using mesh_class_centroid = t8_mesh_handle::mesh<t8_mesh_handle::cache_centroid>;
-  using element_class_centroid = mesh_class_centroid::element_class;
-  mesh_class_centroid mesh_centroid = mesh_class_centroid (forest);
+  using competence_centroid = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_centroid>;
+  using mesh_class_centroid = t8_mesh_handle::mesh<competence_centroid>;
+  using element_class_centroid = typename mesh_class_centroid::element_class;
+  const mesh_class_centroid mesh_centroid = mesh_class_centroid (forest);
   EXPECT_FALSE (element_class_centroid::has_vertex_cache ());
   EXPECT_TRUE (element_class_centroid::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements.
-  for (auto it = mesh_centroid.begin (); it != mesh_centroid.end (); ++it) {
+  for (auto it = mesh_centroid.cbegin (); it != mesh_centroid.cend (); ++it) {
     EXPECT_FALSE (it->centroid_cache_filled ());
     auto centroid = it->get_centroid ();
     for (const auto& coordinate : centroid) {
@@ -160,17 +163,20 @@ TEST_P (t8_mesh_handle_test, test_competences)
 TEST_P (t8_mesh_handle_test, test_2_competences)
 {
   // --- Use competences to cache level and centroid. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_vertex_coordinates, t8_mesh_handle::cache_centroid>;
-  using element_class = mesh_class::element_class;
-  mesh_class mesh = mesh_class (forest);
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_competences>;
+  using element_class = typename mesh_class::element_class;
+  const mesh_class mesh = mesh_class (forest);
+  EXPECT_TRUE (element_class::has_volume_cache ());
   EXPECT_TRUE (element_class::has_vertex_cache ());
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements.
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+    EXPECT_FALSE (it->volume_cache_filled ());
     EXPECT_FALSE (it->centroid_cache_filled ());
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
+    EXPECT_GE (it->get_volume (), 0);
     auto centroid = it->get_centroid ();
     for (const auto& coordinate : centroid) {
       EXPECT_GE (1, coordinate);
@@ -185,10 +191,12 @@ TEST_P (t8_mesh_handle_test, test_2_competences)
     }
   }
   // Test dereference operator. (Here the cached values should be used.)
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+    EXPECT_TRUE (it->volume_cache_filled ());
     EXPECT_TRUE (it->centroid_cache_filled ());
     EXPECT_TRUE (it->vertex_cache_filled ());
     EXPECT_EQ (level, (*it).get_level ());
+    EXPECT_GE (it->get_volume (), 0);
     auto centroid = (*it).get_centroid ();
     for (const auto& coordinate : centroid) {
       EXPECT_GE (1, coordinate);