From e5051fd089349723cd876eb17a8bd4a1d094cfa2 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Mon, 10 Nov 2025 11:11:36 +0100
Subject: [PATCH 01/11] pack competences into one class

---
 api/t8_mesh_handle/abstract_element.hxx       | 15 +++---
 api/t8_mesh_handle/competence_pack.hxx        | 51 +++++++++++++++++++
 api/t8_mesh_handle/ghost_element.hxx          |  8 +--
 api/t8_mesh_handle/mesh.hxx                   | 15 ++++--
 api/t8_mesh_handle/mesh_element.hxx           |  8 +--
 .../t8_gtest_cache_competence.cxx             |  7 +--
 .../t8_gtest_custom_competence.cxx            |  7 ++-
 test/api/t8_mesh_handle/t8_gtest_ghost.cxx    |  5 +-
 .../t8_mesh_handle/t8_gtest_mesh_handle.cxx   | 17 ++++---
 9 files changed, 94 insertions(+), 39 deletions(-)
 create mode 100644 api/t8_mesh_handle/competence_pack.hxx

diff --git a/api/t8_mesh_handle/abstract_element.hxx b/api/t8_mesh_handle/abstract_element.hxx
index d022bfee69..4ce21384b9 100644
--- a/api/t8_mesh_handle/abstract_element.hxx
+++ b/api/t8_mesh_handle/abstract_element.hxx
@@ -28,6 +28,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #define T8_ABSTRACT_ELEMENT_HXX
 
 #include <t8.h>
+#include <t8_mesh_handle/competence_pack.hxx>
 #include <t8_element.h>
 #include <t8_eclass.h>
 #include <t8_forest/t8_forest_general.h>
@@ -42,7 +43,7 @@ namespace t8_mesh_handle
 {
 /* Forward declaration of the mesh class of the handle.
  */
-template <template <typename> class... TCompetence>
+template <typename Competences>
 class mesh;
 
 /** 
@@ -67,7 +68,7 @@ template <template <typename> class... TCompetence>
 class abstract_element: public TCompetence<abstract_element<TCompetence...>>... {
  protected:
   using SelfType = abstract_element<TCompetence...>;
-  using mesh_class = mesh<TCompetence...>;
+  using mesh_class = mesh<competence_pack<TCompetence...>>;
   friend mesh_class;
 
   /**
@@ -77,7 +78,7 @@ class abstract_element: public TCompetence<abstract_element<TCompetence...>>...
    * \param [in] tree_id        The tree id of the element in the forest defining the mesh.
    * \param [in] element_id     The element id of the element in the forest defining the mesh.
    */
-  abstract_element (mesh<TCompetence...>* mesh, t8_locidx_t tree_id, t8_locidx_t element_id)
+  abstract_element (mesh_class* mesh, t8_locidx_t tree_id, t8_locidx_t element_id)
     : m_mesh (mesh), m_tree_id (tree_id), m_element_id (element_id)
   {
   }
@@ -248,7 +249,7 @@ class abstract_element: public TCompetence<abstract_element<TCompetence...>>...
    * Getter for the mesh to which the element is belonging.
    * \return Reference to the mesh.
    */
-  const mesh<TCompetence...>*
+  const mesh_class*
   get_mesh () const
   {
     return m_mesh;
@@ -273,9 +274,9 @@ class abstract_element: public TCompetence<abstract_element<TCompetence...>>...
   get_element () const
     = 0;
 
-  mesh<TCompetence...>* m_mesh; /**< Pointer to the mesh the element is defined for. */
-  t8_locidx_t m_tree_id;        /**< The tree id of the element in the forest defined in the mesh. */
-  t8_locidx_t m_element_id;     /**< The element id of the element in the forest defined in the mesh. */
+  mesh_class* m_mesh;       /**< Pointer to the mesh the element is defined for. */
+  t8_locidx_t m_tree_id;    /**< The tree id of the element in the forest defined in the mesh. */
+  t8_locidx_t m_element_id; /**< The element id of the element in the forest defined in the mesh. */
 };
 
 }  // namespace t8_mesh_handle
