From e96805874f86326415c051ed89fb6812be5ed74f Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 5 Mar 2026 09:34:33 +0100
Subject: [PATCH 1/5] ideas with union

---
 mesh_handle/competence_pack.hxx               |  13 ++
 .../internal/competence_pack_union.hxx        | 144 ++++++++++++++++++
 .../mesh_handle/t8_gtest_cache_competence.cxx |   3 +-
 3 files changed, 159 insertions(+), 1 deletion(-)
 create mode 100644 mesh_handle/internal/competence_pack_union.hxx

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index f93c7219a1..82fa50212c 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -27,6 +27,7 @@
 #pragma once
 
 #include "competences.hxx"
+#include "internal/competence_pack_union.hxx"
 namespace t8_mesh_handle
 {
 /** Class to pack different competences into one template parameter for the \ref mesh class.
@@ -53,4 +54,16 @@ using all_cache_competences
 using cache_face_competences
   = competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
 
+/**
+ * \brief Convenience alias for \ref combine_competence_packs.
+ *
+ * Provides direct access to the resulting competence pack type.
+ *
+ * \tparam P1 First competence pack.
+ * \tparam P2 Second competence pack.
+ */
+template <typename P1, typename P2>
+using union_competence_packs =
+  typename combine_competence_packs<P1, P2>::type;
+
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/internal/competence_pack_union.hxx b/mesh_handle/internal/competence_pack_union.hxx
new file mode 100644
index 0000000000..9de4802f12
--- /dev/null
+++ b/mesh_handle/internal/competence_pack_union.hxx
@@ -0,0 +1,144 @@
+/*
+  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_union.hxx 
+ * Define union operator for two competence packs. The result of the union of two competence packs is a competence pack
+ * that contains all competences of both packs, but each competence at most once.
+ */
+
+ #pragma once
+ #include <type_traits>
+
+ namespace t8_mesh_handle
+{
+/** Forward definition of the competence_pack class.
+ */
+template <template <typename> class... TCompetence>
+struct competence_pack;
+
+/** Compute the set-union of two \ref competence_pack types.
+ * 
+ * \ref competence_pack types and produces a new pack that contains
+ * each competence at most once.
+ *
+ * Order of competences in the resulting pack is unspecified.
+ *
+ * \tparam P1 First competence pack.
+ * \tparam P2 Second competence pack.
+ */
+template <typename P1, typename P2>
+struct combine_competence_packs;
+
+
+/**
+ * \brief Specialization of \ref combine_competence_packs for two competence_pack types.
+ *
+ * Extracts the template-template parameters from both packs and
+ * builds a new \ref competence_pack containing the unique union
+ * of all competences.
+ *
+ * \tparam C1... Competences of the first pack.
+ * \tparam C2... Competences of the second pack.
+ */
+template <
+    template <typename> class... C1,
+    template <typename> class... C2>
+struct combine_competence_packs<
+    competence_pack<C1...>,
+    competence_pack<C2...>>
+{
+private:
+
+  /**
+   * \brief Helper metafunction to accumulate unique competences.
+   *
+   * \tparam Acc... Currently accumulated competences.
+   */
+  template <template <typename> class... Acc>
+  struct fold
+  {
+    /**
+     * \brief Add a competence to the accumulator if not already present.
+     *
+     * If \p T is already contained in \p Acc..., the accumulator
+     * remains unchanged. Otherwise, \p T is appended.
+     *
+     * \tparam T Competence to add.
+     */
+    template <template <typename> class T>
+    using add =
+      std::conditional_t<
+        (std::is_same_v<T, Acc> || ...),
+        competence_pack<Acc...>,
+        competence_pack<Acc..., T>>;
+  };
+
+  /**
+   * \brief Recursive builder to fold over a list of competences.
+   *
+   * Starting from an initial pack, this recursively processes
+   * all competences and accumulates them uniquely.
+   *
+   * \tparam Pack Current accumulated pack.
+   * \tparam Rest... Remaining competences to process.
+   */
+  template <typename Pack, template <typename> class... Rest>
+  struct build;
+
+  /// \brief Termination case of the recursive build.
+  template <template <typename> class... Acc>
+  struct build<competence_pack<Acc...>>
+  {
+    using type = competence_pack<Acc...>;
+  };
+
+  /// \brief Recursive case: process one competence and continue.
+  template <
+      template <typename> class... Acc,
+      template <typename> class T,
+      template <typename> class... Rest>
+  struct build<competence_pack<Acc...>, T, Rest...>
+  {
+    using next =
+      std::conditional_t<
+        (std::is_same_v<T, Acc> || ...),
+        competence_pack<Acc...>,
+        competence_pack<Acc..., T>>;
+
+    using type = typename build<next, Rest...>::type;
+  };
+
+public:
+
+  /**
+   * \brief Resulting competence pack containing the unique union.
+   */
+  using type =
+    typename build<
+      competence_pack<>,
+      C1..., C2...>::type;
+};
+
+
+
+
+} // namespace t8_mesh_handle
\ No newline at end of file
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 49d1338401..37b64ac88b 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -172,10 +172,11 @@ TEST (t8_gtest_cache_competence, cache_volume)
 TEST (t8_gtest_cache_competence, cache_diameter)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_diameter_overwrite>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::union_competence_packs <t8_mesh_handle::competence_pack<cache_diameter_overwrite>,t8_mesh_handle::competence_pack<t8_mesh_handle::cache_volume>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());
