Merge branch 'main' into feature-mesh_deformation

Author: LenaRadmer

.github/workflows/check_doxygen.yml

@@ -42,12 +42,21 @@ jobs:
         repository: ${{ github.event.pull_request.head.repo.full_name }}
         ref: ${{ github.event.pull_request.head.ref }}
         fetch-depth: 0
+        fetch-tags: true
     - name: disable ownership checks
       run: git config --global --add safe.directory '*'
     - name: init submodules
       run: git submodule init
     - name: update submodules
       run: git submodule update
+    - name: Check whether a version tag is found and throw error message otherwise.
+      run: |
+        if  ! [ -n "$(git tag --list 'v[0-9]*.[0-9]*.[0-9]*')" ]; then
+          echo "ERROR: No version TAG found! A likely explanation is that the PR was created" \
+               "from a git fork missing the associated tags. If so, here is how to fix it:" \
+               "https://github.com/DLR-AMR/t8code/wiki/Contribution-workflow#failing-version-tags-in-pr-tests"
+               exit 1
+        fi
     - name: Install LaTeX dependencies
       run: |
         sudo apt-get update

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,13 @@ 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 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 t8_mesh_handle::competence_pack.
+ */
+template <typename... TPacks>
+using union_competence_packs_type = typename detail::union_competence_packs<TPacks...>::type;
+
 }  // namespace t8_mesh_handle

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 t8_mesh_handle::competence_pack 's.
+ * Users should use \ref t8_mesh_handle::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