diff --git a/api/t8_mesh_handle/competence_pack.hxx b/api/t8_mesh_handle/competence_pack.hxx
new file mode 100644
index 0000000000..ef1d52f938
--- /dev/null
+++ b/api/t8_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 abstract_element class.
+   * \tparam Target The target template class to apply the \ref TCompetence pack to.
+   */
+  template <template <template <typename> class...> class Target>
+  using apply = Target<TCompetence...>;
+
+  using is_competence_pack = void;  // Tag to identify this class.
+};
+
+// Predefined competence pack combining all caching competences.
+using cache_competences = competence_pack<cache_vertex_coordinates, cache_centroid, cache_neighbors>;
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_COMPETENCE_PACK_HXX */
diff --git a/api/t8_mesh_handle/ghost_element.hxx b/api/t8_mesh_handle/ghost_element.hxx
index d36e03011a..390b121f81 100644
--- a/api/t8_mesh_handle/ghost_element.hxx
+++ b/api/t8_mesh_handle/ghost_element.hxx
@@ -34,10 +34,6 @@
 
 namespace t8_mesh_handle
 {
-/* Forward declaration of the mesh class of the handle.
- */
-template <template <typename> class... TCompetence>
-class mesh;
 
 /** 
  * Class for the ghost elements of the mesh handle. 
@@ -49,7 +45,7 @@ class mesh;
 template <template <typename> class... TCompetence>
 class ghost_element: public abstract_element<TCompetence...> {
   using Base = abstract_element<TCompetence...>;
-  using mesh_class = mesh<TCompetence...>;
+  using mesh_class = Base::mesh_class;
   friend mesh_class;
 
   /**
@@ -60,7 +56,7 @@ class ghost_element: public abstract_element<TCompetence...> {
    * \param [in] lghost_tree_id   The ghost tree id of the element in the forest defining the mesh.
    * \param [in] element_id       The element id of the element in the forest defining the mesh.
    */
-  ghost_element (mesh<TCompetence...>* mesh, t8_locidx_t tree_id, t8_locidx_t lghost_tree_id, t8_locidx_t element_id)
+  ghost_element (mesh_class* mesh, t8_locidx_t tree_id, t8_locidx_t lghost_tree_id, t8_locidx_t element_id)
     : Base (mesh, tree_id, element_id), m_lghost_tree_id (lghost_tree_id)
   {
   }
diff --git a/api/t8_mesh_handle/mesh.hxx b/api/t8_mesh_handle/mesh.hxx
index 308c36532e..6abdbec75d 100644
--- a/api/t8_mesh_handle/mesh.hxx
+++ b/api/t8_mesh_handle/mesh.hxx
@@ -32,25 +32,29 @@
 #include <t8_mesh_handle/abstract_element.hxx>
 #include <t8_mesh_handle/mesh_element.hxx>
 #include <t8_mesh_handle/ghost_element.hxx>
+#include <t8_mesh_handle/competence_pack.hxx>
 #include <t8_forest/t8_forest_ghost.h>
 #include <iterator>
 #include <memory>
 #include <vector>
+#include <type_traits>
 
 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.
+ * \tparam TCompetencePack The competences you want to add to the default functionality of the mesh.
  *         \see abstract_element for more details on the choice of the template parameter.   
+ *         \note Please pack your competences using the \ref competence_pack class.
  */
-template <template <typename> class... TCompetence>
+template <typename TCompetencePack = competence_pack<>>
 class mesh {
+
  public:
-  using abstract_element_class = abstract_element<TCompetence...>;
-  using mesh_element_class = mesh_element<TCompetence...>;
-  using ghost_element_class = ghost_element<TCompetence...>;
+  using abstract_element_class = TCompetencePack::template apply<abstract_element>;
+  using mesh_element_class = TCompetencePack::template apply<mesh_element>;
+  using ghost_element_class = TCompetencePack::template apply<ghost_element>;
   // Declare all element classes as friend such that private members (e.g. the forest) can be accessed.
   friend abstract_element_class;
   friend mesh_element_class;
@@ -65,6 +69,7 @@ class mesh {
    */
   mesh (t8_forest_t input_forest): m_forest (input_forest)
   {
+    T8_ASSERT ((std::is_same<typename TCompetencePack::is_competence_pack, void>::value));
     update_elements ();
   }
 
diff --git a/api/t8_mesh_handle/mesh_element.hxx b/api/t8_mesh_handle/mesh_element.hxx
index dadcd65caf..297031ea7e 100644
--- a/api/t8_mesh_handle/mesh_element.hxx
+++ b/api/t8_mesh_handle/mesh_element.hxx
@@ -41,11 +41,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 namespace t8_mesh_handle
 {
-/* Forward declaration of the mesh class of the handle.
- */
-template <template <typename> class... TCompetence>
-class mesh;
-
 /** 
  * Class for the mesh elements of the mesh handle. 
  * This class is a child class of the abstract element class and implements the functionality specific to mesh elements 
@@ -82,8 +77,7 @@ class mesh_element: public abstract_element<TCompetence...> {
    * \param [in] tree_id        The tree id of the element in the forest defining the mesh.
    * \param [in] element_id     The element id of the element in the forest defining the mesh.
    */
-  mesh_element (mesh<TCompetence...>* mesh, t8_locidx_t tree_id, t8_locidx_t element_id)
-    : Base (mesh, tree_id, element_id)
+  mesh_element (mesh_class* mesh, t8_locidx_t tree_id, t8_locidx_t element_id): Base (mesh, tree_id, element_id)
   {
     if constexpr (neighbor_cache_exists) {
       // Resize neighbor caches for clean access to the caches.
diff --git a/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx b/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx
index 9f6a754fa6..49d650d58e 100644
--- a/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <t8_mesh_handle/mesh.hxx>
 #include <t8_mesh_handle/competences.hxx>
+#include <t8_mesh_handle/competence_pack.hxx>
 #include <t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -98,8 +99,8 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
   ASSERT_EQ (true, t8_forest_is_committed (forest));
 
-  using mesh_class = t8_mesh_handle::mesh<cache_vertex_coordinates_overwrite>;
-  using element_class = mesh_class::abstract_element_class;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
+  using element_class = typename mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
@@ -133,7 +134,7 @@ TEST_F (t8_gtest_cache_competence, cache_centroid)
 {
   ASSERT_EQ (true, t8_forest_is_committed (forest));
 
-  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::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_FALSE (element_class::has_vertex_cache ());
diff --git a/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx b/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx
index 103cefd94e..2bdaadc1ab 100644
--- a/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx
@@ -31,6 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <t8_mesh_handle/mesh.hxx>
 #include <t8_mesh_handle/competences.hxx>
+#include <t8_mesh_handle/competence_pack.hxx>
 #include <t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -79,7 +80,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
   ASSERT_EQ (true, t8_forest_is_committed (forest));
 
   // 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>>;
+  mesh_class_custom mesh = mesh_class_custom (forest);
 
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
@@ -87,7 +89,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
   }
 
   // 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) {
diff --git a/test/api/t8_mesh_handle/t8_gtest_ghost.cxx b/test/api/t8_mesh_handle/t8_gtest_ghost.cxx
index d6072c4e29..70b1a3cf47 100644
--- a/test/api/t8_mesh_handle/t8_gtest_ghost.cxx
+++ b/test/api/t8_mesh_handle/t8_gtest_ghost.cxx
@@ -32,6 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <t8_mesh_handle/mesh.hxx>
 #include <t8_mesh_handle/competences.hxx>
+#include <t8_mesh_handle/competence_pack.hxx>
 #include <t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -195,8 +196,8 @@ struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderl
 TEST_P (t8_mesh_ghost_test, cache_neighbors)
 {
   ASSERT_TRUE (t8_forest_is_committed (forest));
-  using mesh_class = t8_mesh_handle::mesh<cache_neighbors_overwrite>;
-  using element_class = mesh_class::mesh_element_class;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+  using element_class = typename mesh_class::mesh_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
diff --git a/test/api/t8_mesh_handle/t8_gtest_mesh_handle.cxx b/test/api/t8_mesh_handle/t8_gtest_mesh_handle.cxx
index 3f991293e1..6122bd8f65 100644
--- a/test/api/t8_mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/api/t8_mesh_handle/t8_gtest_mesh_handle.cxx
@@ -32,6 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <t8_mesh_handle/mesh.hxx>
 #include <t8_mesh_handle/competences.hxx>
+#include <t8_mesh_handle/competence_pack.hxx>
 #include <t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -67,7 +68,7 @@ TEST_P (t8_mesh_handle_test, test_iterator)
 
   // --- Check default functionality. ---
   using mesh_class = t8_mesh_handle::mesh<>;
-  using element_class = mesh_class::abstract_element_class;
+  using element_class = typename mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
@@ -107,8 +108,9 @@ TEST_P (t8_mesh_handle_test, test_competences)
   ASSERT_TRUE (t8_forest_is_committed (forest));
 
   // --- 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::abstract_element_class;
+  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::abstract_element_class;
   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 ());
@@ -143,8 +145,9 @@ 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::abstract_element_class;
+  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::abstract_element_class;
   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 ());
@@ -172,8 +175,8 @@ TEST_P (t8_mesh_handle_test, test_2_competences)
   ASSERT_TRUE (t8_forest_is_committed (forest));
 
   // --- 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::abstract_element_class;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_competences>;
+  using element_class = typename mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
   EXPECT_TRUE (element_class::has_vertex_cache ());
   EXPECT_TRUE (element_class::has_centroid_cache ());

From 17015343e23370eec0a7e9be88357cbae1b10585 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Mon, 10 Nov 2025 16:39:21 +0100
Subject: [PATCH 02/11] rm assert committed in the test

---
 test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx         | 4 ----
 test/api/t8_mesh_handle/t8_gtest_compare_handle_to_forest.cxx | 1 -
 test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx        | 1 -
 3 files changed, 6 deletions(-)

diff --git a/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx b/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx
index 49d650d58e..9b2cf5f4e2 100644
--- a/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/api/t8_mesh_handle/t8_gtest_cache_competence.cxx
@@ -97,8 +97,6 @@ class t8_gtest_cache_competence: public testing::Test {
  */
 TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
-  ASSERT_EQ (true, t8_forest_is_committed (forest));
-
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
   using element_class = typename mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
@@ -132,8 +130,6 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
  */
 TEST_F (t8_gtest_cache_competence, cache_centroid)
 {
-  ASSERT_EQ (true, t8_forest_is_committed (forest));
-
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
   using element_class = mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
diff --git a/test/api/t8_mesh_handle/t8_gtest_compare_handle_to_forest.cxx b/test/api/t8_mesh_handle/t8_gtest_compare_handle_to_forest.cxx
index 5521a56023..3584f94f44 100644
--- a/test/api/t8_mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/api/t8_mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -41,7 +41,6 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
   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);
-  ASSERT_EQ (true, t8_forest_is_committed (forest));
 
   t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
 
diff --git a/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx b/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx
index 2bdaadc1ab..9c6a941049 100644
--- a/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/api/t8_mesh_handle/t8_gtest_custom_competence.cxx
@@ -77,7 +77,6 @@ TEST (t8_gtest_custom_competence, custom_competence)
   t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
   const t8_scheme *scheme = t8_scheme_new_default ();
   t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
-  ASSERT_EQ (true, t8_forest_is_committed (forest));
 
   // Check mesh with custom defined competence.
   using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;

From 27fcc4155d4020fb866a7fc9f7863c2a13412d40 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Mon, 10 Nov 2025 16:44:14 +0100
Subject: [PATCH 03/11] Not working: implement user data

---
 api/t8_mesh_handle/abstract_element.hxx | 12 +++--------
 api/t8_mesh_handle/competence_pack.hxx  |  4 ++--
 api/t8_mesh_handle/ghost_element.hxx    |  7 +++----
 api/t8_mesh_handle/mesh.hxx             | 27 +++++++++++++++++++------
 api/t8_mesh_handle/mesh_element.hxx     |  9 ++++-----
 5 files changed, 33 insertions(+), 26 deletions(-)

diff --git a/api/t8_mesh_handle/abstract_element.hxx b/api/t8_mesh_handle/abstract_element.hxx
index 4ce21384b9..e9f452dca1 100644
--- a/api/t8_mesh_handle/abstract_element.hxx
+++ b/api/t8_mesh_handle/abstract_element.hxx
@@ -41,11 +41,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 namespace t8_mesh_handle
 {
-/* Forward declaration of the mesh class of the handle.
- */
-template <typename Competences>
-class mesh;
-
 /** 
  * Common interface of the mesh elements and the ghost elements of the mesh handle.
  * An element without specified template parameters provides default implementations for basic functionality 
@@ -64,11 +59,10 @@ class mesh;
  *
  * \tparam TCompetence The competences you want to add to the default functionality of the element.
  */
-template <template <typename> class... TCompetence>
-class abstract_element: public TCompetence<abstract_element<TCompetence...>>... {
+template <typename mesh_class, template <typename> class... TCompetence>
+class abstract_element: public TCompetence<abstract_element<mesh_class, TCompetence...>>... {
  protected:
-  using SelfType = abstract_element<TCompetence...>;
-  using mesh_class = mesh<competence_pack<TCompetence...>>;
+  using SelfType = abstract_element<mesh_class, TCompetence...>;
   friend mesh_class;
 
   /**
diff --git a/api/t8_mesh_handle/competence_pack.hxx b/api/t8_mesh_handle/competence_pack.hxx
index ef1d52f938..32c15ec6dd 100644
--- a/api/t8_mesh_handle/competence_pack.hxx
+++ b/api/t8_mesh_handle/competence_pack.hxx
@@ -38,8 +38,8 @@ struct competence_pack
   /** Apply the competence pack to a template class, e.g. the \ref abstract_element class.
    * \tparam Target The target template class to apply the \ref TCompetence pack to.
    */
-  template <template <template <typename> class...> class Target>
-  using apply = Target<TCompetence...>;
+  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.
 };
diff --git a/api/t8_mesh_handle/ghost_element.hxx b/api/t8_mesh_handle/ghost_element.hxx
index 390b121f81..db56d67273 100644
--- a/api/t8_mesh_handle/ghost_element.hxx
+++ b/api/t8_mesh_handle/ghost_element.hxx
@@ -42,10 +42,9 @@ namespace t8_mesh_handle
  *
  * \tparam TCompetence The competences you want to add to the default functionality of the element.
  */
-template <template <typename> class... TCompetence>
-class ghost_element: public abstract_element<TCompetence...> {
-  using Base = abstract_element<TCompetence...>;
-  using mesh_class = Base::mesh_class;
+template <typename mesh_class, template <typename> class... TCompetence>
+class ghost_element: public abstract_element<mesh_class, TCompetence...> {
+  using Base = abstract_element<mesh_class, TCompetence...>;
   friend mesh_class;
 
   /**
diff --git a/api/t8_mesh_handle/mesh.hxx b/api/t8_mesh_handle/mesh.hxx
index 6abdbec75d..8cffc33372 100644
--- a/api/t8_mesh_handle/mesh.hxx
+++ b/api/t8_mesh_handle/mesh.hxx
@@ -48,13 +48,14 @@ namespace t8_mesh_handle
  *         \see abstract_element for more details on the choice of the template parameter.   
  *         \note Please pack your competences using the \ref competence_pack class.
  */
-template <typename TCompetencePack = competence_pack<>>
+template <typename TCompetencePack = competence_pack<>, typename TUserData = void>
 class mesh {
 
  public:
-  using abstract_element_class = TCompetencePack::template apply<abstract_element>;
-  using mesh_element_class = TCompetencePack::template apply<mesh_element>;
-  using ghost_element_class = TCompetencePack::template apply<ghost_element>;
+  using SelfType = mesh<TCompetencePack, TUserData>;
+  using abstract_element_class = TCompetencePack::template apply<SelfType, abstract_element>;
+  using mesh_element_class = TCompetencePack::template apply<SelfType, mesh_element>;
+  using ghost_element_class = TCompetencePack::template apply<SelfType, ghost_element>;
   // Declare all element classes as friend such that private members (e.g. the forest) can be accessed.
   friend abstract_element_class;
   friend mesh_element_class;
@@ -65,11 +66,12 @@ class mesh {
 
   /** 
    * 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 ();
   }
 
@@ -206,6 +208,17 @@ class mesh {
     update_elements ();
   }
 
+  /** 
+    * 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. Data will never be touched by mesh handling routines.
+    */
+  void
+  set_user_data (TUserData data)
+    requires (!std::is_void_v<TUserData>)
+  {
+    m_user_data = data;
+  }
+
  private:
   /** 
    * Update the storage of the mesh elements according to the current forest. 
@@ -252,6 +265,8 @@ class mesh {
   t8_forest_t m_forest;                       /**< The forest the mesh should be defined for. */
   std::vector<mesh_element_class> m_elements; /**< Vector storing the (local) mesh elements. */
   std::vector<ghost_element_class> m_ghosts;  /**< Vector storing the (local) ghost elements. */
+  std::conditional_t<!std::is_void_v<TUserData>, TUserData, std::nullptr_t>
+    m_user_data; /**< User data associated with the mesh. */
 };
 
 }  // namespace t8_mesh_handle
diff --git a/api/t8_mesh_handle/mesh_element.hxx b/api/t8_mesh_handle/mesh_element.hxx
index 297031ea7e..353ef69415 100644
--- a/api/t8_mesh_handle/mesh_element.hxx
+++ b/api/t8_mesh_handle/mesh_element.hxx
@@ -48,11 +48,10 @@ namespace t8_mesh_handle
  *
  * \tparam TCompetence The competences you want to add to the default functionality of the element.
  */
-template <template <typename> class... TCompetence>
-class mesh_element: public abstract_element<TCompetence...> {
-  using Base = abstract_element<TCompetence...>;
-  using SelfType = mesh_element<TCompetence...>;
-  using mesh_class = Base::mesh_class;
+template <typename mesh_class, template <typename> class... TCompetence>
+class mesh_element: public abstract_element<mesh_class, TCompetence...> {
+  using Base = abstract_element<mesh_class, TCompetence...>;
+  using SelfType = mesh_element<mesh_class, TCompetence...>;
   friend mesh_class;
 
   // --- Variables to check which functionality is defined in TCompetence. ---

From df0353c32420e589123f46707609c512476c1524 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Tue, 25 Nov 2025 16:35:09 +0100
Subject: [PATCH 04/11] fix error

---
 api/t8_mesh_handle/mesh.hxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/api/t8_mesh_handle/mesh.hxx b/api/t8_mesh_handle/mesh.hxx
index 8cffc33372..d6a6a642ad 100644
--- a/api/t8_mesh_handle/mesh.hxx
+++ b/api/t8_mesh_handle/mesh.hxx
@@ -32,7 +32,7 @@
 #include <t8_mesh_handle/abstract_element.hxx>
 #include <t8_mesh_handle/mesh_element.hxx>
 #include <t8_mesh_handle/ghost_element.hxx>
-#include <t8_mesh_handle/competence_pack.hxx>
+#include "competence_pack.hxx"
 #include <t8_forest/t8_forest_ghost.h>
 #include <iterator>
 #include <memory>
@@ -212,9 +212,9 @@ class mesh {
     * 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. 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 (TUserData data)
-    requires (!std::is_void_v<TUserData>)
+  set_user_data (U data)
   {
     m_user_data = data;
   }

From b3dc96e43c7437b40fc839f86091b0a402c9aa24 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Wed, 26 Nov 2025 16:56:03 +0100
Subject: [PATCH 05/11] added test

---
 mesh_handle/mesh.hxx                    | 16 ++++--
 test/CMakeLists.txt                     |  1 +
 test/mesh_handle/t8_gtest_user_data.cxx | 75 +++++++++++++++++++++++++
 3 files changed, 88 insertions(+), 4 deletions(-)
 create mode 100644 test/mesh_handle/t8_gtest_user_data.cxx

diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 96ea12758c..1ae69841d2 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -196,9 +196,19 @@ class mesh {
     */
   template <typename U = TUserData, typename = std::enable_if_t<!std::is_void<U>::value>>
   void
-  set_user_data (U data)
+  set_user_data (const U& data)
   {
-    m_user_data = data;
+    t8_forest_set_user_data (m_forest, data);
+  }
+
+  /** 
+    * TODO
+    */
+  template <typename U = TUserData, typename = std::enable_if_t<!std::is_void<U>::value>>
+  const U&
+  get_user_data ()
+  {
+    return *static_cast<const U*> (t8_forest_get_user_data (m_forest));
   }
 
  private:
@@ -243,8 +253,6 @@ class mesh {
   t8_forest_t m_forest;                       /**< The forest the mesh should be defined for. */
   std::vector<mesh_element_class> m_elements; /**< Vector storing the (local) mesh elements. */
   std::vector<ghost_element_class> m_ghosts;  /**< Vector storing the (local) ghost elements. */
-  std::conditional_t<!std::is_void_v<TUserData>, TUserData, std::nullptr_t>
-    m_user_data; /**< User data associated with the mesh. */
 };
 
 }  // namespace t8_mesh_handle
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 8bcf97e7ca..ec49c011d2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -213,6 +213,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_user_data_serial                 SOURCES mesh_handle/t8_gtest_user_data.cxx )
 endif()
 
 copy_test_file( test_cube_unstructured_1.inp )
diff --git a/test/mesh_handle/t8_gtest_user_data.cxx b/test/mesh_handle/t8_gtest_user_data.cxx
new file mode 100644
index 0000000000..d35be7d502
--- /dev/null
+++ b/test/mesh_handle/t8_gtest_user_data.cxx
@@ -0,0 +1,75 @@
+/*
+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_user_data.cxx
+ * TODO.
+ */
+
+#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>
+
+// 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. */
+};
+
+/** Tests that the functionality of the handle gives the same results as if worked with the forest directly.
+ * Therefore, we compare the results of the mesh handle with the one accessed with the forest directly.
+ */
+TEST (t8_gtest_user_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. */
+  };
+
+  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);
+}

From 58559f310512d789d0c2a12864b6ffb4fde4fe90 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Fri, 28 Nov 2025 12:47:43 +0100
Subject: [PATCH 06/11] implement get_volume with cache

---
 mesh_handle/abstract_element.hxx              | 42 ++++++++++++++++++
 mesh_handle/competence_pack.hxx               |  2 +-
 mesh_handle/competences.hxx                   | 23 ++++++++++
 .../mesh_handle/t8_gtest_cache_competence.cxx | 43 ++++++++++++++++++-
 .../t8_gtest_compare_handle_to_forest.cxx     |  2 +
 test/mesh_handle/t8_gtest_mesh_handle.cxx     |  5 +++
 6 files changed, 114 insertions(+), 3 deletions(-)

diff --git a/mesh_handle/abstract_element.hxx b/mesh_handle/abstract_element.hxx
index b266d258b4..e31db214a1 100644
--- a/mesh_handle/abstract_element.hxx
+++ b/mesh_handle/abstract_element.hxx
@@ -75,6 +75,20 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
   }
 
   // --- 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 (); };
+  }
+  /* This variable is true if any of the given competences \ref TCompetence implements 
+  a function volume_cache_filled. */
+  static constexpr bool volume_cache_exists = (false || ... || volume_cache_defined<TCompetence> ());
+
   /** 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.
@@ -105,6 +119,15 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
 
  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 volume_cache_exists;
+  }
   /**
    * Function that checks if a cache for the vertex coordinates exists.
    * \return true if a cache for the vertex coordinates exists, false otherwise.
@@ -161,6 +184,25 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
     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 (volume_cache_exists) {
+      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.
diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 32c15ec6dd..2bf030a5da 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -45,7 +45,7 @@ struct competence_pack
 };
 
 // Predefined competence pack combining all caching competences.
-using cache_competences = competence_pack<cache_vertex_coordinates, cache_centroid, cache_neighbors>;
+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 dda7dbd17e..eac08251d3 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -47,6 +47,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/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index b6e52dbf21..eb4fe57bb4 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -38,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>
@@ -90,6 +105,32 @@ 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::abstract_element_class;
+  mesh_class mesh = mesh_class (forest);
+  EXPECT_TRUE (element_class::has_volume_cache ());
+
+  double unrealistic_volume = -3000;
+  for (auto it = mesh.begin (); it != mesh.end (); ++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.
@@ -100,7 +141,6 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
   using element_class = typename mesh_class::abstract_element_class;
   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) {
@@ -132,7 +172,6 @@ TEST_F (t8_gtest_cache_competence, cache_centroid)
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
   using element_class = mesh_class::abstract_element_class;
   mesh_class mesh = mesh_class (forest);
-  EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
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..b8ff456865 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.
@@ -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_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 14b5ebfbc3..7b39beac29 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -166,14 +166,17 @@ TEST_P (t8_mesh_handle_test, test_2_competences)
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_competences>;
   using element_class = typename mesh_class::abstract_element_class;
   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) {
+    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);
@@ -189,9 +192,11 @@ 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) {
+    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);

From 8d94a95a05cc11010a20873b0ded7cda3abfc2a1 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Fri, 28 Nov 2025 12:48:15 +0100
Subject: [PATCH 07/11] add check for ghost test that we actually test smth

---
 test/mesh_handle/t8_gtest_ghost.cxx | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 3128b88475..5270779f06 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -68,6 +68,10 @@ TEST_P (t8_mesh_ghost_test, check_ghosts)
 
   t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
   EXPECT_EQ (mesh.get_num_local_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.
+    EXPECT_GT (mesh.get_num_local_ghosts (), 0);
+  }
 
   // Check that functionality of mesh elements is still valid.
   for (auto it = mesh.begin (); it != mesh.end (); ++it) {

From e7934cc9a84893d9fe780f67c1dd7bcc4cd829f9 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Fri, 28 Nov 2025 13:06:13 +0100
Subject: [PATCH 08/11] add element data functionality

---
 mesh_handle/mesh.hxx                    | 79 +++++++++++++++++++++----
 test/CMakeLists.txt                     |  2 +-
 test/mesh_handle/t8_gtest_user_data.cxx | 50 +++++++++++++++-
 3 files changed, 114 insertions(+), 17 deletions(-)

diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 1ae69841d2..bf7bf31911 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -45,11 +45,14 @@ namespace t8_mesh_handle
  * \tparam TCompetencePack The competences you want to add to the default functionality of the mesh.
  *         \see abstract_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 <typename TCompetencePack = competence_pack<>, typename TUserData = void>
+template <typename TCompetencePack = competence_pack<>, typename TUserData = void, typename TElementData = void>
 class mesh {
  public:
-  using SelfType = mesh<TCompetencePack, TUserData>;
+  using SelfType = mesh<TCompetencePack, TUserData, TElementData>;
   /** Type definitions of the element classes with given competences. */
   using abstract_element_class = TCompetencePack::template apply<
     SelfType, abstract_element>; /**< The abstract element class of the mesh (could be a mesh element of ghost). */
@@ -97,6 +100,16 @@ class mesh {
     return t8_forest_get_num_ghosts (m_forest);
   }
 
+  /** 
+   * Getter for the dimension the mesh handle lives in.
+   * \return The dimension.
+   */
+  int
+  get_dimension () const
+  {
+    return t8_forest_get_dimension (m_forest);
+  }
+
   /**
    * Returns a constant iterator to the first (local) mesh element.
    * \return Constant iterator to the first (local) mesh element.
@@ -179,9 +192,9 @@ 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)
   {
@@ -191,9 +204,9 @@ class mesh {
   }
 
   /** 
-    * 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. Data will never be touched by mesh handling routines.
-    */
+   * 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)
@@ -202,15 +215,55 @@ class mesh {
   }
 
   /** 
-    * TODO
-    */
+   * 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 ()
+  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_local_ghosts ());
+    std::copy (element_data.begin (), element_data.end (), m_element_data.begin ());
+  }
+
+  /** 
+   * Get the element data vector including ghost entries.
+   * The element data of the local mesh elements is the one set using \ref set_element_data.
+   * In this function, additionally the ghost entries are filled exchanging the correct entries of the
+   *   element vector between processes.
+   * \return 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>&
+  get_element_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_local_ghosts ());
+    sc_array_wrapper = sc_array_new_data (m_element_data.data (), sizeof (TElementData),
+                                          get_num_local_elements () + get_num_local_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:
   /** 
    * Update the storage of the mesh elements according to the current forest. 
@@ -218,7 +271,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.
@@ -237,7 +289,6 @@ class mesh {
   void
   update_ghost_elements ()
   {
-    // Clear the ghost vector if already created.
     m_ghosts.clear ();
     m_ghosts.reserve (get_num_local_ghosts ());
     t8_locidx_t num_loc_trees = t8_forest_get_num_local_trees (m_forest);
@@ -253,6 +304,8 @@ class mesh {
   t8_forest_t m_forest;                       /**< The forest the mesh should be defined for. */
   std::vector<mesh_element_class> m_elements; /**< Vector storing the (local) mesh elements. */
   std::vector<ghost_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 ec49c011d2..12f6f967a5 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -213,7 +213,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_user_data_serial                 SOURCES mesh_handle/t8_gtest_user_data.cxx )
+  add_t8_cpp_test( NAME t8_gtest_handle_user_data_parallel        SOURCES mesh_handle/t8_gtest_user_data.cxx )
 endif()
 
 copy_test_file( test_cube_unstructured_1.inp )
diff --git a/test/mesh_handle/t8_gtest_user_data.cxx b/test/mesh_handle/t8_gtest_user_data.cxx
index d35be7d502..462a30fe2d 100644
--- a/test/mesh_handle/t8_gtest_user_data.cxx
+++ b/test/mesh_handle/t8_gtest_user_data.cxx
@@ -22,7 +22,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 /**
  * \file t8_gtest_user_data.cxx
- * TODO.
+ * Tests to check that \ref t8_mesh_handle::mesh user data and element data functionality works as intended.
  */
 
 #include <gtest/gtest.h>
@@ -35,7 +35,9 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #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
 {
@@ -44,8 +46,7 @@ struct dummy_user_data
   double coarsen_if_outside_radius; /* if an element's center is larger this value, we coarsen its family. */
 };
 
-/** Tests that the functionality of the handle gives the same results as if worked with the forest directly.
- * Therefore, we compare the results of the mesh handle with the one accessed with the forest directly.
+/** Check that user data can be set and accesses for the handle.
  */
 TEST (t8_gtest_user_data, set_and_get_user_data)
 {
@@ -64,6 +65,7 @@ TEST (t8_gtest_user_data, set_and_get_user_data)
     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);
@@ -73,3 +75,45 @@ TEST (t8_gtest_user_data, set_and_get_user_data)
   // 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_user_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_local_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.get_element_data ();
+  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements () + mesh.get_num_local_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;
+  }
+
+  // Unref the forest.
+  t8_forest_unref (&forest);
+}

From a1cabedd8d4875290f8b6851139c9064ec1f97e3 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Fri, 28 Nov 2025 13:07:41 +0100
Subject: [PATCH 09/11] rename test

---
 .../{t8_gtest_user_data.cxx => t8_gtest_handle_data.cxx}          | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename test/mesh_handle/{t8_gtest_user_data.cxx => t8_gtest_handle_data.cxx} (100%)

diff --git a/test/mesh_handle/t8_gtest_user_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
similarity index 100%
rename from test/mesh_handle/t8_gtest_user_data.cxx
rename to test/mesh_handle/t8_gtest_handle_data.cxx

From 5119d032c687a13e66aca7a3aa673b544b50ef06 Mon Sep 17 00:00:00 2001
From: lenaploetzke <70579874+lenaploetzke@users.noreply.github.com>
Date: Fri, 28 Nov 2025 13:14:08 +0100
Subject: [PATCH 10/11] adapt cmake

---
 test/CMakeLists.txt                       | 2 +-
 test/mesh_handle/t8_gtest_handle_data.cxx | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 12f6f967a5..e49877a03d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -213,7 +213,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_user_data_parallel        SOURCES mesh_handle/t8_gtest_user_data.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_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 462a30fe2d..196d28a38a 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -21,7 +21,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 */
 
 /**
- * \file t8_gtest_user_data.cxx
+ * \file t8_gtest_handle_data.cxx
  * Tests to check that \ref t8_mesh_handle::mesh user data and element data functionality works as intended.
  */
 
@@ -48,7 +48,7 @@ struct dummy_user_data
 
 /** Check that user data can be set and accesses for the handle.
  */
-TEST (t8_gtest_user_data, set_and_get_user_data)
+TEST (t8_gtest_handle_data, set_and_get_user_data)
 {
   // Define forest and mesh handle.
   const int level = 2;
@@ -87,7 +87,7 @@ struct data_per_element
 /** Check that element data can be set for the handle and 
  * that the getter has exchanged data for the ghosts.
  */
-TEST (t8_gtest_user_data, set_and_get_element_data)
+TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
   // Define forest and mesh handle.
   const int level = 2;

From c2a78f5623ca332d6164d1889ed3342012ce4b99 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 18 Dec 2025 10:44:02 +0100
Subject: [PATCH 11/11] resolve doxygen warnings

---
 mesh_handle/abstract_element.hxx | 2 +-
 mesh_handle/competence_pack.hxx  | 6 +++---
 mesh_handle/competences.hxx      | 2 +-
 mesh_handle/mesh.hxx             | 3 ++-
 4 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/mesh_handle/abstract_element.hxx b/mesh_handle/abstract_element.hxx
index 5183ca6b75..2c23172243 100644
--- a/mesh_handle/abstract_element.hxx
+++ b/mesh_handle/abstract_element.hxx
@@ -87,7 +87,7 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
   {
     return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
   }
-  /* This variable is true if any of the given competences \ref TCompetence implements 
+  /** This variable is true if any of the given competences \a TCompetence implements 
   a function volume_cache_filled. */
   static constexpr bool volume_cache_exists = (false || ... || volume_cache_defined<TCompetence> ());
 
diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 2bf030a5da..ee351401d2 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -36,15 +36,15 @@ template <template <typename> class... TCompetence>
 struct competence_pack
 {
   /** Apply the competence pack to a template class, e.g. the \ref abstract_element class.
-   * \tparam Target The target template class to apply the \ref TCompetence pack to.
+   * \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.
+  using is_competence_pack = void; /**< Tag to identify this class. */
 };
 
-// Predefined competence pack combining all caching competences.
+/** 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
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index ee38fbec3c..30d79af5ca 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -50,7 +50,7 @@ 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.
+ * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
  */
 template <typename TUnderlying>
 struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index ba57b726f3..86655a5ddb 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -52,7 +52,8 @@ namespace t8_mesh_handle
 template <typename TCompetencePack = competence_pack<>, typename TUserData = void, typename TElementData = void>
 class mesh {
  public:
-  using SelfType = mesh<TCompetencePack, TUserData, TElementData>;
+  using SelfType = mesh<TCompetencePack, TUserData,
+                        TElementData>; /**< Type of the current class with all template parameters specified. */
   /** Type definitions of the element classes with given competences. */
   using abstract_element_class = TCompetencePack::template apply<
     SelfType, abstract_element>; /**< The abstract element class of the mesh (could be a mesh element of ghost). */