+    EXPECT_TRUE (element_class::has_volume_cache ());
 
   double unrealistic_diameter = -3000.0;
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {

From 84d4fe4f3734b75c2d3a1a80c6d4d0150474c65e Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 5 Mar 2026 09:34:52 +0100
Subject: [PATCH 2/5] indent

---
 mesh_handle/competence_pack.hxx               |  3 +-
 .../internal/competence_pack_union.hxx        | 50 ++++++-------------
 .../mesh_handle/t8_gtest_cache_competence.cxx |  7 ++-
 3 files changed, 20 insertions(+), 40 deletions(-)

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 82fa50212c..ae1db78cbf 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -63,7 +63,6 @@ using cache_face_competences
  * \tparam P2 Second competence pack.
  */
 template <typename P1, typename P2>
-using union_competence_packs =
-  typename combine_competence_packs<P1, P2>::type;
+using union_competence_packs = typename combine_competence_packs<P1, P2>::type;
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/internal/competence_pack_union.hxx b/mesh_handle/internal/competence_pack_union.hxx
index 9de4802f12..de61d525af 100644
--- a/mesh_handle/internal/competence_pack_union.hxx
+++ b/mesh_handle/internal/competence_pack_union.hxx
@@ -25,10 +25,10 @@
  * that contains all competences of both packs, but each competence at most once.
  */
 
- #pragma once
- #include <type_traits>
+#pragma once
+#include <type_traits>
 
- namespace t8_mesh_handle
+namespace t8_mesh_handle
 {
 /** Forward definition of the competence_pack class.
  */
@@ -48,7 +48,6 @@ struct competence_pack;
 template <typename P1, typename P2>
 struct combine_competence_packs;
 
-
 /**
  * \brief Specialization of \ref combine_competence_packs for two competence_pack types.
  *
@@ -59,15 +58,10 @@ struct combine_competence_packs;
  * \tparam C1... Competences of the first pack.
  * \tparam C2... Competences of the second pack.
  */
-template <
-    template <typename> class... C1,
-    template <typename> class... C2>
-struct combine_competence_packs<
-    competence_pack<C1...>,
-    competence_pack<C2...>>
+template <template <typename> class... C1, template <typename> class... C2>
+struct combine_competence_packs<competence_pack<C1...>, competence_pack<C2...>>
 {
-private:
-
+ private:
   /**
    * \brief Helper metafunction to accumulate unique competences.
    *
@@ -85,11 +79,8 @@ private:
      * \tparam T Competence to add.
      */
     template <template <typename> class T>
-    using add =
-      std::conditional_t<
-        (std::is_same_v<T, Acc> || ...),
-        competence_pack<Acc...>,
-        competence_pack<Acc..., T>>;
+    using add
+      = std::conditional_t<(std::is_same_v<T, Acc> || ...), competence_pack<Acc...>, competence_pack<Acc..., T>>;
   };
 
   /**
@@ -112,33 +103,20 @@ private:
   };
 
   /// \brief Recursive case: process one competence and continue.
-  template <
-      template <typename> class... Acc,
-      template <typename> class T,
-      template <typename> class... Rest>
+  template <template <typename> class... Acc, template <typename> class T, template <typename> class... Rest>
   struct build<competence_pack<Acc...>, T, Rest...>
   {
-    using next =
-      std::conditional_t<
-        (std::is_same_v<T, Acc> || ...),
-        competence_pack<Acc...>,
-        competence_pack<Acc..., T>>;
+    using next
+      = std::conditional_t<(std::is_same_v<T, Acc> || ...), competence_pack<Acc...>, competence_pack<Acc..., T>>;
 
     using type = typename build<next, Rest...>::type;
   };
 
-public:
-
+ public:
   /**
    * \brief Resulting competence pack containing the unique union.
    */
-  using type =
-    typename build<
-      competence_pack<>,
-      C1..., C2...>::type;
+  using type = typename build<competence_pack<>, C1..., C2...>::type;
 };
 
-
-
-
-} // namespace t8_mesh_handle
\ No newline at end of file
+}  // namespace t8_mesh_handle
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 37b64ac88b..a7ba1c7325 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -172,11 +172,14 @@ TEST (t8_gtest_cache_competence, cache_volume)
 TEST (t8_gtest_cache_competence, cache_diameter)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::union_competence_packs <t8_mesh_handle::competence_pack<cache_diameter_overwrite>,t8_mesh_handle::competence_pack<t8_mesh_handle::cache_volume>>;
