From b4db816cd2c507e3539182e68f5502103a111696 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 19 Feb 2026 15:29:05 +0100
Subject: [PATCH 1/6] first working version

---
 mesh_handle/competence_pack.hxx               |   5 +-
 mesh_handle/competences.hxx                   |  50 ++++++-
 mesh_handle/data_handler.hxx                  | 125 ++++++++++++++++++
 mesh_handle/element.hxx                       |  55 ++------
 mesh_handle/mesh.hxx                          |  85 ++++--------
 .../t8_gtest_adapt_partition_balance.cxx      |   7 +-
 .../t8_gtest_compare_handle_to_forest.cxx     |   2 +-
 test/mesh_handle/t8_gtest_ghost.cxx           |   4 +-
 test/mesh_handle/t8_gtest_handle_data.cxx     |  15 ++-
 test/mesh_handle/t8_gtest_mesh_handle.cxx     |   2 +-
 10 files changed, 236 insertions(+), 114 deletions(-)
 create mode 100644 mesh_handle/data_handler.hxx

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 258e93f66a..196e8ebb82 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -36,10 +36,11 @@ template <template <typename> class... TCompetence>
 struct competence_pack
 {
   /** Apply the competence pack to a template class, e.g. the \ref element class.
+   * \tparam TMeshClass The mesh class given to the 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...>;
+  template <typename TMeshClass, template <typename, template <typename> class...> class Target>
+  using apply = Target<TMeshClass, TCompetence...>;
 
   using is_competence_pack = void; /**< Tag to identify this class. */
 };
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index 514e1d3cf5..2649c4571e 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -28,7 +28,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  * All competences have the same inheritance pattern: 
  * We use the CRTP pattern as we may need to access members of the derived classes like 
  * \ref t8_mesh_handle::element. 
- * The t8_crtp_operator is used for convenience/clear code (avoid to type a static cast explicitly each time 
+ * The t8_crtp_basic is used for convenience/clear code (avoid to type a static cast explicitly each time 
  * we need functionality of TUnderlying).
  * Especially for the competences to cache functionality, the access of members is not necessary, 
  * such that it is not obvious why we use the crtp. For competences that extend the functionality of the element, 
@@ -39,6 +39,10 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #pragma once
 
 #include <t8.h>
+#include "element.hxx"
+#include "mesh.hxx"
+#include "data_handler.hxx"
+#include <t8_types/t8_crtp.hxx>
 #include <t8_types/t8_operators.hxx>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
@@ -52,7 +56,49 @@ namespace t8_mesh_handle
  * \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>
+struct access_element_data: public t8_crtp_basic<TUnderlying>
+{
+ public:
+  // --- 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 TMeshClass::ElementDataType.
+   */
+  const auto &
+  get_element_data () const
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    const t8_locidx_t handle_id = this->underlying ().get_element_handle_id ();
+    T8_ASSERTF (static_cast<size_t> (handle_id) < this->underlying ().m_mesh->m_element_data.size (),
+                "Element data not set.\n");
+    return this->underlying ().m_mesh->m_element_data[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.
+   */
+  void
+  set_element_data (auto element_data)
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    SC_CHECK_ABORT (!this->underlying ().is_ghost_element (), "Element data cannot be set for ghost elements.\n");
+    // Resize for the case that no data vector has been set previously.
+    this->underlying ().m_mesh->m_element_data.reserve (this->underlying ().m_mesh->get_num_local_elements ()
+                                                        + this->underlying ().m_mesh->get_num_ghosts ());
+    this->underlying ().m_mesh->m_element_data.resize (this->underlying ().m_mesh->get_num_local_elements ());
+    this->underlying ().m_mesh->m_element_data[this->underlying ().get_element_handle_id ()] = std::move (element_data);
+  }
+};
+
+/**
+ * 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_basic<TUnderlying>
 {
  public:
   /**
diff --git a/mesh_handle/data_handler.hxx b/mesh_handle/data_handler.hxx
new file mode 100644
index 0000000000..7abca12413
--- /dev/null
+++ b/mesh_handle/data_handler.hxx
@@ -0,0 +1,125 @@
+/*
+  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) 2026 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 data_handler.hxx
+ * Handler for the element data of a \ref t8_mesh_handle::mesh.
+ */
+#pragma once
+
+#include <t8_types/t8_crtp.hxx>
+#include <type_traits>
+#include <vector>
+
+namespace t8_mesh_handle
+{
+
+/** Concept to ensure that a type is MPI safe.
+ */
+template <typename TType>
+concept T8MPISafeType
+  = std::is_void_v<TType> || (std::is_trivially_copyable_v<TType> && std::is_standard_layout_v<TType>);
+
+/**
+ * Handler for the element data of a \ref mesh.
+ * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
+ *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
+ */
+template <typename TUnderlying, T8MPISafeType TElementDataType>
+class handle_element_data: public t8_crtp_basic<TUnderlying> {
+ public:
+  using ElementDataType = TElementDataType; /**< Make Type of the element data accessible. */
+                                            /** 
+   * 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 TElementDataType 
+   *            for each local mesh element (excluding ghosts).
+   */
+  template <typename ElementDataType = TElementDataType,
+            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
+  void
+  set_element_data (std::vector<ElementDataType> element_data)
+  {
+    const auto num_local_elements = this->underlying ().get_num_local_elements ();
+    const auto num_ghosts = this->underlying ().get_num_ghosts ();
+    T8_ASSERT (element_data.size () == static_cast<size_t> (num_local_elements));
+    m_element_data = std::move (element_data);
+    m_element_data.reserve (num_local_elements + num_ghosts);
+    m_element_data.resize (num_local_elements);
+  }
+
+  /** 
+   * 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 TElementDataType.
+   */
+  template <typename ElementDataType = TElementDataType,
+            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
+  const std::vector<ElementDataType>&
+  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.
+  */
+  void
+  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;
+    const auto num_local_elements = this->underlying ().get_num_local_elements ();
+    const auto num_ghosts = this->underlying ().get_num_ghosts ();
+    m_element_data.resize (num_local_elements + num_ghosts);
+    sc_array_wrapper
+      = sc_array_new_data (m_element_data.data (), sizeof (ElementDataType), num_local_elements + num_ghosts);
+
+    // Data exchange: entries with indices > num_local_elements will get overwritten.
+    t8_forest_ghost_exchange_data (this->underlying ().get_forest (), sc_array_wrapper);
+
+    sc_array_destroy (sc_array_wrapper);
+  }
+
+ protected:
+  std::vector<TElementDataType> m_element_data; /**< Vector storing the (local) element data. */
+};
+
+/**
+ * Helper alias to create a mesh competence for element data
+ * without exposing TUnderlying to the user.
+ *
+ * Usage:
+ *   using mesh_type =
+ *     mesh<competence_pack<...>, element_data_competence<MyData>>;
+ */
+// template <T8MPISafeType TElementDataType>
+// struct element_data_wrapper
+// {
+//   template <typename TUnderlying>
+//   using type = handle_element_data<TUnderlying, TElementDataType>;
+// };
+
+// template <T8MPISafeType TElementDataType>
+// using element_data_mesh_competence = typename element_data_wrapper<TElementDataType>::template type;
+
+}  // namespace t8_mesh_handle
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index 5cf3ec1d8e..d8d5c5fcbb 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -27,6 +27,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #pragma once
 
 #include <t8.h>