+  using mesh_class
+    = t8_mesh_handle::mesh
+      < t8_mesh_handle::union_competence_packs<t8_mesh_handle::competence_pack<cache_diameter_overwrite>,
+                                               t8_mesh_handle::competence_pack<t8_mesh_handle::cache_volume>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());
-    EXPECT_TRUE (element_class::has_volume_cache ());
+  EXPECT_TRUE (element_class::has_volume_cache ());
 
   double unrealistic_diameter = -3000.0;
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {

From 22239807cc8aa509545f0528d3c46ada0bd0b9db Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 5 Mar 2026 12:42:09 +0100
Subject: [PATCH 3/5] first working solution

---
 mesh_handle/competence_pack.hxx               | 113 ++++++++++++++--
 .../internal/competence_pack_union.hxx        | 122 ------------------
 .../mesh_handle/t8_gtest_cache_competence.cxx |   7 +-
 3 files changed, 108 insertions(+), 134 deletions(-)
 delete mode 100644 mesh_handle/internal/competence_pack_union.hxx

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index ae1db78cbf..0e159d2ec8 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -27,7 +27,8 @@
 #pragma once
 
 #include "competences.hxx"
-#include "internal/competence_pack_union.hxx"
+//#include "internal/competence_pack_union.hxx"
+#include <type_traits>
 namespace t8_mesh_handle
 {
 /** Class to pack different competences into one template parameter for the \ref mesh class.
@@ -54,15 +55,111 @@ using all_cache_competences
 using cache_face_competences
   = competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
 
+/** Wraps a template-template parameter into a type for comparison.
+ * This allows safe comparison of template templates using std::is_same_v.
+ * \tparam TType Template-template parameter to wrap.
+ */
+template <template <class> class TType>
+struct tag
+{
+};
+
+/** Insert a competence TCompetence into an existing pack with competences TUnionCompetences if not already present.
+ * A new competence_pack is produced.
+ * \tparam TCompetence       Template-template competence to insert.
+ * \tparam TUnionCompetences Existing competences in the pack.
+ */
+template <template <class> class TCompetence, template <class> class... TUnionCompetences>
+using insert_unique
+  = std::conditional_t<(std::is_same_v<tag<TCompetence>, tag<TUnionCompetences>> || ...),
+                       competence_pack<TUnionCompetences...>, competence_pack<TUnionCompetences..., TCompetence>>;
+
+/** Fold operation to accumulate unique competences.
+ * Recursively inserts all TCompetences into the competence pack.
+ * \tparam TCompetencePack Current accumulated competence_pack.
+ * \tparam TCompetences Competences to process.
+ */
+template <typename TCompetencePack, template <class> class... TCompetences>
+struct fold_unique;
+
+/** Termination case: no more competences to process.
+ * Specialization for the case when the competence pack is already fully processed and 
+ * no more competences are left to insert.
+ * \tparam TUnionCompetences Existing competences in the pack.
+ */
+template <template <class> class... TUnionCompetences>
+struct fold_unique<competence_pack<TUnionCompetences...>>
+{
+  /** Final competence pack with all competences inserted. */
+  using type = competence_pack<TUnionCompetences...>;
+};
+
+/** Recursive case: insert the first competence uniquely, then process the rest recursively until 
+ * termination (no competences left). 
+ * Specialization for the case when there are still at least one competence left to process.
+ * \tparam TUnionCompetences Existing competences in the pack.
+ * \tparam TCompetence Competence to insert in this recursion cycle.
+ * \tparam TOtherCompetences Remaining competences to process in the next recursion cycles.
+ */
+template <template <class> class... TUnionCompetences, template <class> class TCompetence,
+          template <class> class... TOtherCompetences>
+struct fold_unique<competence_pack<TUnionCompetences...>, TCompetence, TOtherCompetences...>
+{ /** Competence pack after inserting the first competence TCompetence uniquely. */
+  using type = typename fold_unique<insert_unique<TCompetence, TUnionCompetences...>, TOtherCompetences...>::type;
+};
+
+/** Compute the unique union of the competences of two \ref competence_pack s.
+ * This produces a new \ref competence_pack containing all competences with duplicates removed.
+ * \tparam TPack1 First competence pack.
+ * \tparam TPack2 Second competence pack.
+ */
+template <typename TPack1, typename TPack2>
+struct union_competence_packs;
+
+/** Specialization for two \ref competence_pack types. 
+ * This is necessary because this way, we can access the competences directly. 
+ * This specialization of the class above is used if both template parameters are of type \ref competence_pack.
+ * \tparam TCompetences1 Competences of the first competence pack.
+ * \tparam TCompetences2 Competences of the second competence pack. 
+ */
+template <template <class> class... TCompetences1, template <class> class... TCompetences2>
+struct union_competence_packs<competence_pack<TCompetences1...>, competence_pack<TCompetences2...>>
+{
+  /** The resulting competence_pack type with all competences from both packs, but without duplicates.
+   * The type is computed by folding the unique insertion of all competences from both packs into an 
+   * initially empty pack.
+   */
+  using type = typename fold_unique<competence_pack<>, TCompetences1..., TCompetences2...>::type;
+};
+
+/** Convenience alias for union_competence_packs.
+ * Provides direct access to the resulting competence_pack type.
+ * \tparam TPack1 First competence pack.
+ * \tparam TPack2 Second competence pack.
+ */
+template <typename TPack1, typename TPack2>
+using union_competence_packs_t_impl = typename union_competence_packs<TPack1, TPack2>::type;
+
 /**
- * \brief Convenience alias for \ref combine_competence_packs.
+ * Recursive struct for variadic union of competence packs.
  *
- * Provides direct access to the resulting competence pack type.
- *
- * \tparam P1 First competence pack.
- * \tparam P2 Second competence pack.
+ * Uses \ref union_competence_packs_t_impl for pairwise combination.
  */
-template <typename P1, typename P2>
-using union_competence_packs = typename combine_competence_packs<P1, P2>::type;
+template <typename TPack, typename... TPacks>
+struct union_competence_packs_recursive
+{
+  using type = union_competence_packs_t_impl<TPack, typename union_competence_packs_recursive<TPacks...>::type>;
+};
+
+/** Base case: only one pack left */
+template <typename TPack>
+struct union_competence_packs_recursive<TPack>
+{
+  using type = TPack;
+};
+
+/** Variadic alias for convenience */
+template <typename... TPacks>
+using union_competence_packs_t = typename union_competence_packs_recursive<TPacks...>::type;
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/internal/competence_pack_union.hxx b/mesh_handle/internal/competence_pack_union.hxx
deleted file mode 100644
index de61d525af..0000000000
--- a/mesh_handle/internal/competence_pack_union.hxx
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
-  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_union.hxx 
- * Define union operator for two competence packs. The result of the union of two competence packs is a competence pack
- * that contains all competences of both packs, but each competence at most once.
- */
-
-#pragma once
-#include <type_traits>
-
-namespace t8_mesh_handle
-{
-/** Forward definition of the competence_pack class.
- */
-template <template <typename> class... TCompetence>
-struct competence_pack;
-
-/** Compute the set-union of two \ref competence_pack types.
- * 
- * \ref competence_pack types and produces a new pack that contains
- * each competence at most once.
- *
- * Order of competences in the resulting pack is unspecified.
- *
- * \tparam P1 First competence pack.
- * \tparam P2 Second competence pack.
- */
-template <typename P1, typename P2>
-struct combine_competence_packs;
-
-/**
- * \brief Specialization of \ref combine_competence_packs for two competence_pack types.
- *
- * Extracts the template-template parameters from both packs and
- * builds a new \ref competence_pack containing the unique union
- * of all competences.
- *
- * \tparam C1... Competences of the first pack.
- * \tparam C2... Competences of the second pack.
- */
-template <template <typename> class... C1, template <typename> class... C2>
-struct combine_competence_packs<competence_pack<C1...>, competence_pack<C2...>>
-{
- private:
-  /**
-   * \brief Helper metafunction to accumulate unique competences.
-   *
-   * \tparam Acc... Currently accumulated competences.
-   */
-  template <template <typename> class... Acc>
-  struct fold
-  {
-    /**
-     * \brief Add a competence to the accumulator if not already present.
-     *
-     * If \p T is already contained in \p Acc..., the accumulator
-     * remains unchanged. Otherwise, \p T is appended.
-     *
-     * \tparam T Competence to add.
-     */
-    template <template <typename> class T>
-    using add
-      = std::conditional_t<(std::is_same_v<T, Acc> || ...), competence_pack<Acc...>, competence_pack<Acc..., T>>;
-  };
-
-  /**
-   * \brief Recursive builder to fold over a list of competences.
-   *
-   * Starting from an initial pack, this recursively processes
-   * all competences and accumulates them uniquely.
-   *
-   * \tparam Pack Current accumulated pack.
-   * \tparam Rest... Remaining competences to process.
-   */
-  template <typename Pack, template <typename> class... Rest>
-  struct build;
-
-  /// \brief Termination case of the recursive build.
-  template <template <typename> class... Acc>
-  struct build<competence_pack<Acc...>>
-  {
-    using type = competence_pack<Acc...>;
-  };
-
-  /// \brief Recursive case: process one competence and continue.
-  template <template <typename> class... Acc, template <typename> class T, template <typename> class... Rest>
-  struct build<competence_pack<Acc...>, T, Rest...>
-  {
-    using next
-      = std::conditional_t<(std::is_same_v<T, Acc> || ...), competence_pack<Acc...>, competence_pack<Acc..., T>>;
-
-    using type = typename build<next, Rest...>::type;
-  };
-
- public:
-  /**
-   * \brief Resulting competence pack containing the unique union.
-   */
-  using type = typename build<competence_pack<>, C1..., C2...>::type;
-};
-
-}  // namespace t8_mesh_handle
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index a7ba1c7325..5e4f26cd21 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -172,10 +172,9 @@ TEST (t8_gtest_cache_competence, cache_volume)
 TEST (t8_gtest_cache_competence, cache_diameter)
 {
   const int level = 1;
-  using mesh_class
-    = t8_mesh_handle::mesh
-      < t8_mesh_handle::union_competence_packs<t8_mesh_handle::competence_pack<cache_diameter_overwrite>,
-                                               t8_mesh_handle::competence_pack<t8_mesh_handle::cache_volume>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::union_competence_packs_t<
+    t8_mesh_handle::competence_pack<cache_diameter_overwrite>,
+    t8_mesh_handle::competence_pack<t8_mesh_handle::cache_volume, cache_diameter_overwrite>>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());

From 37a24d47592c31e28ea3ea533601b8488311210b Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 5 Mar 2026 16:31:01 +0100
Subject: [PATCH 4/5] outsource union logic into its own internal folder

---
 mesh_handle/competence_pack.hxx               | 112 +------------
 .../internal/competence_pack_union.hxx        | 157 ++++++++++++++++++
 .../mesh_handle/t8_gtest_cache_competence.cxx |   5 +-
 test/mesh_handle/t8_gtest_mesh_handle.cxx     |  24 ++-
 4 files changed, 187 insertions(+), 111 deletions(-)
 create mode 100644 mesh_handle/internal/competence_pack_union.hxx

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 0e159d2ec8..a5eb09dcd6 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -27,8 +27,7 @@
 #pragma once
 
 #include "competences.hxx"
-//#include "internal/competence_pack_union.hxx"
-#include <type_traits>
+#include "internal/competence_pack_union.hxx"
 namespace t8_mesh_handle
 {
 /** Class to pack different competences into one template parameter for the \ref mesh class.
@@ -55,111 +54,12 @@ using all_cache_competences
 using cache_face_competences
   = competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
 
-/** Wraps a template-template parameter into a type for comparison.
- * This allows safe comparison of template templates using std::is_same_v.
- * \tparam TType Template-template parameter to wrap.
+/** Compute the unique union of the competences of several \ref competence_pack 's.
+ *  This produces a new \ref competence_pack containing all competences of the competence packs with duplicates removed.
+ * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
+ *         Each competence pack is expected to be of type \ref competence_pack.
  */
-template <template <class> class TType>
-struct tag
-{
-};
-
-/** Insert a competence TCompetence into an existing pack with competences TUnionCompetences if not already present.
- * A new competence_pack is produced.
- * \tparam TCompetence       Template-template competence to insert.
- * \tparam TUnionCompetences Existing competences in the pack.
- */
-template <template <class> class TCompetence, template <class> class... TUnionCompetences>
-using insert_unique
-  = std::conditional_t<(std::is_same_v<tag<TCompetence>, tag<TUnionCompetences>> || ...),
-                       competence_pack<TUnionCompetences...>, competence_pack<TUnionCompetences..., TCompetence>>;
-
-/** Fold operation to accumulate unique competences.
- * Recursively inserts all TCompetences into the competence pack.
- * \tparam TCompetencePack Current accumulated competence_pack.
- * \tparam TCompetences Competences to process.
- */
-template <typename TCompetencePack, template <class> class... TCompetences>
-struct fold_unique;
-
-/** Termination case: no more competences to process.
- * Specialization for the case when the competence pack is already fully processed and 
- * no more competences are left to insert.
- * \tparam TUnionCompetences Existing competences in the pack.
- */
-template <template <class> class... TUnionCompetences>
-struct fold_unique<competence_pack<TUnionCompetences...>>
-{
-  /** Final competence pack with all competences inserted. */
-  using type = competence_pack<TUnionCompetences...>;
-};
-
-/** Recursive case: insert the first competence uniquely, then process the rest recursively until 
- * termination (no competences left). 
- * Specialization for the case when there are still at least one competence left to process.
- * \tparam TUnionCompetences Existing competences in the pack.
- * \tparam TCompetence Competence to insert in this recursion cycle.
- * \tparam TOtherCompetences Remaining competences to process in the next recursion cycles.
- */
-template <template <class> class... TUnionCompetences, template <class> class TCompetence,
-          template <class> class... TOtherCompetences>
-struct fold_unique<competence_pack<TUnionCompetences...>, TCompetence, TOtherCompetences...>
-{ /** Competence pack after inserting the first competence TCompetence uniquely. */
-  using type = typename fold_unique<insert_unique<TCompetence, TUnionCompetences...>, TOtherCompetences...>::type;
-};
-
-/** Compute the unique union of the competences of two \ref competence_pack s.
- * This produces a new \ref competence_pack containing all competences with duplicates removed.
- * \tparam TPack1 First competence pack.
- * \tparam TPack2 Second competence pack.
- */
-template <typename TPack1, typename TPack2>
-struct union_competence_packs;
-
-/** Specialization for two \ref competence_pack types. 
- * This is necessary because this way, we can access the competences directly. 
- * This specialization of the class above is used if both template parameters are of type \ref competence_pack.
- * \tparam TCompetences1 Competences of the first competence pack.
- * \tparam TCompetences2 Competences of the second competence pack. 
- */
-template <template <class> class... TCompetences1, template <class> class... TCompetences2>
-struct union_competence_packs<competence_pack<TCompetences1...>, competence_pack<TCompetences2...>>
-{
-  /** The resulting competence_pack type with all competences from both packs, but without duplicates.
-   * The type is computed by folding the unique insertion of all competences from both packs into an 
-   * initially empty pack.
-   */
-  using type = typename fold_unique<competence_pack<>, TCompetences1..., TCompetences2...>::type;
-};
-
-/** Convenience alias for union_competence_packs.
- * Provides direct access to the resulting competence_pack type.
- * \tparam TPack1 First competence pack.
- * \tparam TPack2 Second competence pack.
- */
-template <typename TPack1, typename TPack2>
-using union_competence_packs_t_impl = typename union_competence_packs<TPack1, TPack2>::type;
-
-/**
- * Recursive struct for variadic union of competence packs.
- *
- * Uses \ref union_competence_packs_t_impl for pairwise combination.
- */
-template <typename TPack, typename... TPacks>
-struct union_competence_packs_recursive
-{
-  using type = union_competence_packs_t_impl<TPack, typename union_competence_packs_recursive<TPacks...>::type>;
-};
-
-/** Base case: only one pack left */
-template <typename TPack>
-struct union_competence_packs_recursive<TPack>
-{
-  using type = TPack;
-};
-
-/** Variadic alias for convenience */
 template <typename... TPacks>
-using union_competence_packs_t = typename union_competence_packs_recursive<TPacks...>::type;
+using union_competence_packs_type = typename detail::union_competence_packs<TPacks...>::type;
 
 }  // namespace t8_mesh_handle
diff --git a/mesh_handle/internal/competence_pack_union.hxx b/mesh_handle/internal/competence_pack_union.hxx
new file mode 100644
index 0000000000..a9a5db67eb
--- /dev/null
+++ b/mesh_handle/internal/competence_pack_union.hxx
@@ -0,0 +1,157 @@
+/*
+  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 competence_pack_union.hxx 
+ * Define the implementation of the unique union of competences of several \ref competence_pack 's.
+ * Users should use \ref union_competence_packs_type in \ref competence_pack.hxx.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace t8_mesh_handle
+{
+
+/** Forward declaration of the competence pack class.
+ * \tparam TCompetence The competences to be packed.
+ */
+template <template <typename> class... TCompetence>
+struct competence_pack;
+
+/** Namespace to hide detail from user. */
+namespace detail
+{
+
+// --- Unique insertion of one competence into a competence pack. ---
+/** Helper: Wraps a template-template parameter into a type for comparison.
+ * Necessary because our competences are templated on the underlying type.
+ * This allows safe comparison of template templates using std::is_same_v.
+ * \tparam TType Template-template parameter to wrap.
+ */
+template <template <class> class TType>
+struct tag
+{
+};
+
+/** Insert competence TCompetence into a pack with competences TUnionCompetences if not already present.
+ * A new competence_pack is produced.
+ * \tparam TCompetence       Competence to insert.
+ * \tparam TUnionCompetences Existing competences in the pack.
+ */
+template <template <class> class TCompetence, template <class> class... TUnionCompetences>
+using insert_unique
+  = std::conditional_t<(std::is_same_v<tag<TCompetence>, tag<TUnionCompetences>> || ...),
+                       competence_pack<TUnionCompetences...>, competence_pack<TUnionCompetences..., TCompetence>>;
+
+//--- Unique fold operation to fold competences into one competence pack without duplication. ---
+/** Fold operation to accumulate unique competences.
+ * Recursively inserts all TCompetences into the competence pack.
+ * \tparam TCompetencePack Current accumulated competence_pack.
+ * \tparam TCompetences Competences to process.
+ */
+template <typename TCompetencePack, template <class> class... TCompetences>
+struct fold_unique;
+
+/** Termination case: no more competences to process.
+ * Specialization for the case when the competence pack is already fully processed and 
+ * no more competences are left to insert.
+ * \tparam TUnionCompetences Existing competences in the pack.
+ */
+template <template <class> class... TUnionCompetences>
+struct fold_unique<competence_pack<TUnionCompetences...>>
+{
+  /** Final competence pack with all competences inserted. */
+  using type = competence_pack<TUnionCompetences...>;
+};
+
+/** Recursive case: insert the first competence uniquely, then process the rest recursively until 
+ * termination (no competences left). 
+ * Specialization for the case when there is still at least one competence left to process.
+ * \tparam TUnionCompetences Existing competences in the pack.
+ * \tparam TCompetence Competence to insert in this recursion cycle.
+ * \tparam TOtherCompetences Remaining competences to process in the next recursion cycles.
+ */
+template <template <class> class... TUnionCompetences, template <class> class TCompetence,
+          template <class> class... TOtherCompetences>
+struct fold_unique<competence_pack<TUnionCompetences...>, TCompetence, TOtherCompetences...>
+{
+  /** Competence pack after inserting the first competence TCompetence uniquely. */
+  using type = typename fold_unique<insert_unique<TCompetence, TUnionCompetences...>, TOtherCompetences...>::type;
+};
+
+//--- Unique union of two competence packs. ---
+/** Compute the unique union of the competences of two \ref competence_pack 's.
+ * This produces a new \ref competence_pack containing all competences with duplicates removed.
+ * \tparam TPack1 First competence pack.
+ * \tparam TPack2 Second competence pack.
+ */
+template <typename TPack1, typename TPack2>
+struct union_two_competence_packs;
+
+/** Specialization for two \ref competence_pack types. 
+ * This is necessary because this way, we can access the competences directly. 
+ * This specialization of the class above is used if both template parameters are of type \ref competence_pack.
+ * \tparam TCompetences1 Competences of the first competence pack.
+ * \tparam TCompetences2 Competences of the second competence pack. 
+ */
+template <template <class> class... TCompetences1, template <class> class... TCompetences2>
+struct union_two_competence_packs<competence_pack<TCompetences1...>, competence_pack<TCompetences2...>>
+{
+  /** The resulting competence_pack type with all competences from both packs, but without duplicates.
+   * The type is computed by folding the unique insertion of all competences from both packs into an 
+   * initially empty pack.
+   */
+  using type = typename fold_unique<competence_pack<>, TCompetences1..., TCompetences2...>::type;
+};
+
+//--- Recursive union of multiple competence packs using the implementation for two packs. ---
+/** Recursive case: Compute the unique union of the competences of more than one  \ref competence_pack 's.
+ * Specialization for the case when there are still at least two competence packs left to process.
+ * Uses \ref union_two_competence_packs recursively for pairwise combination.
+ * \tparam TPack First competence pack to combine with the union of the rest of the competence packs 
+ *          in this recursion cycle.
+ * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
+ *         Each competence pack is expected to be of type \ref competence_pack.
+ */
+template <typename TPack, typename... TPacks>
+struct union_competence_packs
+{
+  /** This is the type of a new \ref competence_pack containing all competences of the competence packs 
+   * with duplicates removed.
+   */
+  using type = typename union_two_competence_packs<TPack, typename union_competence_packs<TPacks...>::type>::type;
+};
+
+/** Termination case: Only one pack left.
+ * Specialization for the case when there is only one competence pack left to process.
+ * \tparam TPack The only competence pack left.
+ */
+template <typename TPack>
+struct union_competence_packs<TPack>
+{
+  /** Type of the last remaining competence pack. */
+  using type = TPack;
+};
+
+}  // namespace detail
+}  // namespace t8_mesh_handle
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 5e4f26cd21..49d1338401 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -172,13 +172,10 @@ TEST (t8_gtest_cache_competence, cache_volume)
 TEST (t8_gtest_cache_competence, cache_diameter)
 {
   const int level = 1;
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::union_competence_packs_t<
-    t8_mesh_handle::competence_pack<cache_diameter_overwrite>,
-    t8_mesh_handle::competence_pack<t8_mesh_handle::cache_volume, cache_diameter_overwrite>>>;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_diameter_overwrite>>;
   using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_hybrid_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());
-  EXPECT_TRUE (element_class::has_volume_cache ());
 
   double unrealistic_diameter = -3000.0;
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 1e9802b3b2..eb77fe86c7 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -133,7 +133,6 @@ TEST_P (t8_mesh_handle_test, test_all_cache_competence)
 /** Test mesh class with all predefined face competences using some exemplary functionality. */
 TEST_P (t8_mesh_handle_test, test_cache_face_competences)
 {
-  // --- Use all predefined competences. ---
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_face_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,
@@ -172,4 +171,27 @@ TEST_P (t8_mesh_handle_test, test_cache_face_competences)
   }
 }
 
+/** Check that the unique union of multiple competence packs works as intended. */
+TEST (t8_mesh_handle_test, test_union_competence_pack)
+{
+  using namespace t8_mesh_handle;
+  /* Combine multiple competence packs with some overlapping competences to check that the union works correctly
+   * and duplicates are removed. Duplicates would cause an error because we inherit multiple times from the same class.
+   */
+  using mesh_class
+    = mesh<union_competence_packs_type<competence_pack<cache_volume>,
+                                       competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates>,
+                                       competence_pack<cache_centroid, cache_face_areas, cache_face_centroids>>>;
+  using element_class = typename mesh_class::element_class;
+
+  EXPECT_TRUE (element_class::has_volume_cache ());
+  EXPECT_TRUE (element_class::has_diameter_cache ());
+  EXPECT_TRUE (element_class::has_vertex_cache ());
+  EXPECT_TRUE (element_class::has_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_areas_cache ());
+  EXPECT_TRUE (element_class::has_face_centroids_cache ());
+  EXPECT_FALSE (element_class::has_face_normals_cache ());
+  EXPECT_FALSE (element_class::has_face_neighbor_cache ());
+}
+
 INSTANTIATE_TEST_SUITE_P (t8_gtest_mesh, t8_mesh_handle_test, testing::Combine (AllEclasses, testing::Range (2, 3)));