+#include "competences.hxx"
 #include <t8_element.h>
 #include <t8_eclass.h>
 #include <t8_forest/t8_forest_general.h>
@@ -55,24 +56,27 @@ namespace t8_mesh_handle
  * The choice between calculate and cache is a tradeoff between runtime and memory usage. 
  *
  * \tparam TCompetences The competences you want to add to the default functionality of the element.
+ * \tparam TMeshClass The class of the mesh the element belongs to.
  */
 
-template <typename mesh_class, template <typename> class... TCompetences>
-class element: public TCompetences<element<mesh_class, TCompetences...>>... {
+template <typename TMeshClass, template <typename> class... TCompetences>
+class element: public TCompetences<element<TMeshClass, TCompetences...>>... {
  private:
   using SelfType
-    = element<mesh_class, TCompetences...>; /**< 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. */
+    = element<TMeshClass, TCompetences...>; /**< Type of the current class with all template parameters specified. */
+  friend TMeshClass; /**< Define TMeshClass as friend to be able to access e.g. the constructor. */
+  template <typename>
+  friend struct access_element_data;
 
   /**
    * Private constructor for an element of a mesh. This could be a simple mesh element or a ghost element.
-   * This constructor should only be called by the mesh_class (and invisible for the user).
+   * This constructor should only be called by the TMeshClass (and invisible for the user).
    * \param [in] mesh             Pointer to the mesh the element should belong to.
    * \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.
    * \param [in] is_ghost_element Flag to indicate that this element is a ghost element. Default is false.
    */
-  element (mesh_class* mesh, t8_locidx_t tree_id, t8_locidx_t element_id, bool is_ghost_element = false)
+  element (TMeshClass* mesh, t8_locidx_t tree_id, t8_locidx_t element_id, bool is_ghost_element = false)
     : m_mesh (mesh), m_tree_id (tree_id), m_element_id (element_id), m_is_ghost_element (is_ghost_element)
   {
     if (m_is_ghost_element) {
@@ -399,7 +403,7 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
    * Getter for the mesh to which the element belongs.
    * \return Reference to the mesh.
    */
-  const mesh_class*
+  const TMeshClass*
   get_mesh () const
   {
     return m_mesh;
@@ -415,39 +419,6 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
     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 TElementDataType = typename mesh_class::ElementDataType,
-            typename = std::enable_if_t<!std::is_void<TElementDataType>::value>>
-  const TElementDataType&
-  get_element_data () const
-  {
-    const t8_locidx_t handle_id = get_element_handle_id ();
-    T8_ASSERTF (static_cast<size_t> (handle_id) < m_mesh->m_element_data.size (), "Element data not set.\n");
-    return m_mesh->m_element_data[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 TElementDataType = typename mesh_class::ElementDataType,
-            typename = std::enable_if_t<!std::is_void<TElementDataType>::value>>
-  void
-  set_element_data (TElementDataType 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.reserve (m_mesh->get_num_local_elements () + m_mesh->get_num_ghosts ());
-    m_mesh->m_element_data.resize (m_mesh->get_num_local_elements ());
-    m_mesh->m_element_data[get_element_handle_id ()] = std::move (element_data);
-  }
-
  private:
   //--- Private getter for internal use. ---
   /**
@@ -470,7 +441,9 @@ class element: public TCompetences<element<mesh_class, TCompetences...>>... {
     return t8_forest_get_tree_class (m_mesh->m_forest, m_tree_id);
   }
 
-  mesh_class* m_mesh;             /**< Pointer to the mesh the element is defined for. */
+ protected:
+  TMeshClass* m_mesh; /**< Pointer to the mesh the element is defined for. */
+ private:
   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 c9a459367d..4a96732cf8 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -30,39 +30,31 @@
 #include "element.hxx"
 #include "competence_pack.hxx"
 #include "adapt.hxx"
+#include "competences.hxx"
 #include "t8_forest/t8_forest_balance.h"
 #include "t8_forest/t8_forest_types.h"
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_ghost.h>
 #include <vector>
-#include <type_traits>
 #include <functional>
 #include <memory>
 
 namespace t8_mesh_handle
 {
 
-/** Concept to ensure that a type is MPI safe.
- */
-template <typename TType>
-concept T8MPISafeType
-  = std::is_void_v<TType> || (std::is_trivially_copyable_v<TType> && std::is_standard_layout_v<TType>);
-
 /**
  * Wrapper for a forest that enables it to be handled as a simple mesh object.
  * \tparam TCompetencePack 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 TElementDataType The element data type you want to use for each element of the mesh. 
- *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
+ * \tparam TMeshCompetences 
  *         Use void (this is also the default) if you do not want to set element data.
  */
-template <typename TCompetencePack = competence_pack<>, T8MPISafeType TElementDataType = void>
-class mesh {
+template <typename TCompetencePack, template <typename> class... TMeshCompetences>
+class mesh: public TMeshCompetences<mesh<TCompetencePack, TMeshCompetences...>>... {
  public:
-  using SelfType
-    = mesh<TCompetencePack, TElementDataType>; /**< Type of the current class with all template parameters specified. */
-  using ElementDataType = TElementDataType;    /**< Make Type of the element data accessible. */
+  using SelfType = mesh<TCompetencePack,
+                        TMeshCompetences...>; /**< Type of the current class with all template parameters specified. */
   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. */
@@ -70,6 +62,8 @@ class mesh {
     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. */
+  template <typename>
+  friend struct access_element_data;
 
   /** Callback function prototype to decide for refining and coarsening of a family of elements
    * or one element in a mesh handle.
@@ -374,7 +368,7 @@ class mesh {
     // Check if we adapted and unregister the adapt context if so.
     if (detail::AdaptRegistry::get (m_uncommitted_forest.value ()) != nullptr) {
       detail::AdaptRegistry::unregister_context (m_forest);
-      if (!std::is_void<TElementDataType>::value) {
+      if (has_element_data_handler_competence ()) {
         t8_global_infof (
           "Please note that the element data is not interpolated automatically during adaptation. Use the "
           "function set_element_data() to provide new adapted element data.\n");
@@ -388,58 +382,29 @@ class mesh {
   }
 
   // --- Methods to set and get user and element data and exchange data between processes. ---
-  /** 
-   * 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 TElementDataType 
-   *            for each local mesh element (excluding ghosts).
-   */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  void
-  set_element_data (std::vector<ElementDataType> element_data)
-  {
-    T8_ASSERT (element_data.size () == static_cast<size_t> (get_num_local_elements ()));
-    m_element_data = std::move (element_data);
-    m_element_data.reserve (get_num_local_elements () + get_num_ghosts ());
-    m_element_data.resize (get_num_local_elements ());
-  }
+  // TODO document
 
-  /** 
-   * 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 TElementDataType.
+  /** Function that checks if a competence for element data handling is given.
+   * \return true if mesh has a data handler, false otherwise.
    */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  const std::vector<ElementDataType>&
-  get_element_data () const
+  static constexpr bool
+  has_element_data_handler_competence ()
   {
-    return m_element_data;
+    return (false || ... || element_data_handler_competence_defined<TMeshCompetences> ());
   }
 
-  /** 
-  * 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.
-  */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  void
-  exchange_ghost_data ()
+ private:
+  /** Helper function to check if class T implements the function get_element_data.
+   * \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
+  element_data_handler_competence_defined ()
   {
-    // t8_forest_ghost_exchange_data expects an sc_array, so we need to wrap our data array to one.
-    sc_array* sc_array_wrapper;
-    m_element_data.resize (get_num_local_elements () + get_num_ghosts ());
-    sc_array_wrapper = sc_array_new_data (m_element_data.data (), sizeof (ElementDataType),
-                                          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 requires (T<SelfType>& competence) { competence.get_element_data (); };
   }
 
- private:
   /** 
    * Update the storage of the mesh elements according to the current forest. 
    */
@@ -483,8 +448,6 @@ 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<TElementDataType>, std::vector<TElementDataType>, std::nullptr_t>
-    m_element_data; /**< Vector storing the (local) element data. */
   std::optional<t8_forest_t>
     m_uncommitted_forest; /**< Forest in which the set flags are set for a new forest before committing. */
 };
diff --git a/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
index 3dde1d26cf..66a94131e0 100644
--- a/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
+++ b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
@@ -35,6 +35,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competence_pack.hxx>
 #include <mesh_handle/adapt.hxx>
+#include <mesh_handle/data_handler.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -50,6 +51,9 @@ struct dummy_user_data
   double coarsen_if_outside_radius; /**< If an element's center is larger this value, we coarsen its family. */
 };
 
+template <typename TUnderlying>
+using data_handler = t8_mesh_handle::handle_element_data<TUnderlying, dummy_user_data>;
+
 /** Callback function for the mesh handle to decide for refining or coarsening of (a family of) elements.
  * The function header fits the definition of \ref TMesh::adapt_callback_type_with_userdata.
  * \tparam TMeshClass    The mesh handle class.
@@ -111,7 +115,8 @@ TEST (t8_gtest_handle_adapt, compare_adapt_with_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);
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
+  using mesh_class
+    = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<t8_mesh_handle::access_element_data>, data_handler>;
   mesh_class mesh_handle = mesh_class (forest);
   struct dummy_user_data user_data = {
     t8_3D_point ({ 0.5, 0.5, 1 }), /**< Midpoints of the sphere. */
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 570e5fad2d..c8f5a47e6e 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -46,7 +46,7 @@ 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);
 
-  const t8_mesh_handle::mesh<> mesh (forest);
+  const t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>> 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);
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index a0ba46e487..8287fff4c0 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -59,7 +59,7 @@ struct t8_mesh_ghost_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
 /** Check the implementation of ghosts and all functions accessible by ghosts. */
 TEST_P (t8_mesh_ghost_test, check_ghosts)
 {
-  using mesh_class = t8_mesh_handle::mesh<>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>>;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             false, false);
 
@@ -103,7 +103,7 @@ TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
   t8_forest_t forest = t8_forest_new_uniform (t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0), scheme,
                                               level, 1, sc_MPI_COMM_WORLD);
 
-  const t8_mesh_handle::mesh<> mesh (forest);
+  const t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>> 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.
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 6d8c7d9062..82a0ab98f2 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -30,7 +30,9 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competence_pack.hxx>
+#include <mesh_handle/competences.hxx>
 #include <mesh_handle/constructor_wrappers.hxx>
+#include <mesh_handle/data_handler.hxx>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
@@ -41,6 +43,8 @@ struct data_per_element
   int level;
   double volume;
 };
+template <typename TUnderlying>
+using data_handler = t8_mesh_handle::handle_element_data<TUnderlying, data_per_element>;
 
 /** Check that element data can be set for the handle and 
  * that the getter has exchanged data for the ghosts.
@@ -48,10 +52,11 @@ struct data_per_element
 TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
   const int level = 2;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, data_per_element>;
+
+  using mesh_class
+    = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<t8_mesh_handle::access_element_data>, data_handler>;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, false,
                                                                                    true, false);
-  auto forest = mesh->get_forest ();
 
   if ((mesh->get_dimension () > 1) && (mesh->get_num_local_elements () > 1)) {
     // Ensure that we actually test with ghost elements.
@@ -70,12 +75,16 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
     EXPECT_EQ (mesh_element_data[ielem].level, level) << "ielem = " << ielem;
     EXPECT_EQ (mesh_element_data[ielem].volume, (*mesh)[ielem].get_volume ()) << "ielem = " << ielem;
   }
+  EXPECT_TRUE (mesh->has_element_data_handler_competence ());
+
+  auto forest = mesh->get_forest ();
   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 });
+      data_per_element elem_data ({ newlevel, newvolume });
+      elem.set_element_data (elem_data);
     }
   }
   mesh->exchange_ghost_data ();
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 43fddd4fb7..ecd48feb55 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -52,7 +52,7 @@ struct t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t
 /** Test some default functionality and the iterator of \ref t8_mesh_handle::mesh. */
 TEST_P (t8_mesh_handle_test, test_iterator)
 {
-  using mesh_class = t8_mesh_handle::mesh<>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             true, false);

From 7003620580a527bf2b6a91a86f81776284d2d4fe Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 19 Feb 2026 16:58:19 +0100
Subject: [PATCH 2/6] cool working solution with mesh competence pack

---
 mesh_handle/competence_pack.hxx               | 42 +++++++++++++----
 mesh_handle/data_handler.hxx                  | 23 +++------
 mesh_handle/mesh.hxx                          | 47 +++++++++----------
 .../t8_gtest_adapt_partition_balance.cxx      |  8 ++--
 .../mesh_handle/t8_gtest_cache_competence.cxx |  6 +--
 .../t8_gtest_compare_handle_to_forest.cxx     |  2 +-
 .../t8_gtest_custom_competence.cxx            |  5 +-
 test/mesh_handle/t8_gtest_ghost.cxx           |  6 +--
 test/mesh_handle/t8_gtest_handle_data.cxx     |  7 ++-
 test/mesh_handle/t8_gtest_mesh_handle.cxx     |  9 ++--
 10 files changed, 81 insertions(+), 74 deletions(-)

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 196e8ebb82..8587926aad 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -21,7 +21,8 @@
 */
 
 /** \file competence_pack.hxx
- * Define to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ * Define classes to pack different competences into one template parameter for the \ref t8_mesh_handle::mesh class.
+ * We have one class for element competences and one for mesh competences. 
  */
 #ifndef T8_COMPETENCE_PACK_HXX
 #define T8_COMPETENCE_PACK_HXX
@@ -29,24 +30,45 @@
 #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.
+// --- Element competence pack. ---
+/** Class to pack different element competences into one template parameter for the \ref mesh class.
+ * \tparam TElementCompetence The competences to be packed.
  */
-template <template <typename> class... TCompetence>
-struct competence_pack
+template <template <typename> class... TElementCompetence>
+struct element_competence_pack
 {
   /** Apply the competence pack to a template class, e.g. the \ref element class.
    * \tparam TMeshClass The mesh class given to the element class.
-   * \tparam Target The target template class to apply the \a TCompetence pack to.
+   * \tparam Target The target template class to apply the \a TElementCompetence pack to.
    */
   template <typename TMeshClass, template <typename, template <typename> class...> class Target>
-  using apply = Target<TMeshClass, TCompetence...>;
+  using apply = Target<TMeshClass, TElementCompetence...>;
 
-  using is_competence_pack = void; /**< Tag to identify this class. */
+  using is_element_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>;
+/** Predefined element competence pack combining all caching competences. */
+using cache_element_competences
+  = element_competence_pack<cache_volume, cache_vertex_coordinates, cache_centroid, cache_neighbors>;
+
+// --- Mesh competence pack. ---
+/** Class to pack different mesh competences into one template parameter for the \ref mesh class.
+ * \tparam TMeshCompetence The mesh competences to be packed.
+ */
+template <template <typename> class... TMeshCompetence>
+struct mesh_competence_pack
+{
+  /** Apply the mesh competence pack to a mesh type.
+   *  By inheriting from all mesh competences, the functionality of the competences gets added to the mesh type.
+   *  \tparam TMesh The mesh type to which the competences are applied.
+   */
+  template <typename TMesh>
+  struct apply: public TMeshCompetence<TMesh>...
+  {
+  };
+
+  using is_mesh_competence_pack = void; /**< Tag to identify this class. */
+};
 
 }  // namespace t8_mesh_handle
 #endif /* !T8_COMPETENCE_PACK_HXX */
diff --git a/mesh_handle/data_handler.hxx b/mesh_handle/data_handler.hxx
index 7abca12413..9c26e7d573 100644
--- a/mesh_handle/data_handler.hxx
+++ b/mesh_handle/data_handler.hxx
@@ -104,22 +104,11 @@ class handle_element_data: public t8_crtp_basic<TUnderlying> {
   std::vector<TElementDataType> m_element_data; /**< Vector storing the (local) element data. */
 };
 
-/**
- * Helper alias to create a mesh competence for element data
- * without exposing TUnderlying to the user.
- *
- * Usage:
- *   using mesh_type =
- *     mesh<competence_pack<...>, element_data_competence<MyData>>;
- */
-// template <T8MPISafeType TElementDataType>
-// struct element_data_wrapper
-// {
-//   template <typename TUnderlying>
-//   using type = handle_element_data<TUnderlying, TElementDataType>;
-// };
-
-// template <T8MPISafeType TElementDataType>
-// using element_data_mesh_competence = typename element_data_wrapper<TElementDataType>::template type;
+template <T8MPISafeType TElementDataType>
+struct element_data_competence
+{
+  template <typename TMesh>
+  using type = handle_element_data<TMesh, TElementDataType>;
+};
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 4a96732cf8..79cbd3f9c0 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -42,21 +42,32 @@
 namespace t8_mesh_handle
 {
 
+/** Concept to ensure that a type is an element competence pack.
+ */
+template <typename TType>
+concept ElementCompetencePack = requires { typename TType::is_element_competence_pack; };
+/** Concept to ensure that a type is a mesh competence pack.
+ */
+template <typename TType>
+concept MeshCompetencePack = requires { typename TType::is_mesh_competence_pack; };
+
 /**
  * Wrapper for a forest that enables it to be handled as a simple mesh object.
- * \tparam TCompetencePack The competences you want to add to the default functionality of the mesh.
+ * \tparam TElementCompetencePack The competences you want to add to the default functionality of the elements.
  *         \see element for more details on the choice of the template parameter.   
- *         \note Please pack your competences using the \ref competence_pack class.
- * \tparam TMeshCompetences 
- *         Use void (this is also the default) if you do not want to set element data.
+ *         \note Please pack your competences using the \ref element_competence_pack class.
+ * \tparam TMeshCompetences The competences you want to add to the default functionality of the mesh.  
+ *         \note Please pack your competences using the \ref mesh_competence_pack class.
+ *         One of the most important competences to add is \ref handle_element_data.
  */
-template <typename TCompetencePack, template <typename> class... TMeshCompetences>
-class mesh: public TMeshCompetences<mesh<TCompetencePack, TMeshCompetences...>>... {
+template <ElementCompetencePack TElementCompetencePack = element_competence_pack<>,
+          MeshCompetencePack TMeshCompetencePack = mesh_competence_pack<>>
+class mesh: public TMeshCompetencePack::template apply<mesh<TElementCompetencePack, TMeshCompetencePack>> {
  public:
-  using SelfType = mesh<TCompetencePack,
-                        TMeshCompetences...>; /**< Type of the current class with all template parameters specified. */
+  using SelfType = mesh<TElementCompetencePack, TMeshCompetencePack>; /**< Type of the current class. */
   using element_class
-    = TCompetencePack::template apply<SelfType, element>; /**< The element class of the mesh with given competences. */
+    = TElementCompetencePack::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. */
@@ -102,7 +113,6 @@ class mesh: public TMeshCompetences<mesh<TCompetencePack, TMeshCompetences...>>.
    */
   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 ();
   }
@@ -381,30 +391,17 @@ class mesh: public TMeshCompetences<mesh<TCompetencePack, TMeshCompetences...>>.
     update_elements ();
   }
 
-  // --- Methods to set and get user and element data and exchange data between processes. ---
-  // TODO document
-
+  // --- Methods to check for mesh competences. ---
   /** Function that checks if a competence for element data handling is given.
    * \return true if mesh has a data handler, false otherwise.
    */
   static constexpr bool
   has_element_data_handler_competence ()
   {
-    return (false || ... || element_data_handler_competence_defined<TMeshCompetences> ());
+    return requires (SelfType& mesh) { mesh.get_element_data (); };
   }
 
  private:
-  /** Helper function to check if class T implements the function get_element_data.
-   * \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
-  element_data_handler_competence_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.get_element_data (); };
-  }
-
   /** 
    * Update the storage of the mesh elements according to the current forest. 
    */
diff --git a/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
index 66a94131e0..8e11016f3a 100644
--- a/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
+++ b/test/mesh_handle/t8_gtest_adapt_partition_balance.cxx
@@ -51,9 +51,6 @@ struct dummy_user_data
   double coarsen_if_outside_radius; /**< If an element's center is larger this value, we coarsen its family. */
 };
 
-template <typename TUnderlying>
-using data_handler = t8_mesh_handle::handle_element_data<TUnderlying, dummy_user_data>;
-
 /** Callback function for the mesh handle to decide for refining or coarsening of (a family of) elements.
  * The function header fits the definition of \ref TMesh::adapt_callback_type_with_userdata.
  * \tparam TMeshClass    The mesh handle class.
@@ -115,8 +112,9 @@ TEST (t8_gtest_handle_adapt, compare_adapt_with_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);
-  using mesh_class
-    = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<t8_mesh_handle::access_element_data>, data_handler>;
+  using mesh_class = t8_mesh_handle::mesh<
+    t8_mesh_handle::element_competence_pack<t8_mesh_handle::access_element_data>,
+    t8_mesh_handle::mesh_competence_pack<t8_mesh_handle::element_data_competence<dummy_user_data>::template type>>;
   mesh_class mesh_handle = mesh_class (forest);
   struct dummy_user_data user_data = {
     t8_3D_point ({ 0.5, 0.5, 1 }), /**< Midpoints of the sphere. */
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index c84a44314b..d25492ca03 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -87,7 +87,7 @@ struct cache_centroid_overwrite: public t8_mesh_handle::cache_centroid<TUnderlyi
 TEST (t8_gtest_cache_competence, cache_volume)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_volume_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_volume_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_volume_cache ());
@@ -114,7 +114,7 @@ TEST (t8_gtest_cache_competence, cache_volume)
 TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_vertex_coordinates_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_vertex_coordinates_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_vertex_cache ());
@@ -147,7 +147,7 @@ TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 TEST (t8_gtest_cache_competence, cache_centroid)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_centroid_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_centroid_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_centroid_cache ());
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 c8f5a47e6e..570e5fad2d 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -46,7 +46,7 @@ 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);
 
-  const t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>> mesh (forest);
+  const t8_mesh_handle::mesh<> 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);
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index a626df8732..6502ff67b2 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -83,7 +83,7 @@ TEST (t8_gtest_custom_competence, custom_competence)
 {
   const int level = 1;
   // Check mesh with custom defined competence.
-  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
+  using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<dummy_get_level>>;
   const auto mesh
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
@@ -93,7 +93,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
   }
 
   // Test with two custom competences and a predefined competence.