From 993311bbf4aa05cbd2196b7532862b5d9e0b3cc6 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Thu, 5 Mar 2026 16:49:54 +0100
Subject: [PATCH 5/5] doxygen

---
 mesh_handle/competence_pack.hxx                | 7 ++++---
 mesh_handle/internal/competence_pack_union.hxx | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index a5eb09dcd6..d7406b5112 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -54,10 +54,11 @@ using all_cache_competences
 using cache_face_competences
   = competence_pack<cache_face_areas, cache_face_centroids, cache_face_normals, cache_neighbors>;
 
-/** Compute the unique union of the competences of several \ref competence_pack 's.
- *  This produces a new \ref competence_pack containing all competences of the competence packs with duplicates removed.
+/** Compute the unique union of the competences of several \ref t8_mesh_handle::competence_pack 's.
+ *  This produces a new \ref t8_mesh_handle::competence_pack containing all competences of the competence packs 
+ *  with duplicates removed.
  * \tparam TPacks The competence pack for which we should compute the unique union of the competences.
- *         Each competence pack is expected to be of type \ref competence_pack.
+ *         Each competence pack is expected to be of type \ref t8_mesh_handle::competence_pack.
  */
 template <typename... TPacks>
 using union_competence_packs_type = typename detail::union_competence_packs<TPacks...>::type;
diff --git a/mesh_handle/internal/competence_pack_union.hxx b/mesh_handle/internal/competence_pack_union.hxx
index a9a5db67eb..ab86c5c618 100644
--- a/mesh_handle/internal/competence_pack_union.hxx
+++ b/mesh_handle/internal/competence_pack_union.hxx
@@ -21,8 +21,8 @@
 */
 
 /** \file competence_pack_union.hxx 
- * Define the implementation of the unique union of competences of several \ref competence_pack 's.
- * Users should use \ref union_competence_packs_type in \ref competence_pack.hxx.
+ * Define the implementation of the unique union of competences of several \ref t8_mesh_handle::competence_pack 's.
+ * Users should use \ref t8_mesh_handle::union_competence_packs_type in \ref competence_pack.hxx.
  */
 
 #pragma once