-  using competences = t8_mesh_handle::competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
+  using competences
+    = t8_mesh_handle::element_competence_pack<dummy_get_level, dummy_trivial, t8_mesh_handle::cache_centroid>;
   using mesh_class = t8_mesh_handle::mesh<competences>;
   auto mesh_more_competences
     = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 8287fff4c0..7ef342ac57 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -59,7 +59,7 @@ struct t8_mesh_ghost_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
 /** Check the implementation of ghosts and all functions accessible by ghosts. */
 TEST_P (t8_mesh_ghost_test, check_ghosts)
 {
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>>;
+  using mesh_class = t8_mesh_handle::mesh<>;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             false, false);
 
@@ -103,7 +103,7 @@ TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
   t8_forest_t forest = t8_forest_new_uniform (t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0), scheme,
                                               level, 1, sc_MPI_COMM_WORLD);
 
-  const t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>> mesh (forest);
+  const t8_mesh_handle::mesh<> 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.
@@ -178,7 +178,7 @@ 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<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::element_competence_pack<cache_neighbors_overwrite>>;
   using element_class = typename mesh_class::element_class;
   const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD,
                                                                                   true, true, false);
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 82a0ab98f2..d3d97e3594 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -43,8 +43,6 @@ struct data_per_element
   int level;
   double volume;
 };
-template <typename TUnderlying>
-using data_handler = t8_mesh_handle::handle_element_data<TUnderlying, data_per_element>;
 
 /** Check that element data can be set for the handle and 
  * that the getter has exchanged data for the ghosts.
@@ -53,8 +51,9 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
   const int level = 2;
 
-  using mesh_class
-    = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<t8_mesh_handle::access_element_data>, data_handler>;
+  using mesh_class = t8_mesh_handle::mesh<
+    t8_mesh_handle::element_competence_pack<t8_mesh_handle::access_element_data>,
+    t8_mesh_handle::mesh_competence_pack<t8_mesh_handle::element_data_competence<data_per_element>::template type>>;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, false,
                                                                                    true, false);
 
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index ecd48feb55..a2618b10b0 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -52,7 +52,7 @@ struct t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t
 /** Test some default functionality and the iterator of \ref t8_mesh_handle::mesh. */
 TEST_P (t8_mesh_handle_test, test_iterator)
 {
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>>;
+  using mesh_class = t8_mesh_handle::mesh<>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             true, false);
@@ -88,7 +88,8 @@ TEST_P (t8_mesh_handle_test, test_iterator)
 TEST_P (t8_mesh_handle_test, test_competences)
 {
   // --- Version with cached vertex coordinates. ---
-  using competence_vertex_coordinates = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_vertex_coordinates>;
+  using competence_vertex_coordinates
+    = t8_mesh_handle::element_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;
   auto mesh_vertex = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_vertex> (
@@ -127,7 +128,7 @@ TEST_P (t8_mesh_handle_test, test_competences)
   }
 
   // --- Version with cached centroid variable. ---
-  using competence_centroid = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_centroid>;
+  using competence_centroid = t8_mesh_handle::element_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;
   auto mesh_centroid = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_centroid> (
@@ -156,7 +157,7 @@ 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_competences>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_element_competences>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
                                                                             true, false);

From 0f3208d38ac22ed4fc047ef0b49fc315a3d2f335 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Fri, 20 Feb 2026 11:39:43 +0100
Subject: [PATCH 3/6] change location of element competence

---
 mesh_handle/competences.hxx  | 51 +++----------------
 mesh_handle/data_handler.hxx | 97 ++++++++++++++++++++++++++++--------
 mesh_handle/mesh.hxx         |  4 +-
 3 files changed, 86 insertions(+), 66 deletions(-)

diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index 2649c4571e..cbbd52ef16 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -25,15 +25,20 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
  * Especially, competences to cache functionalities of elements instead of calculating them each time a function
  * is called are provided.
  *
+ * \note for developers or users that want to provide their own competence:
  * All competences have the same inheritance pattern: 
  * We use the CRTP pattern as we may need to access members of the derived classes like 
  * \ref t8_mesh_handle::element. 
- * The t8_crtp_basic is used for convenience/clear code (avoid to type a static cast explicitly each time 
+ * The \ref t8_crtp_operator is used for convenience/clear code (avoid to type a static cast explicitly each time 
  * we need functionality of TUnderlying).
  * Especially for the competences to cache functionality, the access of members is not necessary, 
  * such that it is not obvious why we use the crtp. For competences that extend the functionality of the element, 
  * this is required. 
  * We use it for all competences for consistency and compatibility with \ref t8_mesh_handle::element.
+ *
+ * We use \ref t8_crtp_operator instead of \ref t8_crtp_basic to circumvent diamond shaped inheritance pattern in 
+ * the case that multiple competences are used together. 
+ * The distinction of the classes is made by the second template parameter of \ref t8_crtp_operator.
  */
 
 #pragma once
@@ -56,49 +61,7 @@ namespace t8_mesh_handle
  * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
  */
 template <typename TUnderlying>
-struct access_element_data: public t8_crtp_basic<TUnderlying>
-{
- public:
-  // --- 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 TMeshClass::ElementDataType.
-   */
-  const auto &
-  get_element_data () const
-  {
-    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
-    const t8_locidx_t handle_id = this->underlying ().get_element_handle_id ();
-    T8_ASSERTF (static_cast<size_t> (handle_id) < this->underlying ().m_mesh->m_element_data.size (),
-                "Element data not set.\n");
-    return this->underlying ().m_mesh->m_element_data[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.
-   */
-  void
-  set_element_data (auto element_data)
-  {
-    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
-    SC_CHECK_ABORT (!this->underlying ().is_ghost_element (), "Element data cannot be set for ghost elements.\n");
-    // Resize for the case that no data vector has been set previously.
-    this->underlying ().m_mesh->m_element_data.reserve (this->underlying ().m_mesh->get_num_local_elements ()
-                                                        + this->underlying ().m_mesh->get_num_ghosts ());
-    this->underlying ().m_mesh->m_element_data.resize (this->underlying ().m_mesh->get_num_local_elements ());
-    this->underlying ().m_mesh->m_element_data[this->underlying ().get_element_handle_id ()] = std::move (element_data);
-  }
-};
-
-/**
- * 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_basic<TUnderlying>
+struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
 {
  public:
   /**
diff --git a/mesh_handle/data_handler.hxx b/mesh_handle/data_handler.hxx
index 9c26e7d573..f48ed11d03 100644
--- a/mesh_handle/data_handler.hxx
+++ b/mesh_handle/data_handler.hxx
@@ -22,40 +22,49 @@
 
 /** \file data_handler.hxx
  * Handler for the element data of a \ref t8_mesh_handle::mesh.
+ * The file defines a mesh and an element competence for element data handling.
+ * Use both competences together if you want to manage element data for the elements of the mesh and access it directly for each element.
  */
 #pragma once
 
+#include <t8.h>
+#include <t8_forest/t8_forest_general.h>
 #include <t8_types/t8_crtp.hxx>
 #include <type_traits>
 #include <vector>
 
 namespace t8_mesh_handle
 {
-
-/** Concept to ensure that a type is MPI safe.
- */
+// --- Mesh competence for element data management. ---
+/** Concept to ensure that a type is MPI safe. */
 template <typename TType>
 concept T8MPISafeType
   = std::is_void_v<TType> || (std::is_trivially_copyable_v<TType> && std::is_standard_layout_v<TType>);
 
-/**
- * Handler for the element data of a \ref mesh.
+/** Handler for the element data of a \ref mesh.
+ * Use this competence if you want to manage element data for the elements of the mesh.
+ * Use the helper \ref element_data_competence to get this competence with the correct template parameters form for the mesh. 
+ * If you want to access the data not only in vector form but also directly for each element, 
+ * you can combine this competence with the \ref access_element_data competence.
+ * In summary you can use the competences like this: 
+ *    mesh<element_competence_pack<access_element_data>,
+ *         mesh_competence_pack<element_data_competence<YourElementDataType>::template type>>;
+ *
+ * \tparam TUnderlying Use the \ref mesh class here.
  * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
  *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
  */
 template <typename TUnderlying, T8MPISafeType TElementDataType>
 class handle_element_data: public t8_crtp_basic<TUnderlying> {
  public:
-  using ElementDataType = TElementDataType; /**< Make Type of the element data accessible. */
-                                            /** 
-   * Set the element data vector. The vector should have the length of num_local_elements.
+  using ElementDataType = TElementDataType; /**< Make Type of the element data publicly accessible. */
+
+  /** 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 TElementDataType 
    *            for each local mesh element (excluding ghosts).
    */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
   void
-  set_element_data (std::vector<ElementDataType> element_data)
+  set_element_data (std::vector<TElementDataType> element_data)
   {
     const auto num_local_elements = this->underlying ().get_num_local_elements ();
     const auto num_ghosts = this->underlying ().get_num_ghosts ();
@@ -65,22 +74,18 @@ class handle_element_data: public t8_crtp_basic<TUnderlying> {
     m_element_data.resize (num_local_elements);
   }
 
-  /** 
-   * Get the element data vector.
+  /** 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 TElementDataType.
    */
-  template <typename ElementDataType = TElementDataType,
-            typename = std::enable_if_t<!std::is_void<ElementDataType>::value>>
-  const std::vector<ElementDataType>&
+  const std::vector<TElementDataType>&
   get_element_data () const
   {
     return m_element_data;
   }
 
-  /** 
-  * Exchange the element data for ghost elements between processes.
+  /** 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.
   */
   void
@@ -104,11 +109,63 @@ class handle_element_data: public t8_crtp_basic<TUnderlying> {
   std::vector<TElementDataType> m_element_data; /**< Vector storing the (local) element data. */
 };
 
+/** Wrapper for \ref handle_element_data to hide TUnderlying and provide the form needed to pass it as a mesh competence.
+ * Use mesh_competence_pack<element_data_competence<YourElementDataType>::template type> 
+ * to get this competence with the correct template parameter form for the mesh.
+ * \tparam TElementDataType The element data type you want to use for each element of the mesh. 
+ *         The data type has to be MPI safe as the data for ghost elements will be exchanged via MPI.
+ */
 template <T8MPISafeType TElementDataType>
 struct element_data_competence
 {
-  template <typename TMesh>
-  using type = handle_element_data<TMesh, TElementDataType>;
+  /** Type to provide the form needed for the mesh competence pack. 
+  * \tparam TUnderlying Use the \ref mesh class here.
+  */
+  template <typename TUnderlying>
+  using type = handle_element_data<TUnderlying, TElementDataType>;
+};
+
+// --- Element competence for element data management. ---
+/** Element competence to enable that element data can be accessed directly for each element of the mesh.
+ * \note This competence requires that the mesh has the \ref handle_element_data competence to manage the
+ *   element data vector and exchange ghost data.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct access_element_data: public t8_crtp_basic<TUnderlying>
+{
+ public:
+  // --- 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 TMeshClass::ElementDataType.
+   */
+  const auto&
+  get_element_data () const
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    const t8_locidx_t handle_id = this->underlying ().get_element_handle_id ();
+    T8_ASSERTF (static_cast<size_t> (handle_id) < this->underlying ().m_mesh->m_element_data.size (),
+                "Element data not set.\n");
+    return this->underlying ().m_mesh->m_element_data[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 of Type TMeshClass::ElementDataType.
+   */
+  void
+  set_element_data (auto element_data)
+  {
+    T8_ASSERT (this->underlying ().m_mesh->has_element_data_handler_competence ());
+    SC_CHECK_ABORT (!this->underlying ().is_ghost_element (), "Element data cannot be set for ghost elements.\n");
+    // Resize for the case that no data vector has been set previously.
+    this->underlying ().m_mesh->m_element_data.reserve (this->underlying ().m_mesh->get_num_local_elements ()
+                                                        + this->underlying ().m_mesh->get_num_ghosts ());
+    this->underlying ().m_mesh->m_element_data.resize (this->underlying ().m_mesh->get_num_local_elements ());
+    this->underlying ().m_mesh->m_element_data[this->underlying ().get_element_handle_id ()] = std::move (element_data);
+  }
 };
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 79cbd3f9c0..da77c15816 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -31,8 +31,8 @@
 #include "competence_pack.hxx"
 #include "adapt.hxx"
 #include "competences.hxx"
-#include "t8_forest/t8_forest_balance.h"
-#include "t8_forest/t8_forest_types.h"
+#include <t8_forest/t8_forest_balance.h>
+#include <t8_forest/t8_forest_types.h>
 #include <t8_forest/t8_forest_general.h>
 #include <t8_forest/t8_forest_ghost.h>
 #include <vector>

From de7c92c045c9603b8cf84fbc398669e4eebb87c2 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Fri, 20 Feb 2026 11:44:44 +0100
Subject: [PATCH 4/6] adapt README

---
 mesh_handle/README.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/mesh_handle/README.md b/mesh_handle/README.md
index 570209c131..af68775144 100644
--- a/mesh_handle/README.md
+++ b/mesh_handle/README.md
@@ -8,6 +8,8 @@ If you want to use the handle, note that is has its own library. Turn the option
 
 The folder's most important files are: 
 - The [mesh.hxx](mesh.hxx) defines the mesh of the handle. This is the central file of the mesh handle. 
+- The [constructor_wrappers.hxx](constructor_wrappers.hxx) allows to define a mesh handle using a cmesh instead of a forest and provides a very small number of examples where the user needs no cmesh.
 - The [element.hxx](element.hxx) defines the elements (mesh or ghost elements) of the mesh handle.
 - The [competences.hxx](competences.hxx) defines additional competences/functionality of an element to access additional data.
-- The [constructor_wrappers.hxx](constructor_wrappers.hxx) allows to define a mesh handle using a cmesh instead of a forest and provides a very small number of examples where the user needs no cmesh.
\ No newline at end of file
+- The [competence_pack.hxx](competence_pack.hxx) is needed to pack element or mesh competences to pass it as template parameter to the mesh.
+- The [data_handler.hxx](data_handler.hxx) provides competences to work with element data.
\ No newline at end of file

From 7ec21ff604943ecd12c66e86548a1eae50304710 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Fri, 20 Feb 2026 13:18:17 +0100
Subject: [PATCH 5/6] fix doxygen and clang

---
 mesh_handle/competences.hxx               | 4 ----
 mesh_handle/data_handler.hxx              | 2 +-
 mesh_handle/element.hxx                   | 2 +-
 mesh_handle/mesh.hxx                      | 6 +++---
 test/mesh_handle/t8_gtest_handle_data.cxx | 1 -
 5 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index c702ac6d40..9782149022 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -44,10 +44,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #pragma once
 
 #include <t8.h>
-#include "element.hxx"
-#include "mesh.hxx"
-#include "data_handler.hxx"
-#include <t8_types/t8_crtp.hxx>
 #include <t8_types/t8_operators.hxx>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
diff --git a/mesh_handle/data_handler.hxx b/mesh_handle/data_handler.hxx
index f48ed11d03..7c98c19164 100644
--- a/mesh_handle/data_handler.hxx
+++ b/mesh_handle/data_handler.hxx
@@ -137,7 +137,7 @@ struct access_element_data: public t8_crtp_basic<TUnderlying>
  public:
   // --- 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.
+   * For ghost elements ensure that \ref handle_element_data::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 TMeshClass::ElementDataType.
    */
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index 571c36f774..49123e3c4f 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -27,7 +27,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #pragma once
 
 #include <t8.h>
-#include "competences.hxx"
+#include "data_handler.hxx"
 #include <t8_element.h>
 #include <t8_eclass.h>
 #include <t8_forest/t8_forest_general.h>
diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 3bce888f09..08661b2087 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -30,7 +30,7 @@
 #include "element.hxx"
 #include "competence_pack.hxx"
 #include "adapt.hxx"
-#include "competences.hxx"
+#include "data_handler.hxx"
 #include <t8_forest/t8_forest_balance.h>
 #include <t8_forest/t8_forest_types.h>
 #include <t8_forest/t8_forest_general.h>
@@ -57,7 +57,7 @@ concept MeshCompetencePack = requires { typename TType::is_mesh_competence_pack;
  *         \see element for more details on the choice of the template parameter.   
  *         \note Please pack your competences using the \ref element_competence_pack class.
  * \tparam TMeshCompetences The competences you want to add to the default functionality of the mesh.  
- *         \note Please pack your competences using the \ref mesh_competence_pack class.
+ *         \note Please pack your competences using the \ref t8_mesh_handle::mesh_competence_pack class.
  *         One of the most important competences to add is \ref handle_element_data.
  */
 template <ElementCompetencePack TElementCompetencePack = element_competence_pack<>,
@@ -66,7 +66,7 @@ class mesh: public TMeshCompetencePack::template apply<mesh<TElementCompetencePa
  public:
   using SelfType = mesh<TElementCompetencePack, TMeshCompetencePack>; /**< Type of the current class. */
   using element_class
-    = TElementCompetencePack::template apply<SelfType,
+    = typename TElementCompetencePack::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 =
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index f54984dfa2..ba6c7abe9b 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -30,7 +30,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <mesh_handle/competences.hxx>
 #include <mesh_handle/constructor_wrappers.hxx>
 #include <mesh_handle/data_handler.hxx>
 #include <t8_forest/t8_forest_general.h>

From ee1f913b6e6911d32bb569390da745bfc0fec934 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Fri, 20 Feb 2026 14:05:58 +0100
Subject: [PATCH 6/6] indent

---
 mesh_handle/mesh.hxx | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/mesh_handle/mesh.hxx b/mesh_handle/mesh.hxx
index 08661b2087..463a0c9e24 100644
--- a/mesh_handle/mesh.hxx
+++ b/mesh_handle/mesh.hxx
@@ -65,9 +65,8 @@ template <ElementCompetencePack TElementCompetencePack = element_competence_pack
 class mesh: public TMeshCompetencePack::template apply<mesh<TElementCompetencePack, TMeshCompetencePack>> {
  public:
   using SelfType = mesh<TElementCompetencePack, TMeshCompetencePack>; /**< Type of the current class. */
-  using element_class
-    = typename TElementCompetencePack::template apply<SelfType,
-                                             element>; /**< The element class of the mesh with given competences. */
+  using element_class = typename TElementCompetencePack::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. */