From 0d2ad43eb7fae3b45eeb01b205c61ce56e98676f Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Mon, 22 Dec 2025 13:31:17 +0100
Subject: [PATCH 1/7] add constructor wrappers

---
 mesh_handle/constructor_wrapper.hxx           | 78 +++++++++++++++++++
 .../mesh_handle/t8_gtest_cache_competence.cxx | 50 ++++--------
 .../t8_gtest_custom_competence.cxx            | 16 ++--
 test/mesh_handle/t8_gtest_handle_data.cxx     | 41 ++++------
 4 files changed, 112 insertions(+), 73 deletions(-)
 create mode 100644 mesh_handle/constructor_wrapper.hxx

diff --git a/mesh_handle/constructor_wrapper.hxx b/mesh_handle/constructor_wrapper.hxx
new file mode 100644
index 0000000000..483ffe9a27
--- /dev/null
+++ b/mesh_handle/constructor_wrapper.hxx
@@ -0,0 +1,78 @@
+/*
+  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 constructor_wrapper.hxx
+ * Wrapper for the mesh constructor from a cmesh and some default cmeshes.
+ */
+
+#ifndef T8_CONSTRUCTOR_WRAPPER_HXX
+#define T8_CONSTRUCTOR_WRAPPER_HXX
+
+#include <t8.h>
+#include <t8_forest/t8_forest_general.h>
+#include <t8_cmesh/t8_cmesh.h>
+#include <t8_schemes/t8_default/t8_default.hxx>
+#include <t8_cmesh/t8_cmesh_examples.h>
+#include <memory>
+
+namespace t8_mesh_handle
+{
+
+/** Build a uniformly refined mesh handle on a coarse mesh using a default scheme.
+ * \param [in] cmesh         A coarse mesh.
+ * \param [in] level         An initial uniform refinement level.
+ * \param [in] comm          MPI communicator to use.
+ * \param [in] do_face_ghost If true, a layer of ghost elements is created.
+ * \tparam TMesh             The mesh handle class.
+ * \return Unique pointer to a uniformly refined mesh handle with coarse mesh \a cmesh and refinement level \a level.
+ */
+template <typename TMesh>
+std::unique_ptr<TMesh>
+handle_new_uniform_default (const t8_cmesh_t cmesh, const int level, const sc_MPI_Comm comm,
+                            const bool do_face_ghost = false)
+{
+  const t8_scheme *scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, do_face_ghost, sc_MPI_COMM_WORLD);
+  return std::make_unique<TMesh> (forest);
+}
+
+/** Hybercube with 6 Tets, 6 Prism, 4 Hex. Refined uniformly to given level.
+ * \param [in] level         An initial uniform refinement level.
+ * \param [in] comm          MPI communicator to use.
+ * \param [in] do_partition  If non-zero create a partitioned cmesh.
+ * \param [in] do_face_ghost If true, a layer of ghost elements is created.
+ * \param [in] periodic      If non-zero create a periodic cmesh in each direction.
+ * \tparam TMesh             The mesh handle class.
+ * \return Unique pointer to a uniformly refined mesh handle initially consisting of 6 Tets, 6 prism and 4 hex.
+ *         Together, they form a cube.
+*/
+template <typename TMesh>
+std::unique_ptr<TMesh>
+handle_hypercube_uniform_default (const int level, const sc_MPI_Comm comm, const bool do_partition = false,
+                                  const bool do_face_ghost = false, const bool periodic = false)
+{
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (comm, do_partition, periodic);
+  return handle_new_uniform_default<TMesh> (cmesh, level, comm, do_face_ghost);
+}
+
+}  // namespace t8_mesh_handle
+#endif /* !T8_CONSTRUCTOR_WRAPPER_HXX */
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 5c881fae64..5906518512 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -31,10 +31,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
 
@@ -83,43 +80,20 @@ struct cache_centroid_overwrite: public t8_mesh_handle::cache_centroid<TUnderlyi
   }
 };
 
-/** Test fixture for cache competence tests. */
-class t8_gtest_cache_competence: public testing::Test {
- protected:
-  void
-  SetUp () override
-  {
-    level = 1;
-    t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-    const t8_scheme *scheme = t8_scheme_new_default ();
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
-  }
-
-  void
-  TearDown () override
-  {
-    if (forest->rc.refcount > 0) {
-      t8_forest_unref (&forest);
-    }
-  }
-
-  t8_forest_t forest;
-  int level;
-};
-
 /** Use child class of \ref t8_mesh_handle::cache_volume class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
-TEST_F (t8_gtest_cache_competence, cache_volume)
+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 element_class = typename mesh_class::abstract_element_class;
-  mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_volume_cache ());
 
   double unrealistic_volume = -3000;
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->volume_cache_filled ());
     // Fill cache and check that volume is valid.
@@ -137,15 +111,16 @@ TEST_F (t8_gtest_cache_competence, cache_volume)
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
-TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
+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 element_class = typename mesh_class::abstract_element_class;
-  mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_vertex_cache ());
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->vertex_cache_filled ());
     // Check that values are valid.
@@ -169,15 +144,16 @@ TEST_F (t8_gtest_cache_competence, cache_vertex_coordinates)
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
  */
-TEST_F (t8_gtest_cache_competence, cache_centroid)
+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 element_class = mesh_class::abstract_element_class;
-  mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->centroid_cache_filled ());
     // Check that values are valid.
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 788b35ab74..183ac20b95 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -31,10 +31,8 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
 #include <t8_types/t8_operators.hxx>
 
 /**
@@ -85,26 +83,22 @@ TEST (t8_gtest_custom_competence, custom_competence)
 {
   // Define forest to construct mesh.
   const int level = 1;
-  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
 
   // Check mesh with custom defined competence.
   using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
-  mesh_class_custom mesh = mesh_class_custom (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (level, it->get_level_dummy ());
   }
 
-  t8_forest_ref (forest);
   // 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 mesh_class = t8_mesh_handle::mesh<competences>;
-  mesh_class mesh_more_competences = mesh_class (forest);
+  auto mesh_more_competences = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
-  for (auto it = mesh_more_competences.begin (); it != mesh_more_competences.end (); ++it) {
+  for (auto it = mesh_more_competences->begin (); it != mesh_more_competences->end (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (it->get_value_dummy (), 1);
     EXPECT_FALSE (it->centroid_cache_filled ());
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 53adab5eac..b07bad833f 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -30,10 +30,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 <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_types/t8_vec.hxx>
 #include <vector>
 
@@ -50,14 +47,10 @@ struct dummy_user_data
  */
 TEST (t8_gtest_handle_data, set_and_get_user_data)
 {
-  // Define forest and mesh handle.
+  // Define mesh handle.
   const int level = 2;
-  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *init_scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
-
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
-  mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
   struct dummy_user_data user_data = {
     t8_3D_point ({ 41, 42, 43 }), /* Midpoints of the sphere. */
@@ -66,8 +59,8 @@ TEST (t8_gtest_handle_data, set_and_get_user_data)
   };
 
   // Set user data for the mesh handle and check that the getter returns the same data.
-  mesh.set_user_data (&user_data);
-  auto mesh_user_data = mesh.get_user_data ();
+  mesh->set_user_data (&user_data);
+  auto mesh_user_data = mesh->get_user_data ();
   EXPECT_EQ (mesh_user_data.midpoint, user_data.midpoint);
   EXPECT_EQ (mesh_user_data.refine_if_inside_radius, user_data.refine_if_inside_radius);
   EXPECT_EQ (mesh_user_data.coarsen_if_outside_radius, user_data.coarsen_if_outside_radius);
@@ -86,28 +79,26 @@ struct data_per_element
  */
 TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
-  // Define forest and mesh handle.
+  // Define mesh handle.
   const int level = 2;
-  t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *init_scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 1, sc_MPI_COMM_WORLD);
-
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, void, data_per_element>;
-  mesh_class mesh = mesh_class (forest);
-  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+  auto mesh
+    = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, true, true, false);
+
+  if ((mesh->get_dimension () > 1) && (mesh->get_num_local_elements () > 1)) {
     // Ensure that we actually test with ghost elements.
-    EXPECT_GT (mesh.get_num_local_ghosts (), 0);
+    EXPECT_GT (mesh->get_num_local_ghosts (), 0);
   }
   // Create element data for all local mesh elements.
   std::vector<data_per_element> element_data;
-  for (const auto &elem : mesh) {
+  for (const auto &elem : *mesh) {
     element_data.push_back ({ elem.get_level (), elem.get_volume () });
   }
-  mesh.set_element_data (element_data);
+  mesh->set_element_data (element_data);
   // Get element data and check that the data for all elements (including ghosts) is correct.
-  auto mesh_element_data = mesh.get_element_data ();
-  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements () + mesh.get_num_local_ghosts (); ielem++) {
+  auto mesh_element_data = mesh->get_element_data ();
+  for (t8_locidx_t ielem = 0; ielem < mesh->get_num_local_elements () + mesh->get_num_local_ghosts (); ielem++) {
     EXPECT_EQ (mesh_element_data[ielem].level, level) << "ielem = " << ielem;
-    EXPECT_EQ (mesh_element_data[ielem].volume, mesh[ielem].get_volume ()) << "ielem = " << ielem;
+    EXPECT_EQ (mesh_element_data[ielem].volume, (*mesh)[ielem].get_volume ()) << "ielem = " << ielem;
   }
 }

From 554be6c9ec71bc5d058bf9083133f626e3538df3 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Fri, 2 Jan 2026 15:33:28 +0100
Subject: [PATCH 2/7] added some functionality

---
 mesh_handle/abstract_element.hxx    | 262 ++++++++++++++++++++++++++--
 mesh_handle/competence_pack.hxx     |   7 +-
 mesh_handle/competences.hxx         |  94 +++++++++-
 mesh_handle/mesh_element.hxx        |  12 +-
 test/mesh_handle/t8_gtest_ghost.cxx | 241 +++++++++++++------------
 5 files changed, 485 insertions(+), 131 deletions(-)

diff --git a/mesh_handle/abstract_element.hxx b/mesh_handle/abstract_element.hxx
index 2c23172243..1484242bf0 100644
--- a/mesh_handle/abstract_element.hxx
+++ b/mesh_handle/abstract_element.hxx
@@ -91,6 +91,20 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
   a function volume_cache_filled. */
   static constexpr bool volume_cache_exists = (false || ... || volume_cache_defined<TCompetence> ());
 
+  /** Helper function to check if class T implements the function diameter_cache_defined.
+   * \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
+  diameter_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.diameter_cache_filled (); };
+  }
+  /** This variable is true if any of the given competences \a TCompetence implements 
+  a function diameter_cache_filled. */
+  static constexpr bool diameter_cache_exists = (false || ... || diameter_cache_defined<TCompetence> ());
+
   /** Helper function to check if class T implements the function vertex_cache_filled.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
@@ -119,6 +133,48 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
   a function centroid_cache_filled. */
   static constexpr bool centroid_cache_exists = (false || ... || centroid_cache_defined<TCompetence> ());
 
+  /** Helper function to check if class T implements the function face_area_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_area_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_area_cache_filled (0); };
+  }
+  /** This variable is true if any of the given competences \a TCompetence implements 
+  a function face_area_cache_filled. */
+  static constexpr bool face_area_cache_exists = (false || ... || face_area_cache_defined<TCompetence> ());
+
+  /** Helper function to check if class T implements the function face_centroid_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_centroid_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_centroid_cache_filled (0); };
+  }
+  /** This variable is true if any of the given competences \a TCompetence implements 
+  a function face_centroid_cache_filled. */
+  static constexpr bool face_centroid_cache_exists = (false || ... || face_centroid_cache_defined<TCompetence> ());
+
+  /** Helper function to check if class T implements the function face_normal_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_normal_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_normal_cache_filled (0); };
+  }
+  /** This variable is true if any of the given competences \a TCompetence implements 
+  a function face_normal_cache_filled. */
+  static constexpr bool face_normal_cache_exists = (false || ... || face_normal_cache_defined<TCompetence> ());
+
  public:
   // --- Functions to check if caches exist. ---
   /**
@@ -130,6 +186,17 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
   {
     return volume_cache_exists;
   }
+
+  /**
+   * Function that checks if a cache for the element's diameter exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_diameter_cache ()
+  {
+    return diameter_cache_exists;
+  }
+
   /**
    * Function that checks if a cache for the vertex coordinates exists.
    * \return true if a cache for the vertex coordinates exists, false otherwise.
@@ -150,6 +217,36 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
     return centroid_cache_exists;
   }
 
+  /**
+   * Function that checks if a cache for the element's face area exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_face_area_cache ()
+  {
+    return face_area_cache_exists;
+  }
+
+  /**
+   * Function that checks if a cache for the element's face centroid exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_face_centroid_cache ()
+  {
+    return face_centroid_cache_exists;
+  }
+
+  /**
+   * Function that checks if a cache for the element's face normal exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_face_normal_cache ()
+  {
+    return face_normal_cache_exists;
+  }
+
   // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
   /**
    * Getter for the refinement level of the element.
@@ -175,6 +272,17 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
     return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_faces (get_tree_class (), get_element ());
   }
 
+  /**
+   * Getter for the number of vertices of the element.
+   * For this easily accessible variable, it makes no sense to provide a cached version.
+   * \return Number of vertices of the element.
+   */
+  int
+  get_num_vertices () const
+  {
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), get_element ());
+  }
+
   /**
    * Getter for the element's shape.
    * For this easily accessible variable, it makes no sense to provide a cached version.
@@ -188,23 +296,41 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
 
   /**
    * Getter for the element's volume.
-   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
    * \return The volume of the element.
    */
   double
   get_volume () const
   {
     if constexpr (volume_cache_exists) {
-      if (this->volume_cache_filled ()) {
-        return this->m_volume.value ();
+      if (!this->volume_cache_filled ()) {
+        // Fill cache.
+        this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
       }
-      // Fill cache.
-      this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
       return this->m_volume.value ();
     }
     return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
   }
 
+  /**
+   * Getter for the element's diameter.
+   * This is only an approximation.
+   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * \return The diameter of the element.
+   */
+  double
+  get_diameter () const
+  {
+    if constexpr (diameter_cache_exists) {
+      if (!this->diameter_cache_filled ()) {
+        // Fill cache.
+        this->m_diameter = t8_forest_element_diam (m_mesh->m_forest, m_tree_id, get_element ());
+      }
+      return this->m_diameter.value ();
+    }
+    return t8_forest_element_diam (m_mesh->m_forest, m_tree_id, get_element ());
+  }
+
   /**
    * Getter for the vertex coordinates of the element.
    * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
@@ -220,12 +346,11 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
       }
     }
     // Calculate the vertex coordinates.
-    const t8_element_t* element = get_element ();
-    const int num_corners
-      = t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), element);
+    const int num_corners = get_num_vertices ();
     std::vector<t8_3D_point> vertex_coordinates (num_corners);
     for (int icorner = 0; icorner < num_corners; ++icorner) {
-      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, element, icorner, vertex_coordinates[icorner].data ());
+      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, get_element (), icorner,
+                                    vertex_coordinates[icorner].data ());
     }
     // Fill the cache in the cached version.
     if constexpr (vertex_cache_exists) {
@@ -235,6 +360,30 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
     return vertex_coordinates;
   }
 
+  /**
+   * Getter for the coordinates of one specific vertex of the element.
+   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * The cache is filled for all vertices simultaneously.
+   * \param [in] vertex Index of the vertex.
+   * \return Coordinates of the vertex.
+   */
+  t8_3D_point
+  get_vertex_coordinates (int vertex) const
+  {
+    T8_ASSERT (vertex < get_num_vertices ());
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (vertex_cache_exists) {
+      if (!this->vertex_cache_filled ()) {
+        get_vertex_coordinates ();
+      }
+      return this->m_vertex_coordinates[vertex];
+    }
+    // Calculate the vertex coordinates.
+    t8_3D_point coordinates;
+    t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, get_element (), vertex, coordinates.data ());
+    return coordinates;
+  }
+
   /**
    * Getter for the center of mass of the element.
    * This function uses the cached version defined in TCompetence if available and calculates if not.
@@ -258,7 +407,100 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
     return coordinates;
   }
 
-  //--- Getter for the member variables. ---
+  // --- Getter for face properties. ---
+  /** The area of a face of the element.
+   * This is only an approximation.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The area of \a face.
+   */
+  double
+  get_face_area (int face) const
+  {
+
+    if constexpr (face_area_cache_exists) {
+      if (!this->face_area_cache_filled (face)) {
+        // Fill cache.
+        this->m_face_area[face] = t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
+      }
+      return this->m_face_area[face];
+    }
+    return t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
+  }
+
+  /** The centroid of a face of the element.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The centroid of \a face.
+   */
+  t8_3D_point
+  get_face_centroid (int face) const
+  {
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (face_centroid_cache_exists) {
+      if (this->face_centroid_cache_filled (face)) {
+        return this->m_face_centroid[face];
+      }
+    }
+    t8_3D_point coordinates;
+    t8_forest_element_face_centroid (m_mesh->m_forest, m_tree_id, get_element (), face, coordinates.data ());
+    // Fill the cache in the cached version.
+    if constexpr (face_centroid_cache_exists) {
+      this->m_face_centroid[face] = coordinates;
+    }
+    return coordinates;
+  }
+
+  /** The normal vector of a face of the element.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The normal vector of \a face.
+   */
+  t8_3D_vec
+  get_face_normal (int face) const
+  {
+
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (face_normal_cache_exists) {
+      if (this->face_normal_cache_filled (face)) {
+        return this->m_face_normal[face];
+      }
+    }
+    t8_3D_vec normal;
+    t8_forest_element_face_normal (m_mesh->m_forest, m_tree_id, get_element (), face, normal.data ());
+    // Fill the cache in the cached version.
+    if constexpr (face_normal_cache_exists) {
+      this->m_face_normal[face] = normal;
+    }
+    return normal;
+  }
+
+  /**
+   * Getter for the element's shape.
+   * For this easily accessible variable, it makes no sense to provide a cached version.
+   * \param [in] face Index of a face of the element.
+   * \return The shape of the element.
+   */
+  t8_element_shape_t
+  get_face_shape (int face) const
+  {
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_face_shape (get_tree_class (), get_element (), face);
+  }
+
+  // --- Print for the element for debugging purpose. ---
+#if T8_ENABLE_DEBUG
+  /** Print the element. 
+    * For a example for a triangle print the coordinates and the level of the triangle. 
+    * This function is only available in the debugging configuration.
+    */
+  void
+  print_element_debug () const
+  {
+    t8_forest_get_scheme (m_mesh->m_forest)->element_debug_print (get_tree_class (), get_element ());
+  }
+#endif
+
+  // --- Getter for the member variables. ---
   /**
    * Getter for the tree id of the element.
    * \return The element's local tree id.
diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index ee351401d2..52033978aa 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -45,7 +45,12 @@ struct competence_pack
 };
 
 /** Predefined competence pack combining all caching competences. */
-using cache_competences = competence_pack<cache_volume, cache_vertex_coordinates, cache_centroid, cache_neighbors>;
+using cache_competences = competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid,
+                                          cache_face_area, cache_face_centroid, cache_face_normal, cache_neighbors>;
+
+/** Predefined competence pack combining all competences related to faces. */
+using cache_face_competences
+  = competence_pack<cache_face_area, cache_face_centroid, cache_face_normal, cache_neighbors>;
 
 }  // namespace t8_mesh_handle
 #endif /* !T8_COMPETENCE_PACK_HXX */
diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index 30d79af5ca..f256e0e13e 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -71,6 +71,29 @@ struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
     m_volume; /**< Cache for the volume. Use optional to allow no value if cache is not filled. */
 };
 
+/**
+ * Competence to cache the diameter of an element at the first function call.
+ * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_diameter: public t8_crtp_operator<TUnderlying, cache_diameter>
+{
+ public:
+  /**
+   * Function that checks if the cache for the diameter has been filled.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  diameter_cache_filled () const
+  {
+    return m_diameter.has_value ();
+  }
+
+ protected:
+  mutable std::optional<double>
+    m_diameter; /**< Cache for the diameter. Use optional to allow no value if cache is not filled. */
+};
+
 /**
  * Competence to cache the vertex coordinates of an element at the first function call.
  * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
@@ -117,12 +140,81 @@ struct cache_centroid: public t8_crtp_operator<TUnderlying, cache_centroid>
     m_centroid; /**< Cache for the coordinates of the centroid. Use optional to allow no value if cache is not filled. */
 };
 
+/**
+ * Competence to cache the area of a specific face at the first function call.
+ * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_face_area: t8_crtp_operator<TUnderlying, cache_face_area>
+{
+ public:
+  /**
+   * Function that checks if the cache for a face has been filled.
+   * \param [in] face The face for which the cache should be checked.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  face_area_cache_filled (int face) const
+  {
+    return m_face_area[face].has_value ();
+  }
+
+ protected:
+  mutable std::vector<std::optional<double>> m_face_area; /**< Vector with the face area each face. */
+};
+
+/**
+ * Competence to cache the centroid of a specific face at the first function call.
+ * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_face_centroid: t8_crtp_operator<TUnderlying, cache_face_centroid>
+{
+ public:
+  /**
+   * Function that checks if the cache for a face has been filled.
+   * \param [in] face The face for which the cache should be checked.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  face_centroid_cache_filled (int face) const
+  {
+    return m_face_centroid[face].has_value ();
+  }
+
+ protected:
+  mutable std::vector<std::optional<t8_3D_point>> m_face_centroid; /**< Vector with the face centroid each face. */
+};
+
+/**
+ * Competence to cache the normal of a specific face at the first function call.
+ * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ */
+template <typename TUnderlying>
+struct cache_face_normal: t8_crtp_operator<TUnderlying, cache_face_normal>
+{
+ public:
+  /**
+   * Function that checks if the cache for a face has been filled.
+   * \param [in] face The face for which the cache should be checked.
+   * \return true if the cache has been filled, false otherwise.
+   */
+  bool
+  face_normal_cache_filled (int face) const
+  {
+    return m_face_normal[face].has_value ();
+  }
+
+ protected:
+  mutable std::vector<std::optional<t8_3D_vec>> m_face_normal; /**< Vector with the face normal each face. */
+};
+
 /**
  * Competence to cache the neighbors of an element at a specific face at the first function call.
  * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
  */
 template <typename TUnderlying>
-struct cache_neighbors: t8_crtp_operator<TUnderlying, cache_centroid>
+struct cache_neighbors: t8_crtp_operator<TUnderlying, cache_neighbors>
 {
  public:
   /**
diff --git a/mesh_handle/mesh_element.hxx b/mesh_handle/mesh_element.hxx
index 8bc08f30da..e03c2b5b58 100644
--- a/mesh_handle/mesh_element.hxx
+++ b/mesh_handle/mesh_element.hxx
@@ -51,7 +51,7 @@ class mesh_element: public abstract_element<mesh_class, TCompetence...> {
   friend mesh_class;
 
   // --- Variables to check which functionality is defined in TCompetence. ---
-  /** Helper function to check if class T implements the function neighbor_cache_filled.
+  /** Helper function to check if class T implements the function neighbor_cache_filled_any.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
    */
@@ -59,10 +59,10 @@ class mesh_element: public abstract_element<mesh_class, TCompetence...> {
   static constexpr bool
   neighbor_cache_defined ()
   {
-    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
+    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled_any (); };
   }
   /* This variable is true if any of the given competences \ref TCompetence implements 
-  a function neighbor_cache_filled. */
+  a function neighbor_cache_filled_any. */
   static constexpr bool neighbor_cache_exists = (false || ... || neighbor_cache_defined<TCompetence> ());
 
   /**
@@ -116,10 +116,10 @@ class mesh_element: public abstract_element<mesh_class, TCompetence...> {
       }
     }
     std::vector<std::reference_wrapper<SelfType>> neighbor_elements;
-    t8_element_t** neighbors; /*< Neighboring elements. */
+    t8_element_t** neighbors; /**< Neighboring elements. */
     int* dual_faces_internal; /**< The face indices of the neighbor elements. */
-    t8_locidx_t* neighids;    /*< Neighboring elements ids. */
-    t8_eclass_t neigh_class;  /*< Neighboring elements tree class. */
+    t8_locidx_t* neighids;    /**< Neighboring elements ids. */
+    t8_eclass_t neigh_class;  /**< Neighboring elements tree class. */
 
     t8_forest_leaf_face_neighbors (this->m_mesh->m_forest, this->m_tree_id, get_element (), &neighbors, face,
                                    &dual_faces_internal, num_neighbors, &neighids, &neigh_class,
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 43a639b10a..9753911855 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -99,6 +99,10 @@ TEST_P (t8_mesh_ghost_test, check_ghosts)
   for (t8_locidx_t ighost = num_local_elements; ighost < num_local_elements + num_ghost_elements; ++ighost) {
     EXPECT_TRUE (mesh[ighost].is_ghost_element ());
     EXPECT_EQ (level, mesh[ighost].get_level ());
+    EXPECT_LE (0, mesh[ighost].get_num_faces ());
+    EXPECT_LE (0, mesh[ighost].get_num_vertices ());
+    EXPECT_LE (0, mesh[ighost].get_volume ());
+    EXPECT_LE (0, mesh[ighost].get_diameter ());
     auto centroid = mesh[ighost].get_centroid ();
     for (const auto& coordinate : centroid) {
       EXPECT_GE (1, coordinate);
@@ -111,122 +115,133 @@ TEST_P (t8_mesh_ghost_test, check_ghosts)
         EXPECT_LE (0, coordinate);
       }
     }
-  }
-}
-
-/** Check that the function \ref t8_mesh_handle::mesh_element::get_face_neighbors of the handle works as intended (equal results to forest).*/
-TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
-{
-  ASSERT_TRUE (t8_forest_is_committed (forest));
-
-  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
-  EXPECT_EQ (mesh.get_num_local_ghosts (), t8_forest_get_num_ghosts (forest));
-
-  // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
-  const t8_scheme* scheme = t8_forest_get_scheme (forest);
-  auto mesh_iterator = mesh.begin ();
-  for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
-    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
-    for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
-      // --- Compare elements. ---
-      EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
-      EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
-      // --- Compare neighbors. ---
-      const t8_element_t* elem = t8_forest_get_leaf_element_in_tree (forest, itree, ielem);
-      const int num_faces = scheme->element_get_num_faces (tree_class, elem);
-      EXPECT_EQ (mesh_iterator->get_num_faces (), num_faces);
-      for (int iface = 0; iface < num_faces; iface++) {
-        // --- Get neighbors from forest. ---
-        t8_element_t** neighbors;
-        int num_neighbors;
-        const int forest_is_balanced = t8_forest_is_balanced (forest);
-        t8_eclass_t neigh_eclass;
-        int* dual_faces;
-        t8_locidx_t* neigh_ids;
-        t8_forest_leaf_face_neighbors (forest, itree, elem, &neighbors, iface, &dual_faces, &num_neighbors, &neigh_ids,
-                                       &neigh_eclass, forest_is_balanced);
-        // --- Get neighbors from mesh element. ---
-        int num_neighbors_handle;
-        std::vector<int> dual_faces_handle;
-        auto neighbor_ids_handle = mesh_iterator->get_face_neighbors (iface, &num_neighbors_handle, &dual_faces_handle);
-        // --- Compare results. ---
-        EXPECT_EQ ((int) neighbor_ids_handle.size (), num_neighbors_handle);
-        EXPECT_EQ (num_neighbors, num_neighbors_handle);
-        EXPECT_EQ (dual_faces_handle, std::vector<int> (dual_faces, dual_faces + num_neighbors));
-        EXPECT_EQ (neighbor_ids_handle, std::vector<t8_locidx_t> (neigh_ids, neigh_ids + num_neighbors));
-        for (int ineigh = 0; ineigh < num_neighbors; ineigh++) {
-          EXPECT_EQ (scheme->element_get_shape (neigh_eclass, neighbors[ineigh]),
-                     mesh[neighbor_ids_handle[ineigh]].get_shape ());
-        }
-        // Free memory.
-        if (num_neighbors > 0) {
-          scheme->element_destroy (neigh_eclass, num_neighbors, neighbors);
-          T8_FREE (neigh_ids);
-          T8_FREE (neighbors);
-          T8_FREE (dual_faces);
-        }
-      }
-      // Evolve mesh iterator.
-      mesh_iterator++;
+    EXPECT_LE (0, mesh[ighost].get_face_area (0));
+    auto centroid_face = mesh[ighost].get_face_centroid (0);
+    for (const auto& coordinate : centroid_face) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (0, coordinate);
     }
-  }
-}
-
-/** Child class of \ref t8_mesh_handle::cache_neighbors that allows to modify the cache variables for test purposes. */
-template <typename TUnderlying>
-struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderlying>
-{
- public:
-  /** Overwrites the cache variables for the a \ref face.
-   * \param [in] face              Face for which the cache should be overwritten.
-   * \param [in] neighbor_indices  New cache vector for the neighbor indices.
-   * \param [in] num_neighbors     New cache value for the number of neighbors.
-   * \param [in] dual_faces        New cache vector for the dual faces.
-   */
-  void
-  overwrite_cache (int face, std::vector<t8_locidx_t> neighbor_indices, int num_neighbors,
-                   std::vector<int> dual_faces) const
-  {
-    this->m_neighbor_indices[face] = neighbor_indices;
-    this->m_num_neighbors[face] = num_neighbors;
-    this->m_dual_faces[face] = dual_faces;
-  }
-};
-
-/** Use child class of \ref t8_mesh_handle::cache_neighbors class to check that the cache is actually set 
- * and accessed correctly. This is done by modifying the cache variables to a unrealistic values and 
- * checking that the functionality actually outputs this unrealistic value.
- */
-TEST_P (t8_mesh_ghost_test, cache_neighbors)
-{
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
-  using element_class = typename mesh_class::mesh_element_class;
-  mesh_class mesh = mesh_class (forest);
-  EXPECT_TRUE (element_class::has_face_neighbor_cache ());
-
-  const std::vector<t8_locidx_t> unrealistic_neighbor_indices = { 9999, 99989997 };
-  const int unrealistic_num_neighbors = 2;
-  const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
-  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
-    // Check that cache is empty at the beginning.
-    EXPECT_FALSE (it->neighbor_cache_filled_any ());
-    it->fill_face_neighbor_cache ();
-    for (int iface = 0; iface < it->get_num_faces (); iface++) {
-      EXPECT_TRUE (it->neighbor_cache_filled (iface));
-      int num_neighbors = -1;
-      std::vector<int> dual_faces;
-      auto neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
-      EXPECT_EQ ((int) neighbor_ids.size (), num_neighbors);
-      // Overwrite cache with unrealistic values.
-      it->overwrite_cache (iface, unrealistic_neighbor_indices, unrealistic_num_neighbors, unrealistic_dual_faces);
-      EXPECT_TRUE (it->neighbor_cache_filled (iface));
-      neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
-      // --- Compare results. ---
-      EXPECT_EQ (neighbor_ids, unrealistic_neighbor_indices);
-      EXPECT_EQ (num_neighbors, unrealistic_num_neighbors);
-      EXPECT_EQ (dual_faces, unrealistic_dual_faces);
+    auto normal_face = mesh[ighost].get_face_normal (0);
+    for (const auto& coordinate : normal_face) {
+      EXPECT_GE (1, coordinate);
+      EXPECT_LE (-1, coordinate);
     }
   }
 }
 
+// /** Check that the function \ref t8_mesh_handle::mesh_element::get_face_neighbors of the handle works as intended (equal results to forest).*/
+// TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
+// {
+//   ASSERT_TRUE (t8_forest_is_committed (forest));
+
+//   t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+//   EXPECT_EQ (mesh.get_num_local_ghosts (), t8_forest_get_num_ghosts (forest));
+
+//   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
+//   const t8_scheme* scheme = t8_forest_get_scheme (forest);
+//   auto mesh_iterator = mesh.begin ();
+//   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
+//     const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
+//     for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
+//       // --- Compare elements. ---
+//       EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
+//       EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
+//       // --- Compare neighbors. ---
+//       const t8_element_t* elem = t8_forest_get_leaf_element_in_tree (forest, itree, ielem);
+//       const int num_faces = scheme->element_get_num_faces (tree_class, elem);
+//       EXPECT_EQ (mesh_iterator->get_num_faces (), num_faces);
+//       for (int iface = 0; iface < num_faces; iface++) {
+//         // --- Get neighbors from forest. ---
+//         t8_element_t** neighbors;
+//         int num_neighbors;
+//         const int forest_is_balanced = t8_forest_is_balanced (forest);
+//         t8_eclass_t neigh_eclass;
+//         int* dual_faces;
+//         t8_locidx_t* neigh_ids;
+//         t8_forest_leaf_face_neighbors (forest, itree, elem, &neighbors, iface, &dual_faces, &num_neighbors, &neigh_ids,
+//                                        &neigh_eclass, forest_is_balanced);
+//         // --- Get neighbors from mesh element. ---
+//         int num_neighbors_handle;
+//         std::vector<int> dual_faces_handle;
+//         auto neighbor_ids_handle = mesh_iterator->get_face_neighbors (iface, &num_neighbors_handle, &dual_faces_handle);
+//         // --- Compare results. ---
+//         EXPECT_EQ ((int) neighbor_ids_handle.size (), num_neighbors_handle);
+//         EXPECT_EQ (num_neighbors, num_neighbors_handle);
+//         EXPECT_EQ (dual_faces_handle, std::vector<int> (dual_faces, dual_faces + num_neighbors));
+//         EXPECT_EQ (neighbor_ids_handle, std::vector<t8_locidx_t> (neigh_ids, neigh_ids + num_neighbors));
+//         for (int ineigh = 0; ineigh < num_neighbors; ineigh++) {
+//           EXPECT_EQ (scheme->element_get_shape (neigh_eclass, neighbors[ineigh]),
+//                      mesh[neighbor_ids_handle[ineigh]].get_shape ());
+//         }
+//         // Free memory.
+//         if (num_neighbors > 0) {
+//           scheme->element_destroy (neigh_eclass, num_neighbors, neighbors);
+//           T8_FREE (neigh_ids);
+//           T8_FREE (neighbors);
+//           T8_FREE (dual_faces);
+//         }
+//       }
+//       // Evolve mesh iterator.
+//       mesh_iterator++;
+//     }
+//   }
+// }
+
+// /** Child class of \ref t8_mesh_handle::cache_neighbors that allows to modify the cache variables for test purposes. */
+// template <typename TUnderlying>
+// struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderlying>
+// {
+//  public:
+//   /** Overwrites the cache variables for the a \ref face.
+//    * \param [in] face              Face for which the cache should be overwritten.
+//    * \param [in] neighbor_indices  New cache vector for the neighbor indices.
+//    * \param [in] num_neighbors     New cache value for the number of neighbors.
+//    * \param [in] dual_faces        New cache vector for the dual faces.
+//    */
+//   void
+//   overwrite_cache (int face, std::vector<t8_locidx_t> neighbor_indices, int num_neighbors,
+//                    std::vector<int> dual_faces) const
+//   {
+//     this->m_neighbor_indices[face] = neighbor_indices;
+//     this->m_num_neighbors[face] = num_neighbors;
+//     this->m_dual_faces[face] = dual_faces;
+//   }
+// };
+
+// /** Use child class of \ref t8_mesh_handle::cache_neighbors class to check that the cache is actually set
+//  * and accessed correctly. This is done by modifying the cache variables to a unrealistic values and
+//  * checking that the functionality actually outputs this unrealistic value.
+//  */
+// TEST_P (t8_mesh_ghost_test, cache_neighbors)
+// {
+//   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+//   using element_class = typename mesh_class::mesh_element_class;
+//   mesh_class mesh = mesh_class (forest);
+//   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
+
+//   const std::vector<t8_locidx_t> unrealistic_neighbor_indices = { 9999, 99989997 };
+//   const int unrealistic_num_neighbors = 2;
+//   const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
+//   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+//     // Check that cache is empty at the beginning.
+//     EXPECT_FALSE (it->neighbor_cache_filled_any ());
+//     it->fill_face_neighbor_cache ();
+//     for (int iface = 0; iface < it->get_num_faces (); iface++) {
+//       EXPECT_TRUE (it->neighbor_cache_filled (iface));
+//       int num_neighbors = -1;
+//       std::vector<int> dual_faces;
+//       auto neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
+//       EXPECT_EQ ((int) neighbor_ids.size (), num_neighbors);
+//       // Overwrite cache with unrealistic values.
+//       it->overwrite_cache (iface, unrealistic_neighbor_indices, unrealistic_num_neighbors, unrealistic_dual_faces);
+//       EXPECT_TRUE (it->neighbor_cache_filled (iface));
+//       neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
+//       // --- Compare results. ---
+//       EXPECT_EQ (neighbor_ids, unrealistic_neighbor_indices);
+//       EXPECT_EQ (num_neighbors, unrealistic_num_neighbors);
+//       EXPECT_EQ (dual_faces, unrealistic_dual_faces);
+//     }
+//   }
+// }
+
 INSTANTIATE_TEST_SUITE_P (t8_gtest_ghost, t8_mesh_ghost_test, testing::Combine (AllEclasses, testing::Range (1, 2)));

From 4c57ea026e713086c896b26289c0edb6ed88f4b7 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Mon, 5 Jan 2026 13:19:41 +0100
Subject: [PATCH 3/7] added test

---
 mesh_handle/abstract_element.hxx              |   6 +-
 mesh_handle/ghost_element.hxx                 |  13 +
 mesh_handle/mesh_element.hxx                  |  13 +
 test/mesh_handle/README.md                    |  13 +
 .../mesh_handle/t8_gtest_cache_competence.cxx |  83 +++++++
 test/mesh_handle/t8_gtest_ghost.cxx           | 228 +++++++++---------
 6 files changed, 239 insertions(+), 117 deletions(-)
 create mode 100644 test/mesh_handle/README.md

diff --git a/mesh_handle/abstract_element.hxx b/mesh_handle/abstract_element.hxx
index 1484242bf0..4b3d644951 100644
--- a/mesh_handle/abstract_element.hxx
+++ b/mesh_handle/abstract_element.hxx
@@ -423,7 +423,7 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
         // Fill cache.
         this->m_face_area[face] = t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
       }
-      return this->m_face_area[face];
+      return this->m_face_area[face].value ();
     }
     return t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
   }
@@ -476,10 +476,10 @@ class abstract_element: public TCompetence<abstract_element<mesh_class, TCompete
   }
 
   /**
-   * Getter for the element's shape.
+   * Getter for the element's face shape.
    * For this easily accessible variable, it makes no sense to provide a cached version.
    * \param [in] face Index of a face of the element.
-   * \return The shape of the element.
+   * \return The shape of the face of the element.
    */
   t8_element_shape_t
   get_face_shape (int face) const
diff --git a/mesh_handle/ghost_element.hxx b/mesh_handle/ghost_element.hxx
index 0221f5b7c8..ada12d4318 100644
--- a/mesh_handle/ghost_element.hxx
+++ b/mesh_handle/ghost_element.hxx
@@ -56,6 +56,19 @@ class ghost_element: public abstract_element<mesh_class, TCompetence...> {
   ghost_element (mesh_class* mesh, t8_locidx_t tree_id, t8_locidx_t lghost_tree_id, t8_locidx_t element_id)
     : Base (mesh, tree_id, element_id), m_lghost_tree_id (lghost_tree_id)
   {
+    // Resize caches for clean access.
+    if constexpr (this->face_area_cache_exists) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_area.resize (num_faces);
+    }
+    if constexpr (this->face_centroid_cache_exists) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_centroid.resize (num_faces);
+    }
+    if constexpr (this->face_normal_cache_exists) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_normal.resize (num_faces);
+    }
   }
 
  public:
diff --git a/mesh_handle/mesh_element.hxx b/mesh_handle/mesh_element.hxx
index e03c2b5b58..ce6b626a5d 100644
--- a/mesh_handle/mesh_element.hxx
+++ b/mesh_handle/mesh_element.hxx
@@ -81,6 +81,19 @@ class mesh_element: public abstract_element<mesh_class, TCompetence...> {
       this->m_dual_faces.resize (num_faces);
       this->m_neighbor_indices.resize (num_faces);
     }
+    // Resize caches for clean access.
+    if constexpr (this->face_area_cache_exists) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_area.resize (num_faces);
+    }
+    if constexpr (this->face_centroid_cache_exists) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_centroid.resize (num_faces);
+    }
+    if constexpr (this->face_normal_cache_exists) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_normal.resize (num_faces);
+    }
   }
 
  public:
diff --git a/test/mesh_handle/README.md b/test/mesh_handle/README.md
new file mode 100644
index 0000000000..4a5b95cf9a
--- /dev/null
+++ b/test/mesh_handle/README.md
@@ -0,0 +1,13 @@
+# mesh_handle testing concept #
+
+In this folder, we test the mesh handle functionality. 
+The tests are structured as follow: 
+
+- [t8_gtest_mesh_handle.cxx](t8_gtest_mesh_handle.cxx) tests some basic functionality, e.g., if the mesh handle generally works with more than one competence or the iterator. The handle's functionality is not tested in detail, but instead using some exemplary functions.
+- [t8_gtest_custom_competence.cxx](t8_gtest_custom_competence.cxx) checks that user defined competences can be used for the mesh handle.
+- [t8_gtest_compare_handle_to_forest.cxx](t8_gtest_compare_handle_to_forest.cxx) tests that the functionality of the handle gives the same results as if worked with the forest directly. This test checks each function. 
+- [t8_gtest_cache_competence.cxx](t8_gtest_cache_competence.cxx) tests that all predefined caching competences work as intended.
+- [t8_gtest_ghost.cxx](t8_gtest_ghost.cxx) checks ghosts and the neighbor algorithm. Furthermore tests if all functions work also for ghost cells if applicable.
+- [t8_gtest_handle_data.cxx](t8_gtest_handle_data.cxx) defines tests for user and element data.
+- [t8_gtest_adapt.cxx](t8_gtest_adapt.cxx) checks that the adapt routine works as intended and compares it with the result of an adapted forest.
+
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 5906518512..0088827a79 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -50,6 +50,21 @@ struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
   }
 };
 
+/** Child class of \ref t8_mesh_handle::cache_diameter that allows to modify the cache variable for test purposes. */
+template <typename TUnderlying>
+struct cache_diameter_overwrite: public t8_mesh_handle::cache_diameter<TUnderlying>
+{
+ public:
+  /** Overwrites the cache variable for the diameter.
+   * \param [in] new_diameter New diameter. 
+   */
+  void
+  overwrite_cache (double new_diameter) const
+  {
+    this->m_diameter = new_diameter;
+  }
+};
+
 /** Child class of \ref t8_mesh_handle::cache_vertex_coordinates that allows to modify the cache variable for test purposes. */
 template <typename TUnderlying>
 struct cache_vertex_coordinates_overwrite: public t8_mesh_handle::cache_vertex_coordinates<TUnderlying>
@@ -107,6 +122,28 @@ TEST (t8_gtest_cache_competence, cache_volume)
   }
 }
 
+/** Use child class of \ref t8_mesh_handle::cache_diameter class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (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 element_class = typename mesh_class::abstract_element_class;
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_diameter_cache ());
+
+  double unrealistic_diameter = -3000;
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
+    EXPECT_FALSE (it->diameter_cache_filled ());
+    EXPECT_GE (it->get_diameter (), 0);
+    EXPECT_TRUE (it->diameter_cache_filled ());
+    it->overwrite_cache (unrealistic_diameter);
+    EXPECT_EQ (it->get_diameter (), unrealistic_diameter);
+  }
+}
+
 /** Use child class of \ref t8_mesh_handle::cache_vertex_coordinates class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
@@ -170,3 +207,49 @@ TEST (t8_gtest_cache_competence, cache_centroid)
     EXPECT_EQ (it->get_centroid (), unrealistic_centroid);
   }
 }
+
+// --- Face related caches. ---
+
+/** Child class of \ref t8_mesh_handle::cache_face_area that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_face_area_overwrite: public t8_mesh_handle::cache_face_area<TUnderlying>
+{
+ public:
+  /** Overwrites the cache variable for the face area.
+   * \param [in] face The face for which the cache should be set.
+   * \param [in] new_face_area New face area. 
+   */
+  void
+  overwrite_cache (int face, double new_face_area) const
+  {
+    this->m_face_area[face] = new_face_area;
+  }
+};
+
+/** Use child class of \ref t8_mesh_handle::cache_face_area class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (t8_gtest_cache_competence, cache_face_area)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_area_overwrite>>;
+  using element_class = typename mesh_class::abstract_element_class;
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_face_area_cache ());
+
+  //double unrealistic_face_area = 41.1;
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_area_cache_filled (iface));
+      // auto face_area = it->get_face_area (iface);
+      // EXPECT_LE (0, face_area);
+      // EXPECT_TRUE (it->face_area_cache_filled (iface));
+      //it->overwrite_cache (iface,unrealistic_face_area+iface);
+      // EXPECT_EQ (it->get_face_area (iface), unrealistic_face_area+iface);
+      std::cout << "here";
+    }
+  }
+}
+
+//TODO: Add tests for face centroid and face normal caches. Also add these to compare handle to forest.
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 9753911855..258d6d4879 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -129,119 +129,119 @@ TEST_P (t8_mesh_ghost_test, check_ghosts)
   }
 }
 
-// /** Check that the function \ref t8_mesh_handle::mesh_element::get_face_neighbors of the handle works as intended (equal results to forest).*/
-// TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
-// {
-//   ASSERT_TRUE (t8_forest_is_committed (forest));
-
-//   t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
-//   EXPECT_EQ (mesh.get_num_local_ghosts (), t8_forest_get_num_ghosts (forest));
-
-//   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
-//   const t8_scheme* scheme = t8_forest_get_scheme (forest);
-//   auto mesh_iterator = mesh.begin ();
-//   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
-//     const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
-//     for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
-//       // --- Compare elements. ---
-//       EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
-//       EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
-//       // --- Compare neighbors. ---
-//       const t8_element_t* elem = t8_forest_get_leaf_element_in_tree (forest, itree, ielem);
-//       const int num_faces = scheme->element_get_num_faces (tree_class, elem);
-//       EXPECT_EQ (mesh_iterator->get_num_faces (), num_faces);
-//       for (int iface = 0; iface < num_faces; iface++) {
-//         // --- Get neighbors from forest. ---
-//         t8_element_t** neighbors;
-//         int num_neighbors;
-//         const int forest_is_balanced = t8_forest_is_balanced (forest);
-//         t8_eclass_t neigh_eclass;
-//         int* dual_faces;
-//         t8_locidx_t* neigh_ids;
-//         t8_forest_leaf_face_neighbors (forest, itree, elem, &neighbors, iface, &dual_faces, &num_neighbors, &neigh_ids,
-//                                        &neigh_eclass, forest_is_balanced);
-//         // --- Get neighbors from mesh element. ---
-//         int num_neighbors_handle;
-//         std::vector<int> dual_faces_handle;
-//         auto neighbor_ids_handle = mesh_iterator->get_face_neighbors (iface, &num_neighbors_handle, &dual_faces_handle);
-//         // --- Compare results. ---
-//         EXPECT_EQ ((int) neighbor_ids_handle.size (), num_neighbors_handle);
-//         EXPECT_EQ (num_neighbors, num_neighbors_handle);
-//         EXPECT_EQ (dual_faces_handle, std::vector<int> (dual_faces, dual_faces + num_neighbors));
-//         EXPECT_EQ (neighbor_ids_handle, std::vector<t8_locidx_t> (neigh_ids, neigh_ids + num_neighbors));
-//         for (int ineigh = 0; ineigh < num_neighbors; ineigh++) {
-//           EXPECT_EQ (scheme->element_get_shape (neigh_eclass, neighbors[ineigh]),
-//                      mesh[neighbor_ids_handle[ineigh]].get_shape ());
-//         }
-//         // Free memory.
-//         if (num_neighbors > 0) {
-//           scheme->element_destroy (neigh_eclass, num_neighbors, neighbors);
-//           T8_FREE (neigh_ids);
-//           T8_FREE (neighbors);
-//           T8_FREE (dual_faces);
-//         }
-//       }
-//       // Evolve mesh iterator.
-//       mesh_iterator++;
-//     }
-//   }
-// }
-
-// /** Child class of \ref t8_mesh_handle::cache_neighbors that allows to modify the cache variables for test purposes. */
-// template <typename TUnderlying>
-// struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderlying>
-// {
-//  public:
-//   /** Overwrites the cache variables for the a \ref face.
-//    * \param [in] face              Face for which the cache should be overwritten.
-//    * \param [in] neighbor_indices  New cache vector for the neighbor indices.
-//    * \param [in] num_neighbors     New cache value for the number of neighbors.
-//    * \param [in] dual_faces        New cache vector for the dual faces.
-//    */
-//   void
-//   overwrite_cache (int face, std::vector<t8_locidx_t> neighbor_indices, int num_neighbors,
-//                    std::vector<int> dual_faces) const
-//   {
-//     this->m_neighbor_indices[face] = neighbor_indices;
-//     this->m_num_neighbors[face] = num_neighbors;
-//     this->m_dual_faces[face] = dual_faces;
-//   }
-// };
-
-// /** Use child class of \ref t8_mesh_handle::cache_neighbors class to check that the cache is actually set
-//  * and accessed correctly. This is done by modifying the cache variables to a unrealistic values and
-//  * checking that the functionality actually outputs this unrealistic value.
-//  */
-// TEST_P (t8_mesh_ghost_test, cache_neighbors)
-// {
-//   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
-//   using element_class = typename mesh_class::mesh_element_class;
-//   mesh_class mesh = mesh_class (forest);
-//   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
-
-//   const std::vector<t8_locidx_t> unrealistic_neighbor_indices = { 9999, 99989997 };
-//   const int unrealistic_num_neighbors = 2;
-//   const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
-//   for (auto it = mesh.begin (); it != mesh.end (); ++it) {
-//     // Check that cache is empty at the beginning.
-//     EXPECT_FALSE (it->neighbor_cache_filled_any ());
-//     it->fill_face_neighbor_cache ();
-//     for (int iface = 0; iface < it->get_num_faces (); iface++) {
-//       EXPECT_TRUE (it->neighbor_cache_filled (iface));
-//       int num_neighbors = -1;
-//       std::vector<int> dual_faces;
-//       auto neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
-//       EXPECT_EQ ((int) neighbor_ids.size (), num_neighbors);
-//       // Overwrite cache with unrealistic values.
-//       it->overwrite_cache (iface, unrealistic_neighbor_indices, unrealistic_num_neighbors, unrealistic_dual_faces);
-//       EXPECT_TRUE (it->neighbor_cache_filled (iface));
-//       neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
-//       // --- Compare results. ---
-//       EXPECT_EQ (neighbor_ids, unrealistic_neighbor_indices);
-//       EXPECT_EQ (num_neighbors, unrealistic_num_neighbors);
-//       EXPECT_EQ (dual_faces, unrealistic_dual_faces);
-//     }
-//   }
-// }
+/** Check that the function \ref t8_mesh_handle::mesh_element::get_face_neighbors of the handle works as intended (equal results to forest).*/
+TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
+{
+  ASSERT_TRUE (t8_forest_is_committed (forest));
+
+  t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  EXPECT_EQ (mesh.get_num_local_ghosts (), t8_forest_get_num_ghosts (forest));
+
+  // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
+  const t8_scheme* scheme = t8_forest_get_scheme (forest);
+  auto mesh_iterator = mesh.begin ();
+  for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
+    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
+    for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
+      // --- Compare elements. ---
+      EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
+      EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
+      // --- Compare neighbors. ---
+      const t8_element_t* elem = t8_forest_get_leaf_element_in_tree (forest, itree, ielem);
+      const int num_faces = scheme->element_get_num_faces (tree_class, elem);
+      EXPECT_EQ (mesh_iterator->get_num_faces (), num_faces);
+      for (int iface = 0; iface < num_faces; iface++) {
+        // --- Get neighbors from forest. ---
+        t8_element_t** neighbors;
+        int num_neighbors;
+        const int forest_is_balanced = t8_forest_is_balanced (forest);
+        t8_eclass_t neigh_eclass;
+        int* dual_faces;
+        t8_locidx_t* neigh_ids;
+        t8_forest_leaf_face_neighbors (forest, itree, elem, &neighbors, iface, &dual_faces, &num_neighbors, &neigh_ids,
+                                       &neigh_eclass, forest_is_balanced);
+        // --- Get neighbors from mesh element. ---
+        int num_neighbors_handle;
+        std::vector<int> dual_faces_handle;
+        auto neighbor_ids_handle = mesh_iterator->get_face_neighbors (iface, &num_neighbors_handle, &dual_faces_handle);
+        // --- Compare results. ---
+        EXPECT_EQ ((int) neighbor_ids_handle.size (), num_neighbors_handle);
+        EXPECT_EQ (num_neighbors, num_neighbors_handle);
+        EXPECT_EQ (dual_faces_handle, std::vector<int> (dual_faces, dual_faces + num_neighbors));
+        EXPECT_EQ (neighbor_ids_handle, std::vector<t8_locidx_t> (neigh_ids, neigh_ids + num_neighbors));
+        for (int ineigh = 0; ineigh < num_neighbors; ineigh++) {
+          EXPECT_EQ (scheme->element_get_shape (neigh_eclass, neighbors[ineigh]),
+                     mesh[neighbor_ids_handle[ineigh]].get_shape ());
+        }
+        // Free memory.
+        if (num_neighbors > 0) {
+          scheme->element_destroy (neigh_eclass, num_neighbors, neighbors);
+          T8_FREE (neigh_ids);
+          T8_FREE (neighbors);
+          T8_FREE (dual_faces);
+        }
+      }
+      // Evolve mesh iterator.
+      mesh_iterator++;
+    }
+  }
+}
+
+/** Child class of \ref t8_mesh_handle::cache_neighbors that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_neighbors_overwrite: public t8_mesh_handle::cache_neighbors<TUnderlying>
+{
+ public:
+  /** Overwrites the cache variables for the a \ref face.
+   * \param [in] face              Face for which the cache should be overwritten.
+   * \param [in] neighbor_indices  New cache vector for the neighbor indices.
+   * \param [in] num_neighbors     New cache value for the number of neighbors.
+   * \param [in] dual_faces        New cache vector for the dual faces.
+   */
+  void
+  overwrite_cache (int face, std::vector<t8_locidx_t> neighbor_indices, int num_neighbors,
+                   std::vector<int> dual_faces) const
+  {
+    this->m_neighbor_indices[face] = neighbor_indices;
+    this->m_num_neighbors[face] = num_neighbors;
+    this->m_dual_faces[face] = dual_faces;
+  }
+};
+
+/** Use child class of \ref t8_mesh_handle::cache_neighbors class to check that the cache is actually set
+ * and accessed correctly. This is done by modifying the cache variables to a unrealistic values and
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST_P (t8_mesh_ghost_test, cache_neighbors)
+{
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
+  using element_class = typename mesh_class::mesh_element_class;
+  mesh_class mesh = mesh_class (forest);
+  EXPECT_TRUE (element_class::has_face_neighbor_cache ());
+
+  const std::vector<t8_locidx_t> unrealistic_neighbor_indices = { 9999, 99989997 };
+  const int unrealistic_num_neighbors = 2;
+  const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
+  for (auto it = mesh.begin (); it != mesh.end (); ++it) {
+    // Check that cache is empty at the beginning.
+    EXPECT_FALSE (it->neighbor_cache_filled_any ());
+    it->fill_face_neighbor_cache ();
+    for (int iface = 0; iface < it->get_num_faces (); iface++) {
+      EXPECT_TRUE (it->neighbor_cache_filled (iface));
+      int num_neighbors = -1;
+      std::vector<int> dual_faces;
+      auto neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
+      EXPECT_EQ ((int) neighbor_ids.size (), num_neighbors);
+      // Overwrite cache with unrealistic values.
+      it->overwrite_cache (iface, unrealistic_neighbor_indices, unrealistic_num_neighbors, unrealistic_dual_faces);
+      EXPECT_TRUE (it->neighbor_cache_filled (iface));
+      neighbor_ids = it->get_face_neighbors (iface, &num_neighbors, &dual_faces);
+      // --- Compare results. ---
+      EXPECT_EQ (neighbor_ids, unrealistic_neighbor_indices);
+      EXPECT_EQ (num_neighbors, unrealistic_num_neighbors);
+      EXPECT_EQ (dual_faces, unrealistic_dual_faces);
+    }
+  }
+}
 
 INSTANTIATE_TEST_SUITE_P (t8_gtest_ghost, t8_mesh_ghost_test, testing::Combine (AllEclasses, testing::Range (1, 2)));

From 72c73241c4d07f4e5401bbef43dd7205de37eeee Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Mon, 5 Jan 2026 13:23:26 +0100
Subject: [PATCH 4/7] uncomment test

---
 test/mesh_handle/t8_gtest_cache_competence.cxx | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index 0088827a79..51b5c5435b 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -238,15 +238,15 @@ TEST (t8_gtest_cache_competence, cache_face_area)
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_area_cache ());
 
-  //double unrealistic_face_area = 41.1;
+  double unrealistic_face_area = 41.1;
   for (auto it = mesh->begin (); it != mesh->end (); ++it) {
     for (int iface = 0; iface < it->get_num_faces (); ++iface) {
       EXPECT_FALSE (it->face_area_cache_filled (iface));
-      // auto face_area = it->get_face_area (iface);
-      // EXPECT_LE (0, face_area);
-      // EXPECT_TRUE (it->face_area_cache_filled (iface));
-      //it->overwrite_cache (iface,unrealistic_face_area+iface);
-      // EXPECT_EQ (it->get_face_area (iface), unrealistic_face_area+iface);
+      auto face_area = it->get_face_area (iface);
+      EXPECT_LE (0, face_area);
+      EXPECT_TRUE (it->face_area_cache_filled (iface));
+      it->overwrite_cache (iface, unrealistic_face_area + iface);
+      EXPECT_EQ (it->get_face_area (iface), unrealistic_face_area + iface);
       std::cout << "here";
     }
   }

From 7bd8f36dcbfcf19df008d7d0a84f823782545ba1 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Fri, 9 Jan 2026 12:05:00 +0100
Subject: [PATCH 5/7] update after merge

---
 mesh_handle/element.hxx                       | 252 +++++++++++++++++-
 .../mesh_handle/t8_gtest_cache_competence.cxx |  16 +-
 .../t8_gtest_custom_competence.cxx            |   4 +-
 test/mesh_handle/t8_gtest_handle_data.cxx     |  38 +--
 4 files changed, 274 insertions(+), 36 deletions(-)

diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index cb74480d3e..ff72d24291 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -91,6 +91,19 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       this->m_dual_faces.resize (num_faces);
       this->m_neighbors.resize (num_faces);
     }
+    // Resize caches for clean access.
+    if constexpr (has_face_area_cache ()) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_area.resize (num_faces);
+    }
+    if constexpr (has_face_centroid_cache ()) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_centroid.resize (num_faces);
+    }
+    if constexpr (has_face_normal_cache ()) {
+      const int num_faces = this->get_num_faces ();
+      this->m_face_normal.resize (num_faces);
+    }
   }
 
   // --- Variables to check which functionality is defined in TCompetence. ---
@@ -104,6 +117,16 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
   }
+  /** Helper function to check if class T implements the function diameter_cache_defined.
+   * \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
+  diameter_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.diameter_cache_filled (); };
+  }
   /** Helper function to check if class T implements the function vertex_cache_filled.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
@@ -134,6 +157,36 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
   }
+  /** Helper function to check if class T implements the function face_area_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_area_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_area_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_centroid_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_centroid_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_centroid_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_normal_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_normal_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_normal_cache_filled (0); };
+  }
 
  public:
   // --- Public functions to check if caches exist. ---
@@ -146,6 +199,15 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return (false || ... || volume_cache_defined<TCompetence> ());
   }
+  /**
+   * Function that checks if a cache for the element's diameter exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_diameter_cache ()
+  {
+    return (false || ... || diameter_cache_defined<TCompetence> ());
+  }
   /**
    * Function that checks if a cache for the vertex coordinates exists.
    * \return true if a cache for the vertex coordinates exists, false otherwise.
@@ -175,6 +237,35 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return (false || ... || neighbor_cache_defined<TCompetence> ());
   }
+  /**
+   * Function that checks if a cache for the element's face area exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_face_area_cache ()
+  {
+    return (false || ... || face_area_cache_defined<TCompetence> ());
+  }
+
+  /**
+   * Function that checks if a cache for the element's face centroid exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_face_centroid_cache ()
+  {
+    return (false || ... || face_centroid_cache_defined<TCompetence> ());
+  }
+
+  /**
+   * Function that checks if a cache for the element's face normal exists.
+   * \return true if a cache exists, false otherwise.
+   */
+  static constexpr bool
+  has_face_normal_cache ()
+  {
+    return (false || ... || face_normal_cache_defined<TCompetence> ());
+  }
 
   // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
   /**
@@ -201,6 +292,17 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_faces (get_tree_class (), get_element ());
   }
 
+  /**
+   * Getter for the number of vertices of the element.
+   * For this easily accessible variable, it makes no sense to provide a cached version.
+   * \return Number of vertices of the element.
+   */
+  int
+  get_num_vertices () const
+  {
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), get_element ());
+  }
+
   /**
    * Getter for the element's shape.
    * For this easily accessible variable, it makes no sense to provide a cached version.
@@ -221,16 +323,34 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   get_volume () const
   {
     if constexpr (has_volume_cache ()) {
-      if (this->volume_cache_filled ()) {
-        return this->m_volume.value ();
+      if (!this->volume_cache_filled ()) {
+        // Fill cache.
+        this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
       }
-      // Fill cache.
-      this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
       return this->m_volume.value ();
     }
     return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
   }
 
+  /**
+   * Getter for the element's diameter.
+   * This is only an approximation.
+   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * \return The diameter of the element.
+   */
+  double
+  get_diameter () const
+  {
+    if constexpr (has_diameter_cache ()) {
+      if (!this->diameter_cache_filled ()) {
+        // Fill cache.
+        this->m_diameter = t8_forest_element_diam (m_mesh->m_forest, m_tree_id, get_element ());
+      }
+      return this->m_diameter.value ();
+    }
+    return t8_forest_element_diam (m_mesh->m_forest, m_tree_id, get_element ());
+  }
+
   /**
    * Getter for the vertex coordinates of the element.
    * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
@@ -246,12 +366,11 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       }
     }
     // Calculate the vertex coordinates.
-    const t8_element_t* element = get_element ();
-    const int num_corners
-      = t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), element);
+    const int num_corners = get_num_vertices ();
     std::vector<t8_3D_point> vertex_coordinates (num_corners);
     for (int icorner = 0; icorner < num_corners; ++icorner) {
-      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, element, icorner, vertex_coordinates[icorner].data ());
+      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, get_element (), icorner,
+                                    vertex_coordinates[icorner].data ());
     }
     // Fill the cache in the cached version.
     if constexpr (has_vertex_cache ()) {
@@ -261,6 +380,30 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return vertex_coordinates;
   }
 
+  /**
+   * Getter for the coordinates of one specific vertex of the element.
+   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   * The cache is filled for all vertices simultaneously.
+   * \param [in] vertex Index of the vertex.
+   * \return Coordinates of the vertex.
+   */
+  t8_3D_point
+  get_vertex_coordinates (int vertex) const
+  {
+    T8_ASSERT (vertex < get_num_vertices ());
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (has_vertex_cache ()) {
+      if (!this->vertex_cache_filled ()) {
+        get_vertex_coordinates ();
+      }
+      return this->m_vertex_coordinates[vertex];
+    }
+    // Calculate the vertex coordinates.
+    t8_3D_point coordinates;
+    t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, get_element (), vertex, coordinates.data ());
+    return coordinates;
+  }
+
   /**
    * Getter for the center of mass of the element.
    * This function uses the cached version defined in TCompetence if available and calculates if not.
@@ -349,6 +492,99 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     }
   }
 
+  // --- Getter for face properties. ---
+  /** The area of a face of the element.
+   * This is only an approximation.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The area of \a face.
+   */
+  double
+  get_face_area (int face) const
+  {
+
+    if constexpr (has_face_area_cache ()) {
+      if (!this->face_area_cache_filled (face)) {
+        // Fill cache.
+        this->m_face_area[face] = t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
+      }
+      return this->m_face_area[face].value ();
+    }
+    return t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
+  }
+
+  /** The centroid of a face of the element.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The centroid of \a face.
+   */
+  t8_3D_point
+  get_face_centroid (int face) const
+  {
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (has_face_centroid_cache ()) {
+      if (this->face_centroid_cache_filled (face)) {
+        return this->m_face_centroid[face];
+      }
+    }
+    t8_3D_point coordinates;
+    t8_forest_element_face_centroid (m_mesh->m_forest, m_tree_id, get_element (), face, coordinates.data ());
+    // Fill the cache in the cached version.
+    if constexpr (has_face_centroid_cache ()) {
+      this->m_face_centroid[face] = coordinates;
+    }
+    return coordinates;
+  }
+
+  /** The normal vector of a face of the element.
+   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   * \param [in] face Index of a face of the element.
+   * \return The normal vector of \a face.
+   */
+  t8_3D_vec
+  get_face_normal (int face) const
+  {
+
+    // Check if we have a cached version and if the cache has already been filled.
+    if constexpr (has_face_normal_cache ()) {
+      if (this->face_normal_cache_filled (face)) {
+        return this->m_face_normal[face];
+      }
+    }
+    t8_3D_vec normal;
+    t8_forest_element_face_normal (m_mesh->m_forest, m_tree_id, get_element (), face, normal.data ());
+    // Fill the cache in the cached version.
+    if constexpr (has_face_normal_cache ()) {
+      this->m_face_normal[face] = normal;
+    }
+    return normal;
+  }
+
+  /**
+   * Getter for the element's face shape.
+   * For this easily accessible variable, it makes no sense to provide a cached version.
+   * \param [in] face Index of a face of the element.
+   * \return The shape of the face of the element.
+   */
+  t8_element_shape_t
+  get_face_shape (int face) const
+  {
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_face_shape (get_tree_class (), get_element (), face);
+  }
+
+  // --- Print for the element for debugging purpose. ---
+#if T8_ENABLE_DEBUG
+  /** Print the element. 
+    * For a example for a triangle print the coordinates and the level of the triangle. 
+    * This function is only available in the debugging configuration.
+    */
+  void
+  print_element_debug () const
+  {
+    t8_forest_get_scheme (m_mesh->m_forest)->element_debug_print (get_tree_class (), get_element ());
+  }
+#endif
+
   // --- Function to access mesh specific id. ---
   /**
    * Getter for the index of the element in the mesh to which the element belongs.
diff --git a/test/mesh_handle/t8_gtest_cache_competence.cxx b/test/mesh_handle/t8_gtest_cache_competence.cxx
index be9e9c0fc2..e5841271a6 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -108,7 +108,7 @@ TEST (t8_gtest_cache_competence, cache_volume)
   EXPECT_TRUE (element_class::has_volume_cache ());
 
   double unrealistic_volume = -3000;
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->volume_cache_filled ());
     // Fill cache and check that volume is valid.
@@ -130,12 +130,12 @@ 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 element_class = typename mesh_class::abstract_element_class;
+  using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());
 
   double unrealistic_diameter = -3000;
-  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->diameter_cache_filled ());
     EXPECT_GE (it->get_diameter (), 0);
     EXPECT_TRUE (it->diameter_cache_filled ());
@@ -157,10 +157,10 @@ TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
   EXPECT_TRUE (element_class::has_vertex_cache ());
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->vertex_cache_filled ());
-    // Check that values are valid.
+    // Fill and check that values are valid.
     auto vertex_coordinates = it->get_vertex_coordinates ();
     for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
       for (const auto &coordinate : vertex_coordinates[ivertex]) {
@@ -190,7 +190,7 @@ TEST (t8_gtest_cache_competence, cache_centroid)
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->centroid_cache_filled ());
     // Check that values are valid.
@@ -234,12 +234,12 @@ TEST (t8_gtest_cache_competence, cache_face_area)
 {
   const int level = 1;
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_area_overwrite>>;
-  using element_class = typename mesh_class::abstract_element_class;
+  using element_class = typename mesh_class::element_class;
   auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_area_cache ());
 
   double unrealistic_face_area = 41.1;
-  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     for (int iface = 0; iface < it->get_num_faces (); ++iface) {
       EXPECT_FALSE (it->face_area_cache_filled (iface));
       auto face_area = it->get_face_area (iface);
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 037915e908..003faa2e30 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -88,7 +88,7 @@ TEST (t8_gtest_custom_competence, custom_competence)
   using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
   const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (level, it->get_level_dummy ());
   }
@@ -98,7 +98,7 @@ TEST (t8_gtest_custom_competence, custom_competence)
   using mesh_class = t8_mesh_handle::mesh<competences>;
   auto mesh_more_competences = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
-  for (auto it = mesh_more_competences.cbegin (); it != mesh_more_competences.cend (); ++it) {
+  for (auto it = mesh_more_competences->cbegin (); it != mesh_more_competences->cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (it->get_value_dummy (), 1);
     EXPECT_FALSE (it->centroid_cache_filled ());
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index e9d45aa824..a028cc8d00 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -88,6 +88,7 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
     // Ensure that we actually test with ghost elements.
     EXPECT_GT (mesh->get_num_ghosts (), 0);
   }
+  auto forest = mesh->get_forest ();
 
   // Create element data for all local mesh elements.
   std::vector<data_per_element> element_data;
@@ -97,41 +98,42 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
   mesh->set_element_data (element_data);
   // Get element data and check that the data for all elements (including ghosts) is correct.
   auto mesh_element_data = mesh->exchange_ghost_data ();
-  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements () + mesh.get_num_ghosts (); ielem++) {
+  for (t8_locidx_t ielem = 0; ielem < mesh->get_num_local_elements () + mesh->get_num_ghosts (); ielem++) {
     EXPECT_EQ (mesh_element_data[ielem].level, level) << "ielem = " << ielem;
     EXPECT_EQ (mesh_element_data[ielem].volume, (*mesh)[ielem].get_volume ()) << "ielem = " << ielem;
   }
   t8_gloidx_t barrier = t8_forest_get_num_global_trees (forest) / 2.0;
   const int newlevel = 42;
   const double newvolume = 42.42;
-  for (auto &elem : mesh) {
+  for (auto &elem : *mesh) {
     if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
       elem.set_element_data ({ newlevel, newvolume });
     }
   }
-  mesh.exchange_ghost_data ();
-  for (t8_locidx_t ielem = 0; ielem < mesh.get_num_local_elements (); ielem++) {
-    if (t8_forest_global_tree_id (forest, mesh[ielem].get_local_tree_id ()) < barrier) {
-      EXPECT_EQ (mesh[ielem].get_element_data ().level, newlevel) << "ielem = " << ielem;
-      EXPECT_EQ (mesh[ielem].get_element_data ().volume, newvolume) << "ielem = " << ielem;
+  mesh->exchange_ghost_data ();
+  // Check for mesh elements with updated data.
+  for (auto &elem : *mesh) {
+    if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
+      EXPECT_EQ (elem.get_element_data ().level, newlevel);
+      EXPECT_EQ (elem.get_element_data ().volume, newvolume);
     }
     else {
-      EXPECT_EQ (mesh[ielem].get_element_data ().level, level) << "ielem = " << ielem;
-      EXPECT_EQ (mesh[ielem].get_element_data ().volume, mesh[ielem].get_volume ()) << "ielem = " << ielem;
+      EXPECT_EQ (elem.get_element_data ().level, level);
+      EXPECT_EQ (elem.get_element_data ().volume, elem.get_volume ());
     }
   }
-
-  for (t8_locidx_t ighost = mesh.get_num_local_elements ();
-       ighost < mesh.get_num_local_elements () + mesh.get_num_ghosts (); ighost++) {
-    if (t8_forest_ghost_get_global_treeid (forest,
-                                           mesh[ighost].get_local_tree_id () - t8_forest_get_num_local_trees (forest))
+  // Check fpor ghost elements with updated data.
+  for (t8_locidx_t ighost = mesh->get_num_local_elements ();
+       ighost < mesh->get_num_local_elements () + mesh->get_num_ghosts (); ighost++) {
+    if (t8_forest_ghost_get_global_treeid (
+          forest, (*mesh)[ighost].get_local_tree_id () - t8_forest_get_num_local_trees (forest))
         < barrier) {
-      EXPECT_EQ (mesh[ighost].get_element_data ().level, newlevel);
-      EXPECT_EQ (mesh[ighost].get_element_data ().volume, newvolume);
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().level, newlevel);
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().volume, newvolume);
     }
     else {
-      EXPECT_EQ (mesh[ighost].get_element_data ().level, level);
-      EXPECT_EQ (mesh[ighost].get_element_data ().volume, mesh[ighost].get_volume ());
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().level, level);
+      EXPECT_EQ ((*mesh)[ighost].get_element_data ().volume, (*mesh)[ighost].get_volume ());
     }
   }
 }

From db4cb491c2d8cb1a57f1401a7695a58242329561 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Fri, 9 Jan 2026 13:56:57 +0100
Subject: [PATCH 6/7] new cstar, restructuring, improvement

---
 mesh_handle/competences.hxx                   |   8 +-
 mesh_handle/constructor_wrapper.hxx           |  29 +-
 mesh_handle/element.hxx                       | 387 ++++++++----------
 .../mesh_handle/t8_gtest_cache_competence.cxx |  10 +-
 .../t8_gtest_custom_competence.cxx            |   6 +-
 test/mesh_handle/t8_gtest_handle_data.cxx     |   6 +-
 test/mesh_handle/t8_gtest_mesh_handle.cxx     |  47 +--
 7 files changed, 234 insertions(+), 259 deletions(-)

diff --git a/mesh_handle/competences.hxx b/mesh_handle/competences.hxx
index 57f368f69d..a7a2616912 100644
--- a/mesh_handle/competences.hxx
+++ b/mesh_handle/competences.hxx
@@ -73,7 +73,7 @@ struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
 
 /**
  * Competence to cache the diameter of an element at the first function call.
- * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
  */
 template <typename TUnderlying>
 struct cache_diameter: public t8_crtp_operator<TUnderlying, cache_diameter>
@@ -142,7 +142,7 @@ struct cache_centroid: public t8_crtp_operator<TUnderlying, cache_centroid>
 
 /**
  * Competence to cache the area of a specific face at the first function call.
- * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
  */
 template <typename TUnderlying>
 struct cache_face_area: t8_crtp_operator<TUnderlying, cache_face_area>
@@ -165,7 +165,7 @@ struct cache_face_area: t8_crtp_operator<TUnderlying, cache_face_area>
 
 /**
  * Competence to cache the centroid of a specific face at the first function call.
- * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
  */
 template <typename TUnderlying>
 struct cache_face_centroid: t8_crtp_operator<TUnderlying, cache_face_centroid>
@@ -188,7 +188,7 @@ struct cache_face_centroid: t8_crtp_operator<TUnderlying, cache_face_centroid>
 
 /**
  * Competence to cache the normal of a specific face at the first function call.
- * \tparam TUnderlying Use the \ref abstract_element with specified competences as template parameter.
+ * \tparam TUnderlying Use the \ref element with specified competences as template parameter.
  */
 template <typename TUnderlying>
 struct cache_face_normal: t8_crtp_operator<TUnderlying, cache_face_normal>
diff --git a/mesh_handle/constructor_wrapper.hxx b/mesh_handle/constructor_wrapper.hxx
index 483ffe9a27..56d366a8f3 100644
--- a/mesh_handle/constructor_wrapper.hxx
+++ b/mesh_handle/constructor_wrapper.hxx
@@ -21,7 +21,7 @@
 */
 
 /** \file constructor_wrapper.hxx
- * Wrapper for the mesh constructor from a cmesh and some default cmeshes.
+ * Construct a mesh handle instance from a cmesh and some default mesh handles.
  */
 
 #ifndef T8_CONSTRUCTOR_WRAPPER_HXX
@@ -55,7 +55,7 @@ handle_new_uniform_default (const t8_cmesh_t cmesh, const int level, const sc_MP
   return std::make_unique<TMesh> (forest);
 }
 
-/** Hybercube with 6 Tets, 6 Prism, 4 Hex. Refined uniformly to given level.
+/** Hybercube with 6 Tets, 6 Prism, 4 Hex. Refined uniformly to given level using the default scheme.
  * \param [in] level         An initial uniform refinement level.
  * \param [in] comm          MPI communicator to use.
  * \param [in] do_partition  If non-zero create a partitioned cmesh.
@@ -67,12 +67,33 @@ handle_new_uniform_default (const t8_cmesh_t cmesh, const int level, const sc_MP
 */
 template <typename TMesh>
 std::unique_ptr<TMesh>
-handle_hypercube_uniform_default (const int level, const sc_MPI_Comm comm, const bool do_partition = false,
-                                  const bool do_face_ghost = false, const bool periodic = false)
+handle_hybrid_hypercube_uniform_default (const int level, const sc_MPI_Comm comm, const bool do_partition = false,
+                                         const bool do_face_ghost = false, const bool periodic = false)
 {
   t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (comm, do_partition, periodic);
   return handle_new_uniform_default<TMesh> (cmesh, level, comm, do_face_ghost);
 }
 
+/** Construct hybercube from one primitive tree class. Refined uniformly to given level using the default scheme.
+ * \param [in] eclass        This element class determines the dimension and the number of trees needed to construct a cube.
+ * \param [in] level         An initial uniform refinement level.
+ * \param [in] comm          MPI communicator to use.
+ * \param [in] do_partition  If non-zero create a partitioned cmesh.
+ * \param [in] do_face_ghost If true, a layer of ghost elements is created.
+ * \param [in] periodic      If non-zero create a periodic cmesh in each direction. Not possible with \a eclass pyramid.
+ * \tparam TMesh             The mesh handle class.
+ * \return Unique pointer to a uniformly refined mesh handle hypercube.
+*/
+template <typename TMesh>
+std::unique_ptr<TMesh>
+handle_hypercube_uniform_default (t8_eclass_t eclass, const int level, const sc_MPI_Comm comm,
+                                  const bool do_partition = false, const bool do_face_ghost = false,
+                                  const bool periodic = false)
+{
+  // Broadcast option is hidden from the user.
+  t8_cmesh_t cmesh = t8_cmesh_new_hypercube (eclass, comm, 0, do_partition, periodic);
+  return handle_new_uniform_default<TMesh> (cmesh, level, comm, do_face_ghost);
+}
+
 }  // namespace t8_mesh_handle
 #endif /* !T8_CONSTRUCTOR_WRAPPER_HXX */
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index ff72d24291..a299534914 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -21,7 +21,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 */
 
 /** \file element.hxx
- * Definition of the element class of the \ref t8_mesh_handle::mesh handle (can be ghost or mesh elements).
+ *  Definition of the element class of the \ref t8_mesh_handle::mesh handle (can be ghost or mesh elements).
  */
 
 #ifndef T8_ELEMENT_HXX
@@ -64,9 +64,8 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     = element<mesh_class, TCompetence...>; /**< Type of the current class with all template parameters specified. */
   friend mesh_class; /**< Define mesh_class as friend to be able to access e.g. the constructor. */
 
-  /**
-   * 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).
+  /** 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).
    * \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.
@@ -75,6 +74,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   element (mesh_class* 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)
   {
+    // Cache the t8_element_t from the forest as it is often used.
     if (m_is_ghost_element) {
       // The local ghost tree id is per definition the local tree id - number of local (non-ghost) trees.
       m_element = t8_forest_ghost_get_leaf_element (
@@ -84,114 +84,30 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       m_element = t8_forest_get_leaf_element_in_tree (m_mesh->m_forest, m_tree_id, m_element_id);
     }
 
+    // Resize caches for clean access where the cache vector may not be filled completely at once.
     if constexpr (has_face_neighbor_cache ()) {
-      // Resize neighbor caches for clean access to the caches.
-      const int num_faces = this->get_num_faces ();
+      const int num_faces = get_num_faces ();
       this->m_num_neighbors.resize (num_faces);
       this->m_dual_faces.resize (num_faces);
       this->m_neighbors.resize (num_faces);
     }
-    // Resize caches for clean access.
     if constexpr (has_face_area_cache ()) {
-      const int num_faces = this->get_num_faces ();
+      const int num_faces = get_num_faces ();
       this->m_face_area.resize (num_faces);
     }
     if constexpr (has_face_centroid_cache ()) {
-      const int num_faces = this->get_num_faces ();
+      const int num_faces = get_num_faces ();
       this->m_face_centroid.resize (num_faces);
     }
     if constexpr (has_face_normal_cache ()) {
-      const int num_faces = this->get_num_faces ();
+      const int num_faces = get_num_faces ();
       this->m_face_normal.resize (num_faces);
     }
   }
 
-  // --- Variables to check which functionality is defined in TCompetence. ---
-  /** Helper function to check if class T implements the function volume_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  volume_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
-  }
-  /** Helper function to check if class T implements the function diameter_cache_defined.
-   * \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
-  diameter_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.diameter_cache_filled (); };
-  }
-  /** Helper function to check if class T implements the function vertex_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  vertex_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
-  }
-  /** Helper function to check if class T implements the function centroid_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  centroid_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
-  }
-  /** Helper function to check if class T implements the function neighbor_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  neighbor_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
-  }
-  /** Helper function to check if class T implements the function face_area_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  face_area_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.face_area_cache_filled (0); };
-  }
-  /** Helper function to check if class T implements the function face_centroid_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  face_centroid_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.face_centroid_cache_filled (0); };
-  }
-  /** Helper function to check if class T implements the function face_normal_cache_filled.
-   * \tparam T The competence to be checked.
-   * \return true if T implements the function, false if not.
-   */
-  template <template <typename> class T>
-  static constexpr bool
-  face_normal_cache_defined ()
-  {
-    return requires (T<SelfType>& competence) { competence.face_normal_cache_filled (0); };
-  }
-
  public:
   // --- Public functions to check if caches exist. ---
-  /**
-   * Function that checks if a cache for the element's volume exists.
+  /** Function that checks if a cache for the element's volume exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
@@ -199,8 +115,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return (false || ... || volume_cache_defined<TCompetence> ());
   }
-  /**
-   * Function that checks if a cache for the element's diameter exists.
+  /** Function that checks if a cache for the element's diameter exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
@@ -208,8 +123,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return (false || ... || diameter_cache_defined<TCompetence> ());
   }
-  /**
-   * Function that checks if a cache for the vertex coordinates exists.
+  /** Function that checks if a cache for the vertex coordinates exists.
    * \return true if a cache for the vertex coordinates exists, false otherwise.
    */
   static constexpr bool
@@ -218,8 +132,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return (false || ... || vertex_cache_defined<TCompetence> ());
   }
 
-  /**
-   * Function that checks if a cache for the centroid exists.
+  /** Function that checks if a cache for the centroid exists.
    * \return true if a cache for the centroid exists, false otherwise.
    */
   static constexpr bool
@@ -228,8 +141,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return (false || ... || centroid_cache_defined<TCompetence> ());
   }
 
-  /**
-   * Function that checks if a cache for the face neighbors exists.
+  /** Function that checks if a cache for the face neighbors exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
@@ -237,8 +149,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return (false || ... || neighbor_cache_defined<TCompetence> ());
   }
-  /**
-   * Function that checks if a cache for the element's face area exists.
+  /** Function that checks if a cache for the element's face area exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
@@ -247,8 +158,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return (false || ... || face_area_cache_defined<TCompetence> ());
   }
 
-  /**
-   * Function that checks if a cache for the element's face centroid exists.
+  /** Function that checks if a cache for the element's face centroid exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
@@ -257,8 +167,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return (false || ... || face_centroid_cache_defined<TCompetence> ());
   }
 
-  /**
-   * Function that checks if a cache for the element's face normal exists.
+  /** Function that checks if a cache for the element's face normal exists.
    * \return true if a cache exists, false otherwise.
    */
   static constexpr bool
@@ -268,54 +177,48 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   }
 
   // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
-  /**
-   * Getter for the refinement level of the element.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the refinement level of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \return Refinement level of the element.
    */
   t8_element_level
   get_level () const
   {
-    const t8_eclass_t eclass = get_tree_class ();
-    const t8_element_t* element = get_element ();
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_level (eclass, element);
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_level (get_tree_class (), m_element);
   }
 
-  /**
-   * Getter for the number of faces of the element.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the number of faces of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \return Number of faces of the element.
    */
   int
   get_num_faces () const
   {
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_faces (get_tree_class (), get_element ());
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_faces (get_tree_class (), m_element);
   }
 
-  /**
-   * Getter for the number of vertices of the element.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the number of vertices of the element.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \return Number of vertices of the element.
    */
   int
   get_num_vertices () const
   {
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), get_element ());
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_num_corners (get_tree_class (), m_element);
   }
 
-  /**
-   * Getter for the element's shape.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the element's shape.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \return The shape of the element.
    */
   t8_element_shape_t
   get_shape () const
   {
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_shape (get_tree_class (), get_element ());
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_shape (get_tree_class (), m_element);
   }
 
-  /**
-   * Getter for the element's volume.
+  /** Getter for the element's volume.
+   *  This is only an approximation.
    *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
    * \return The volume of the element.
    */
@@ -325,17 +228,16 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     if constexpr (has_volume_cache ()) {
       if (!this->volume_cache_filled ()) {
         // Fill cache.
-        this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
+        this->m_volume = t8_forest_element_volume (m_mesh->m_forest, m_tree_id, m_element);
       }
       return this->m_volume.value ();
     }
-    return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, get_element ());
+    return t8_forest_element_volume (m_mesh->m_forest, m_tree_id, m_element);
   }
 
-  /**
-   * Getter for the element's diameter.
-   * This is only an approximation.
-   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+  /** Getter for the element's diameter.
+   *  This is only an approximation.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
    * \return The diameter of the element.
    */
   double
@@ -344,22 +246,20 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     if constexpr (has_diameter_cache ()) {
       if (!this->diameter_cache_filled ()) {
         // Fill cache.
-        this->m_diameter = t8_forest_element_diam (m_mesh->m_forest, m_tree_id, get_element ());
+        this->m_diameter = t8_forest_element_diam (m_mesh->m_forest, m_tree_id, m_element);
       }
       return this->m_diameter.value ();
     }
-    return t8_forest_element_diam (m_mesh->m_forest, m_tree_id, get_element ());
+    return t8_forest_element_diam (m_mesh->m_forest, m_tree_id, m_element);
   }
 
-  /**
-   * Getter for the vertex coordinates of the element.
-   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+  /** Getter for the vertex coordinates of the element.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
    * \return Vector with one coordinate array for each vertex of the element.
    */
   std::vector<t8_3D_point>
   get_vertex_coordinates () const
   {
-    // Check if we have a cached version and if the cache has already been filled.
     if constexpr (has_vertex_cache ()) {
       if (this->vertex_cache_filled ()) {
         return this->m_vertex_coordinates;
@@ -369,7 +269,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     const int num_corners = get_num_vertices ();
     std::vector<t8_3D_point> vertex_coordinates (num_corners);
     for (int icorner = 0; icorner < num_corners; ++icorner) {
-      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, get_element (), icorner,
+      t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, m_element, icorner,
                                     vertex_coordinates[icorner].data ());
     }
     // Fill the cache in the cached version.
@@ -380,10 +280,9 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return vertex_coordinates;
   }
 
-  /**
-   * Getter for the coordinates of one specific vertex of the element.
-   * This function uses or sets the cached version defined in TCompetence if available and calculates if not.
-   * The cache is filled for all vertices simultaneously.
+  /** Getter for the coordinates of one specific vertex of the element.
+   *  This function uses or sets the cached version defined in TCompetence if available and calculates if not.
+   *  The cache is filled for all vertices simultaneously.
    * \param [in] vertex Index of the vertex.
    * \return Coordinates of the vertex.
    */
@@ -398,14 +297,12 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       }
       return this->m_vertex_coordinates[vertex];
     }
-    // Calculate the vertex coordinates.
     t8_3D_point coordinates;
-    t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, get_element (), vertex, coordinates.data ());
+    t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, m_element, vertex, coordinates.data ());
     return coordinates;
   }
 
-  /**
-   * Getter for the center of mass of the element.
+  /** Getter for the center of mass of the element.
    * This function uses the cached version defined in TCompetence if available and calculates if not.
    * \return Coordinates of the center.
    */
@@ -419,7 +316,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       }
     }
     t8_3D_point coordinates;
-    t8_forest_element_centroid (m_mesh->m_forest, m_tree_id, get_element (), coordinates.data ());
+    t8_forest_element_centroid (m_mesh->m_forest, m_tree_id, m_element, coordinates.data ());
     // Fill the cache in the cached version.
     if constexpr (has_centroid_cache ()) {
       this->m_centroid = coordinates;
@@ -436,6 +333,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   std::vector<const SelfType*>
   get_face_neighbors (int face, std::optional<std::reference_wrapper<std::vector<int>>> dual_faces = std::nullopt) const
   {
+    T8_ASSERT (face < get_num_faces ());
     SC_CHECK_ABORT (!m_is_ghost_element, "get_face_neighbors is not implemented for ghost elements.\n");
     if constexpr (has_face_neighbor_cache ()) {
       if (this->neighbor_cache_filled (face)) {
@@ -445,14 +343,14 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
         return this->m_neighbors[face];
       }
     }
-    std::vector<std::reference_wrapper<SelfType>> neighbor_elements;
+
     t8_element_t** neighbors; /**< Neighboring elements. */
     int* dual_faces_internal; /**< Face indices of the neighbor elements. */
     int num_neighbors;        /**< Number of neighboring elements. */
     t8_locidx_t* neighids;    /**< Neighboring elements ids. */
     t8_eclass_t neigh_class;  /**< Neighboring elements tree class. */
 
-    t8_forest_leaf_face_neighbors (m_mesh->m_forest, m_tree_id, get_element (), &neighbors, face, &dual_faces_internal,
+    t8_forest_leaf_face_neighbors (m_mesh->m_forest, m_tree_id, m_element, &neighbors, face, &dual_faces_internal,
                                    &num_neighbors, &neighids, &neigh_class, t8_forest_is_balanced (m_mesh->m_forest));
     if (dual_faces) {
       dual_faces->get ().assign (dual_faces_internal, dual_faces_internal + num_neighbors);
@@ -480,8 +378,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return neighbors_handle;
   }
 
-  /**
-   * Function to fill the face neighbor cache for all faces of the mesh element.
+  /** Function to fill the face neighbor cache for all faces of the mesh element.
    */
   void
   fill_face_neighbor_cache () const
@@ -494,42 +391,40 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
 
   // --- Getter for face properties. ---
   /** The area of a face of the element.
-   * This is only an approximation.
-   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   *  This is only an approximation.
+   *  This function uses the cached version defined in TCompetence if available and calculates if not.
    * \param [in] face Index of a face of the element.
    * \return The area of \a face.
    */
   double
   get_face_area (int face) const
   {
-
+    T8_ASSERT (face < get_num_faces ());
     if constexpr (has_face_area_cache ()) {
       if (!this->face_area_cache_filled (face)) {
-        // Fill cache.
-        this->m_face_area[face] = t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
+        this->m_face_area[face] = t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, m_element, face);
       }
       return this->m_face_area[face].value ();
     }
-    return t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, get_element (), face);
+    return t8_forest_element_face_area (m_mesh->m_forest, m_tree_id, m_element, face);
   }
 
   /** The centroid of a face of the element.
-   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   *  This function uses the cached version defined in TCompetence if available and calculates if not.
    * \param [in] face Index of a face of the element.
    * \return The centroid of \a face.
    */
   t8_3D_point
   get_face_centroid (int face) const
   {
-    // Check if we have a cached version and if the cache has already been filled.
+    T8_ASSERT (face < get_num_faces ());
     if constexpr (has_face_centroid_cache ()) {
       if (this->face_centroid_cache_filled (face)) {
         return this->m_face_centroid[face];
       }
     }
     t8_3D_point coordinates;
-    t8_forest_element_face_centroid (m_mesh->m_forest, m_tree_id, get_element (), face, coordinates.data ());
-    // Fill the cache in the cached version.
+    t8_forest_element_face_centroid (m_mesh->m_forest, m_tree_id, m_element, face, coordinates.data ());
     if constexpr (has_face_centroid_cache ()) {
       this->m_face_centroid[face] = coordinates;
     }
@@ -537,57 +432,54 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   }
 
   /** The normal vector of a face of the element.
-   * This function uses the cached version defined in TCompetence if available and calculates if not.
+   *  This function uses the cached version defined in TCompetence if available and calculates if not.
    * \param [in] face Index of a face of the element.
    * \return The normal vector of \a face.
    */
   t8_3D_vec
   get_face_normal (int face) const
   {
-
-    // Check if we have a cached version and if the cache has already been filled.
+    T8_ASSERT (face < get_num_faces ());
     if constexpr (has_face_normal_cache ()) {
       if (this->face_normal_cache_filled (face)) {
         return this->m_face_normal[face];
       }
     }
     t8_3D_vec normal;
-    t8_forest_element_face_normal (m_mesh->m_forest, m_tree_id, get_element (), face, normal.data ());
-    // Fill the cache in the cached version.
+    t8_forest_element_face_normal (m_mesh->m_forest, m_tree_id, m_element, face, normal.data ());
     if constexpr (has_face_normal_cache ()) {
       this->m_face_normal[face] = normal;
     }
     return normal;
   }
 
-  /**
-   * Getter for the element's face shape.
-   * For this easily accessible variable, it makes no sense to provide a cached version.
+  /** Getter for the element's face shape.
+   *  For this easily accessible variable, it makes no sense to provide a cached version.
    * \param [in] face Index of a face of the element.
    * \return The shape of the face of the element.
    */
   t8_element_shape_t
   get_face_shape (int face) const
   {
-    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_face_shape (get_tree_class (), get_element (), face);
+    T8_ASSERT (face < get_num_faces ());
+    return t8_forest_get_scheme (m_mesh->m_forest)->element_get_face_shape (get_tree_class (), m_element, face);
   }
 
   // --- Print for the element for debugging purpose. ---
 #if T8_ENABLE_DEBUG
   /** Print the element. 
-    * For a example for a triangle print the coordinates and the level of the triangle. 
-    * This function is only available in the debugging configuration.
-    */
+   *  For example, print the coordinates and level of a triangle.  
+   *  This function is only available in the debugging configuration.
+   */
   void
   print_element_debug () const
   {
-    t8_forest_get_scheme (m_mesh->m_forest)->element_debug_print (get_tree_class (), get_element ());
+    t8_forest_get_scheme (m_mesh->m_forest)->element_debug_print (get_tree_class (), m_element);
   }
 #endif
 
   // --- Function to access mesh specific id. ---
-  /**
-   * Getter for the index of the element in the mesh to which the element belongs.
+  /** Getter for the index of the element in the mesh to which the element belongs.
    * \return The local element id of the element in the mesh.
    */
   t8_locidx_t
@@ -603,10 +495,9 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   }
 
   //--- Getter for the member variables. ---
-  /**
-   * Getter for the tree id of the element in the forest related to the mesh.
-   * \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
-   * This function is mainly relevant for writing custom competences that need to access t8code functionality.
+  /** Getter for the tree id of the element in the forest related to the mesh.
+   *  \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
+   *  This function is mainly relevant for writing custom competences that need to access t8code functionality.
    * \return The element's local tree id in the forest.
    */
   t8_locidx_t
@@ -615,11 +506,10 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_tree_id;
   }
 
-  /**
-   * Getter for the local element id in the tree of the element in the forest related to the mesh.
-   * \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
-   * For mesh specific id use \ref get_element_handle_id. 
-   * This function is mainly relevant for writing custom competences that need to access t8code functionality.
+  /** Getter for the local element id in the tree of the element in the forest related to the mesh.
+   *  \warning This is related to t8code's tree structure and should not be confused with \ref mesh specific ids.
+   *  For mesh specific id use \ref get_element_handle_id. 
+   *  This function is mainly relevant for writing custom competences that need to access t8code functionality.
    * \return The local element id in the tree of the element in the forest.
    */
   t8_locidx_t
@@ -628,8 +518,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_element_id;
   }
 
-  /**
-   * Getter for the mesh to which the element belongs.
+  /** Getter for the mesh to which the element belongs.
    * \return Reference to the mesh.
    */
   const mesh_class*
@@ -638,8 +527,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_mesh;
   }
 
-  /**
-   * Function to check if the element is a ghost element.
+  /** Function to check if the element is a ghost element.
    * \return true if the element is a ghost element, false otherwise.
    */
   bool
@@ -650,8 +538,8 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
 
   // --- 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.
+   *  For ghost elements ensure that \ref mesh::exchange_ghost_data is called on each process first.
+   *  Element data for non-ghost elements can be accessed (if set) directly.
    * \return Element data with data of Type mesh_class::ElementDataType.
    */
   template <typename E = typename mesh_class::ElementDataType, typename = std::enable_if_t<!std::is_void<E>::value>>
@@ -661,9 +549,8 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     return m_mesh->m_element_data[get_element_handle_id ()];
   }
 
-  /** 
-   * Set the element data for the element. 
-   * \note You can only set element data for non-ghost elements.
+  /** Set the element data for the element. 
+   *  \note You can only set element data for non-ghost elements.
    * \param [in] element_data The element data to be set.
    */
   template <typename E = typename mesh_class::ElementDataType, typename = std::enable_if_t<!std::is_void<E>::value>>
@@ -677,19 +564,15 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   }
 
  private:
-  //--- Private getter for internal use. ---
-  /**
-   * Getter for the leaf element of the element.
-   * \return The leaf element.
-   */
-  const t8_element_t*
-  get_element () const
-  {
-    return m_element;
-  }
+  // --- Private member variables. ---
+  mesh_class* m_mesh;             /**< Pointer to the mesh the element is defined for. */
+  const t8_locidx_t m_tree_id;    /**< The tree id of the element in the forest defined in the mesh. */
+  const t8_locidx_t m_element_id; /**< The element id of the element in the forest defined in the mesh. */
+  const bool m_is_ghost_element;  /**< Flag to indicate if the element is a ghost element. */
+  const t8_element_t* m_element;  /**< Cache the pointer to element in the forest as this is often needed. */
 
-  /**
-   * Getter for the eclass of the tree of the element.
+  // --- Private helper function. ---
+  /** Getter for the eclass of the tree of the element.
    * \return The eclass of the element's tree.
    */
   t8_eclass_t
@@ -698,11 +581,87 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     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. */
-  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. */
-  const t8_element_t* m_element;  /**< Cache the pointer to element in the forest as this is often needed. */
+  // --- Private variables to check which functionality is defined in TCompetence. ---
+  /** Helper function to check if class T implements the function volume_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  volume_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function diameter_cache_defined.
+   * \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
+  diameter_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.diameter_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function vertex_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  vertex_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function centroid_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  centroid_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
+  }
+  /** Helper function to check if class T implements the function neighbor_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  neighbor_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_area_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_area_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_area_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_centroid_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_centroid_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_centroid_cache_filled (0); };
+  }
+  /** Helper function to check if class T implements the function face_normal_cache_filled.
+   * \tparam T The competence to be checked.
+   * \return true if T implements the function, false if not.
+   */
+  template <template <typename> class T>
+  static constexpr bool
+  face_normal_cache_defined ()
+  {
+    return requires (T<SelfType>& competence) { competence.face_normal_cache_filled (0); };
+  }
 };
 
 }  // 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 e5841271a6..88f1897ca6 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -104,7 +104,7 @@ 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 element_class = typename mesh_class::element_class;
-  const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  const auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_volume_cache ());
 
   double unrealistic_volume = -3000;
@@ -131,7 +131,7 @@ 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 element_class = typename mesh_class::element_class;
-  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_diameter_cache ());
 
   double unrealistic_diameter = -3000;
@@ -153,7 +153,7 @@ 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 element_class = typename mesh_class::element_class;
-  const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  const auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_vertex_cache ());
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
@@ -186,7 +186,7 @@ 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 element_class = mesh_class::element_class;
-  const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  const auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
@@ -235,7 +235,7 @@ TEST (t8_gtest_cache_competence, cache_face_area)
   const int level = 1;
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_area_overwrite>>;
   using element_class = typename mesh_class::element_class;
-  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
   EXPECT_TRUE (element_class::has_face_area_cache ());
 
   double unrealistic_face_area = 41.1;
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 003faa2e30..0ea93489c6 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -86,7 +86,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
 
   // Check mesh with custom defined competence.
   using mesh_class_custom = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<dummy_get_level>>;
-  const auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
+  const auto mesh
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class_custom> (level, sc_MPI_COMM_WORLD);
 
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
@@ -96,7 +97,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 mesh_class = t8_mesh_handle::mesh<competences>;
-  auto mesh_more_competences = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  auto mesh_more_competences
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
   for (auto it = mesh_more_competences->cbegin (); it != mesh_more_competences->cend (); ++it) {
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index a028cc8d00..68da52abf4 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -50,7 +50,7 @@ TEST (t8_gtest_handle_data, set_and_get_user_data)
   // Define mesh handle.
   const int level = 2;
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<>, dummy_user_data>;
-  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
 
   struct dummy_user_data user_data = {
     t8_3D_point ({ 41, 42, 43 }), /* Midpoints of the sphere. */
@@ -83,7 +83,7 @@ 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<>, void, data_per_element>;
   auto mesh
-    = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, true, true, false);
+    = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD, true, true, false);
   if ((mesh->get_dimension () > 1) && (mesh->get_num_local_elements () > 1)) {
     // Ensure that we actually test with ghost elements.
     EXPECT_GT (mesh->get_num_ghosts (), 0);
@@ -122,7 +122,7 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
       EXPECT_EQ (elem.get_element_data ().volume, elem.get_volume ());
     }
   }
-  // Check fpor ghost elements with updated data.
+  // Check for ghost elements with updated data.
   for (t8_locidx_t ighost = mesh->get_num_local_elements ();
        ighost < mesh->get_num_local_elements () + mesh->get_num_ghosts (); ighost++) {
     if (t8_forest_ghost_get_global_treeid (
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 12370ddb6e..972f2af26c 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -32,10 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
-#include <t8_cmesh/t8_cmesh.h>
-#include <t8_cmesh/t8_cmesh_examples.h>
-#include <t8_forest/t8_forest_general.h>
-#include <t8_schemes/t8_default/t8_default.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 
 /** Parametrized test fixture for the mesh handle tests. */
 class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t, int>> {
@@ -43,21 +40,14 @@ class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
   void
   SetUp () override
   {
-    const t8_scheme* scheme = t8_scheme_new_default ();
-    t8_eclass_t eclass = std::get<0> (GetParam ());
+    eclass = std::get<0> (GetParam ());
     level = std::get<1> (GetParam ());
-    t8_cmesh_t cmesh = t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0);
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
   }
   void
   TearDown () override
   {
-    if (forest->rc.refcount > 0) {
-      t8_forest_unref (&forest);
-    }
   }
-
-  t8_forest_t forest;
+  t8_eclass_t eclass;
   int level;
 };
 
@@ -67,12 +57,13 @@ TEST_P (t8_mesh_handle_test, test_iterator)
   // --- Check default functionality. ---
   using mesh_class = t8_mesh_handle::mesh<>;
   using element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
   EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements and check some functionality.
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->has_vertex_cache ());
     EXPECT_FALSE (it->has_centroid_cache ());
     auto centroid = it->get_centroid ();
@@ -91,8 +82,8 @@ TEST_P (t8_mesh_handle_test, test_iterator)
   }
 
   // Check loop with indices.
-  for (int ielement = 0; ielement < mesh.get_num_local_elements (); ielement++) {
-    EXPECT_EQ (level, mesh[ielement].get_level ());
+  for (int ielement = 0; ielement < mesh->get_num_local_elements (); ielement++) {
+    EXPECT_EQ (level, (*mesh)[ielement].get_level ());
   }
 }
 
@@ -103,12 +94,13 @@ TEST_P (t8_mesh_handle_test, test_competences)
   using competence_vertex_coordinates = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_vertex_coordinates>;
   using mesh_class_vertex = t8_mesh_handle::mesh<competence_vertex_coordinates>;
   using element_class_vertex = typename mesh_class_vertex::element_class;
-  const mesh_class_vertex mesh_vertex = mesh_class_vertex (forest);
+  auto mesh_vertex = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_vertex> (
+    eclass, level, sc_MPI_COMM_WORLD, true, true, false);
   EXPECT_TRUE (element_class_vertex::has_vertex_cache ());
   EXPECT_FALSE (element_class_vertex::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements and check functionality.
-  for (auto it = mesh_vertex.cbegin (); it != mesh_vertex.cend (); ++it) {
+  for (auto it = mesh_vertex->cbegin (); it != mesh_vertex->cend (); ++it) {
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
     auto centroid = it->get_centroid ();
@@ -125,7 +117,7 @@ TEST_P (t8_mesh_handle_test, test_competences)
     }
   }
   // Check cached value.
-  for (auto it = mesh_vertex.cbegin (); it != mesh_vertex.cend (); ++it) {
+  for (auto it = mesh_vertex->cbegin (); it != mesh_vertex->cend (); ++it) {
     EXPECT_TRUE (it->vertex_cache_filled ());
     auto vertex_coordinates = it->get_vertex_coordinates ();
     for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
@@ -137,16 +129,16 @@ TEST_P (t8_mesh_handle_test, test_competences)
   }
 
   // --- Version with cached centroid variable. ---
-  t8_forest_ref (forest);
   using competence_centroid = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_centroid>;
   using mesh_class_centroid = t8_mesh_handle::mesh<competence_centroid>;
   using element_class_centroid = typename mesh_class_centroid::element_class;
-  const mesh_class_centroid mesh_centroid = mesh_class_centroid (forest);
+  auto mesh_centroid = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_centroid> (
+    eclass, level, sc_MPI_COMM_WORLD, true, true, false);
   EXPECT_FALSE (element_class_centroid::has_vertex_cache ());
   EXPECT_TRUE (element_class_centroid::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements.
-  for (auto it = mesh_centroid.cbegin (); it != mesh_centroid.cend (); ++it) {
+  for (auto it = mesh_centroid->cbegin (); it != mesh_centroid->cend (); ++it) {
     EXPECT_FALSE (it->centroid_cache_filled ());
     auto centroid = it->get_centroid ();
     for (const auto& coordinate : centroid) {
@@ -168,13 +160,14 @@ 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 element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
   EXPECT_TRUE (element_class::has_volume_cache ());
   EXPECT_TRUE (element_class::has_vertex_cache ());
   EXPECT_TRUE (element_class::has_centroid_cache ());
 
   // Iterate with the iterator over all mesh elements.
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->volume_cache_filled ());
     EXPECT_FALSE (it->centroid_cache_filled ());
     EXPECT_FALSE (it->vertex_cache_filled ());
@@ -193,8 +186,8 @@ TEST_P (t8_mesh_handle_test, test_2_competences)
       }
     }
   }
-  // Test dereference operator. (Here the cached values should be used.)
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  // Check if caches are set.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_TRUE (it->volume_cache_filled ());
     EXPECT_TRUE (it->centroid_cache_filled ());
     EXPECT_TRUE (it->vertex_cache_filled ());

From bd33b14d13e1317bc1c918782eb33bf0d2d4cef6 Mon Sep 17 00:00:00 2001
From: Lena Ploetzke <lena.ploetzke@dlr.de>
Date: Mon, 12 Jan 2026 14:06:41 +0100
Subject: [PATCH 7/7] add tests for new functionality, shorten tests

---
 mesh_handle/competence_pack.hxx               |   4 +-
 mesh_handle/element.hxx                       |   4 +-
 test/mesh_handle/README.md                    |   8 +-
 test/mesh_handle/t8_gtest_adapt.cxx           |   2 +-
 .../mesh_handle/t8_gtest_cache_competence.cxx | 144 +++++++++-----
 .../t8_gtest_compare_handle_to_forest.cxx     |  36 +++-
 .../t8_gtest_custom_competence.cxx            |  12 +-
 test/mesh_handle/t8_gtest_ghost.cxx           |  98 +++++-----
 test/mesh_handle/t8_gtest_handle_data.cxx     |  22 +--
 test/mesh_handle/t8_gtest_mesh_handle.cxx     | 177 +++++++-----------
 10 files changed, 270 insertions(+), 237 deletions(-)

diff --git a/mesh_handle/competence_pack.hxx b/mesh_handle/competence_pack.hxx
index 5c7a87c0be..8c61c025ec 100644
--- a/mesh_handle/competence_pack.hxx
+++ b/mesh_handle/competence_pack.hxx
@@ -45,8 +45,8 @@ struct competence_pack
 };
 
 /** Predefined competence pack combining all caching competences. */
-using cache_competences = competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid,
-                                          cache_face_area, cache_face_centroid, cache_face_normal, cache_neighbors>;
+using all_cache_competences = competence_pack<cache_volume, cache_diameter, cache_vertex_coordinates, cache_centroid,
+                                              cache_face_area, cache_face_centroid, cache_face_normal, cache_neighbors>;
 
 /** Predefined competence pack combining all competences related to faces. */
 using cache_face_competences
diff --git a/mesh_handle/element.hxx b/mesh_handle/element.hxx
index a299534914..8f627457f3 100644
--- a/mesh_handle/element.hxx
+++ b/mesh_handle/element.hxx
@@ -420,7 +420,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     T8_ASSERT (face < get_num_faces ());
     if constexpr (has_face_centroid_cache ()) {
       if (this->face_centroid_cache_filled (face)) {
-        return this->m_face_centroid[face];
+        return this->m_face_centroid[face].value ();
       }
     }
     t8_3D_point coordinates;
@@ -442,7 +442,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     T8_ASSERT (face < get_num_faces ());
     if constexpr (has_face_normal_cache ()) {
       if (this->face_normal_cache_filled (face)) {
-        return this->m_face_normal[face];
+        return this->m_face_normal[face].value ();
       }
     }
     t8_3D_vec normal;
diff --git a/test/mesh_handle/README.md b/test/mesh_handle/README.md
index 4a5b95cf9a..af37422be6 100644
--- a/test/mesh_handle/README.md
+++ b/test/mesh_handle/README.md
@@ -3,11 +3,11 @@
 In this folder, we test the mesh handle functionality. 
 The tests are structured as follow: 
 
-- [t8_gtest_mesh_handle.cxx](t8_gtest_mesh_handle.cxx) tests some basic functionality, e.g., if the mesh handle generally works with more than one competence or the iterator. The handle's functionality is not tested in detail, but instead using some exemplary functions.
+- [t8_gtest_mesh_handle.cxx](t8_gtest_mesh_handle.cxx) tests some basic functionality, e.g., if the mesh handle generally works with default competences. The handle's functionality is not tested in detail, but instead using some *exemplary functions*. The predefined competence packs are checked.
 - [t8_gtest_custom_competence.cxx](t8_gtest_custom_competence.cxx) checks that user defined competences can be used for the mesh handle.
-- [t8_gtest_compare_handle_to_forest.cxx](t8_gtest_compare_handle_to_forest.cxx) tests that the functionality of the handle gives the same results as if worked with the forest directly. This test checks each function. 
-- [t8_gtest_cache_competence.cxx](t8_gtest_cache_competence.cxx) tests that all predefined caching competences work as intended.
-- [t8_gtest_ghost.cxx](t8_gtest_ghost.cxx) checks ghosts and the neighbor algorithm. Furthermore tests if all functions work also for ghost cells if applicable.
+- [t8_gtest_compare_handle_to_forest.cxx](t8_gtest_compare_handle_to_forest.cxx) tests that the functionality of the handle gives the same results as if worked with the forest directly. This test checks *all functions*. 
+- [t8_gtest_cache_competence.cxx](t8_gtest_cache_competence.cxx) tests that *all predefined caching competences* work as intended.
+- [t8_gtest_ghost.cxx](t8_gtest_ghost.cxx) checks ghosts and the neighbor algorithm. Furthermore tests if *all functions work also for ghost cells* if applicable.
 - [t8_gtest_handle_data.cxx](t8_gtest_handle_data.cxx) defines tests for user and element data.
 - [t8_gtest_adapt.cxx](t8_gtest_adapt.cxx) checks that the adapt routine works as intended and compares it with the result of an adapted forest.
 
diff --git a/test/mesh_handle/t8_gtest_adapt.cxx b/test/mesh_handle/t8_gtest_adapt.cxx
index 344415576c..acc311cafd 100644
--- a/test/mesh_handle/t8_gtest_adapt.cxx
+++ b/test/mesh_handle/t8_gtest_adapt.cxx
@@ -118,7 +118,7 @@ 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::all_cache_competences, dummy_user_data>;
   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 88f1897ca6..38b7e439d2 100644
--- a/test/mesh_handle/t8_gtest_cache_competence.cxx
+++ b/test/mesh_handle/t8_gtest_cache_competence.cxx
@@ -39,7 +39,6 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 template <typename TUnderlying>
 struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
 {
- public:
   /** Overwrites the cache variable for the volume.
    * \param [in] new_volume New volume. 
    */
@@ -54,7 +53,6 @@ struct cache_volume_overwrite: public t8_mesh_handle::cache_volume<TUnderlying>
 template <typename TUnderlying>
 struct cache_diameter_overwrite: public t8_mesh_handle::cache_diameter<TUnderlying>
 {
- public:
   /** Overwrites the cache variable for the diameter.
    * \param [in] new_diameter New diameter. 
    */
@@ -69,7 +67,6 @@ struct cache_diameter_overwrite: public t8_mesh_handle::cache_diameter<TUnderlyi
 template <typename TUnderlying>
 struct cache_vertex_coordinates_overwrite: public t8_mesh_handle::cache_vertex_coordinates<TUnderlying>
 {
- public:
   /** Overwrites the cache variable for the vertex coordinates.
    * \param [in] new_vec New cache vector. 
    */
@@ -84,7 +81,6 @@ struct cache_vertex_coordinates_overwrite: public t8_mesh_handle::cache_vertex_c
 template <typename TUnderlying>
 struct cache_centroid_overwrite: public t8_mesh_handle::cache_centroid<TUnderlying>
 {
- public:
   /** Overwrites the cache variable for the centroid.
    * \param [in] new_vec New point for the cache. 
    */
@@ -95,6 +91,52 @@ struct cache_centroid_overwrite: public t8_mesh_handle::cache_centroid<TUnderlyi
   }
 };
 
+// --- Face related caches. ---
+/** Child class of \ref t8_mesh_handle::cache_face_area that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_face_area_overwrite: public t8_mesh_handle::cache_face_area<TUnderlying>
+{
+  /** Overwrites the cache variable for the face area.
+   * \param [in] face The face for which the cache should be set.
+   * \param [in] new_face_area New face area. 
+   */
+  void
+  overwrite_cache (int face, double new_face_area) const
+  {
+    this->m_face_area[face] = new_face_area;
+  }
+};
+
+/** Child class of \ref t8_mesh_handle::cache_face_centroid that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_face_centroid_overwrite: public t8_mesh_handle::cache_face_centroid<TUnderlying>
+{
+  /** Overwrites the cache variable for the face centroid.
+   * \param [in] face The face for which the cache should be set.
+   * \param [in] new_face_centroid New face centroid. 
+   */
+  void
+  overwrite_cache (int face, t8_3D_point new_face_centroid) const
+  {
+    this->m_face_centroid[face] = new_face_centroid;
+  }
+};
+
+/** Child class of \ref t8_mesh_handle::cache_face_normal that allows to modify the cache variables for test purposes. */
+template <typename TUnderlying>
+struct cache_face_normal_overwrite: public t8_mesh_handle::cache_face_normal<TUnderlying>
+{
+  /** Overwrites the cache variable for the face normal.
+   * \param [in] face The face for which the cache should be set.
+   * \param [in] new_face_normal New face normal. 
+   */
+  void
+  overwrite_cache (int face, t8_3D_vec new_face_normal) const
+  {
+    this->m_face_normal[face] = new_face_normal;
+  }
+};
+
 /** Use child class of \ref t8_mesh_handle::cache_volume class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
@@ -158,21 +200,14 @@ TEST (t8_gtest_cache_competence, cache_vertex_coordinates)
 
   std::vector<t8_3D_point> unrealistic_vertex = { t8_3D_point ({ 41, 42, 43 }), t8_3D_point ({ 99, 100, 101 }) };
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
-    // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->vertex_cache_filled ());
-    // Fill and check that values are valid.
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto &coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    for (int ivertex = 0; ivertex < it->get_num_vertices (); ++ivertex) {
+      for (const auto &coordinate : it->get_vertex_coordinates (ivertex)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
-    // Check that cache is set.
     EXPECT_TRUE (it->vertex_cache_filled ());
-    // Overwrite the cache with unrealistic values.
     it->overwrite_cache (unrealistic_vertex);
-    // Check that the cache is actually used.
     EXPECT_EQ (it->get_vertex_coordinates (), unrealistic_vertex);
   }
 }
@@ -191,41 +226,17 @@ TEST (t8_gtest_cache_competence, cache_centroid)
 
   t8_3D_point unrealistic_centroid ({ 999, 1000, 998 });
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
-    // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->centroid_cache_filled ());
-    // Check that values are valid.
-    auto centroid = it->get_centroid ();
-    for (const auto &coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    for (const auto &coordinate : it->get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    // Check that cache is set.
     EXPECT_TRUE (it->centroid_cache_filled ());
-    // Overwrite the cache with unrealistic values.
     it->overwrite_cache (unrealistic_centroid);
-    // Check that the cache is actually used.
     EXPECT_EQ (it->get_centroid (), unrealistic_centroid);
   }
 }
 
 // --- Face related caches. ---
-
-/** Child class of \ref t8_mesh_handle::cache_face_area that allows to modify the cache variables for test purposes. */
-template <typename TUnderlying>
-struct cache_face_area_overwrite: public t8_mesh_handle::cache_face_area<TUnderlying>
-{
- public:
-  /** Overwrites the cache variable for the face area.
-   * \param [in] face The face for which the cache should be set.
-   * \param [in] new_face_area New face area. 
-   */
-  void
-  overwrite_cache (int face, double new_face_area) const
-  {
-    this->m_face_area[face] = new_face_area;
-  }
-};
-
 /** Use child class of \ref t8_mesh_handle::cache_face_area class to check that the cache is actually set 
  * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
  * checking that the functionality actually outputs this unrealistic value.
@@ -247,9 +258,58 @@ TEST (t8_gtest_cache_competence, cache_face_area)
       EXPECT_TRUE (it->face_area_cache_filled (iface));
       it->overwrite_cache (iface, unrealistic_face_area + iface);
       EXPECT_EQ (it->get_face_area (iface), unrealistic_face_area + iface);
-      std::cout << "here";
     }
   }
 }
 
-//TODO: Add tests for face centroid and face normal caches. Also add these to compare handle to forest.
+/** Use child class of \ref t8_mesh_handle::cache_face_centroid class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (t8_gtest_cache_competence, cache_face_centroid)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_centroid_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_face_centroid_cache ());
+
+  t8_3D_point unrealistic_face_centroid ({ 999, 1000, 998 });
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_centroid_cache_filled (iface));
+      for (const auto &coordinate : it->get_face_centroid (iface)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
+      }
+      EXPECT_TRUE (it->face_centroid_cache_filled (iface));
+      it->overwrite_cache (iface, unrealistic_face_centroid);
+      EXPECT_EQ (it->get_face_centroid (iface), unrealistic_face_centroid);
+    }
+  }
+}
+
+/** Use child class of \ref t8_mesh_handle::cache_face_normal class to check that the cache is actually set 
+ * and accessed correctly. This is done by modifying the cache to an unrealistic value and 
+ * checking that the functionality actually outputs this unrealistic value.
+ */
+TEST (t8_gtest_cache_competence, cache_face_normal)
+{
+  const int level = 1;
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_face_normal_overwrite>>;
+  using element_class = typename mesh_class::element_class;
+  auto mesh = t8_mesh_handle::handle_hybrid_hypercube_uniform_default<mesh_class> (level, sc_MPI_COMM_WORLD);
+  EXPECT_TRUE (element_class::has_face_normal_cache ());
+
+  t8_3D_vec unrealistic_face_normal ({ 41, 42, 43 });
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_normal_cache_filled (iface));
+      for (const auto &coordinate : it->get_face_normal (iface)) {
+        EXPECT_TRUE (coordinate >= -1 && coordinate <= 1);
+      }
+      EXPECT_TRUE (it->face_normal_cache_filled (iface));
+      it->overwrite_cache (iface, unrealistic_face_normal);
+      EXPECT_EQ (it->get_face_normal (iface), unrealistic_face_normal);
+    }
+  }
+}
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 9bffb63ee5..300e4962b7 100644
--- a/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
+++ b/test/mesh_handle/t8_gtest_compare_handle_to_forest.cxx
@@ -43,13 +43,15 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
   // Define forest and mesh handle.
   const int level = 2;
   t8_cmesh_t cmesh = t8_cmesh_new_hypercube_hybrid (sc_MPI_COMM_WORLD, 0, 0);
-  const t8_scheme *init_scheme = t8_scheme_new_default ();
-  t8_forest_t forest = t8_forest_new_uniform (cmesh, init_scheme, level, 0, sc_MPI_COMM_WORLD);
+  const t8_scheme *scheme = t8_scheme_new_default ();
+  t8_forest_t forest = t8_forest_new_uniform (cmesh, scheme, level, 0, sc_MPI_COMM_WORLD);
 
   const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
+  EXPECT_EQ (mesh.get_num_local_elements (), t8_forest_get_local_num_leaf_elements (forest));
+  EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
+  EXPECT_EQ (mesh.get_dimension (), t8_forest_get_dimension (forest));
 
   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results of different functions.
-  const t8_scheme *scheme = t8_forest_get_scheme (forest);
   // Use iterator for the mesh handle and two nested for-loops for the forest.
   auto mesh_iterator = mesh.cbegin ();
   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
@@ -59,21 +61,35 @@ TEST (t8_gtest_compare_handle_to_forest, compare_handle_to_forest)
       // --- Compare elements. ---
       EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
       EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
-      // --- Compare basics. ---
+      // --- Compare functionality. ---
       EXPECT_EQ (mesh_iterator->get_level (), scheme->element_get_level (tree_class, elem));
+      EXPECT_EQ (mesh_iterator->get_num_faces (), scheme->element_get_num_faces (tree_class, elem));
+      EXPECT_EQ (mesh_iterator->get_num_vertices (), scheme->element_get_num_corners (tree_class, elem));
       EXPECT_EQ (mesh_iterator->get_shape (), scheme->element_get_shape (tree_class, elem));
       EXPECT_EQ (mesh_iterator->get_volume (), t8_forest_element_volume (forest, itree, elem));
-      // --- Compare centroid. ---
-      t8_3D_point centroid;
-      t8_forest_element_centroid (forest, itree, elem, centroid.data ());
-      EXPECT_EQ (mesh_iterator->get_centroid (), centroid);
-      // --- Compare vertex coordinates. ---
+      EXPECT_EQ (mesh_iterator->get_diameter (), t8_forest_element_diam (forest, itree, elem));
+      // --- Vertex coordinates. ---
       auto vertex_coordinates = mesh_iterator->get_vertex_coordinates ();
-      for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
+      for (int ivertex = 0; ivertex < mesh_iterator->get_num_vertices (); ++ivertex) {
         t8_3D_point vertex_forest;
         t8_forest_element_coordinate (forest, itree, elem, ivertex, vertex_forest.data ());
         EXPECT_EQ (vertex_forest, vertex_coordinates[ivertex]);
       }
+      // --- Centroid. ---
+      t8_3D_point centroid;
+      t8_forest_element_centroid (forest, itree, elem, centroid.data ());
+      EXPECT_EQ (mesh_iterator->get_centroid (), centroid);
+      // Face neighbor functionality is tested in t8_gtest_ghost.cxx.
+      for (int iface = 0; iface < mesh_iterator->get_num_faces (); ++iface) {
+        EXPECT_EQ (mesh_iterator->get_face_area (iface), t8_forest_element_face_area (forest, itree, elem, iface));
+        t8_3D_point coordinates;
+        t8_forest_element_face_centroid (forest, itree, elem, iface, coordinates.data ());
+        EXPECT_EQ (mesh_iterator->get_face_centroid (iface), coordinates);
+        t8_3D_vec normal;
+        t8_forest_element_face_normal (forest, itree, elem, iface, normal.data ());
+        EXPECT_EQ (mesh_iterator->get_face_normal (iface), normal);
+        EXPECT_EQ (mesh_iterator->get_face_shape (iface), scheme->element_get_face_shape (tree_class, elem, iface));
+      }
       // --- Evolve mesh iterator. ---
       mesh_iterator++;
     }
diff --git a/test/mesh_handle/t8_gtest_custom_competence.cxx b/test/mesh_handle/t8_gtest_custom_competence.cxx
index 0ea93489c6..4a63e4e61d 100644
--- a/test/mesh_handle/t8_gtest_custom_competence.cxx
+++ b/test/mesh_handle/t8_gtest_custom_competence.cxx
@@ -44,9 +44,9 @@ struct dummy_get_level: public t8_crtp_operator<TUnderlying, dummy_get_level>
 {
  public:
   /** Getter for the level of the element. This function needs to access several members 
-  *     of the element such that we need the crtp structure here. 
-  * \return Level of the element.
-  */
+   *     of the element such that we need the crtp structure here. 
+   * \return Level of the element.
+   */
   t8_element_level
   get_level_dummy () const
   {
@@ -104,10 +104,8 @@ TEST (t8_gtest_custom_competence, custom_competence)
     EXPECT_EQ (it->get_level (), it->get_level_dummy ());
     EXPECT_EQ (it->get_value_dummy (), 1);
     EXPECT_FALSE (it->centroid_cache_filled ());
-    auto centroid = it->get_centroid ();
-    for (const auto &coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    for (const auto &coordinate : it->get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
     EXPECT_TRUE (it->centroid_cache_filled ());
   }
diff --git a/test/mesh_handle/t8_gtest_ghost.cxx b/test/mesh_handle/t8_gtest_ghost.cxx
index 076d47b2db..6129c61ef0 100644
--- a/test/mesh_handle/t8_gtest_ghost.cxx
+++ b/test/mesh_handle/t8_gtest_ghost.cxx
@@ -32,6 +32,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <mesh_handle/mesh.hxx>
 #include <mesh_handle/competences.hxx>
 #include <mesh_handle/competence_pack.hxx>
+#include <mesh_handle/constructor_wrapper.hxx>
 #include <t8_cmesh/t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_examples.h>
 #include <t8_forest/t8_forest_general.h>
@@ -41,99 +42,93 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 #include <vector>
 
 /** Parametrized test fixture for the ghost tests. */
+
 class t8_mesh_ghost_test: public testing::TestWithParam<std::tuple<t8_eclass_t, int>> {
  protected:
   void
   SetUp () override
   {
-    const t8_scheme* scheme = t8_scheme_new_default ();
-    t8_eclass_t eclass = std::get<0> (GetParam ());
+    eclass = std::get<0> (GetParam ());
     level = std::get<1> (GetParam ());
-    t8_cmesh_t cmesh = t8_cmesh_new_hypercube (eclass, sc_MPI_COMM_WORLD, 0, 1, 0);
-    forest = t8_forest_new_uniform (cmesh, scheme, level, 1, sc_MPI_COMM_WORLD);
   }
-  void
-  TearDown () override
-  {
-    if (forest->rc.refcount > 0) {
-      t8_forest_unref (&forest);
-    }
-  }
-  t8_forest_t forest;
+
+  t8_eclass_t eclass;
   int level;
 };
 
 /** Check the implementation of ghosts and all functions accessible by ghosts. */
 TEST_P (t8_mesh_ghost_test, check_ghosts)
 {
-  t8_forest_ghost_print (forest);
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_competences>;
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
 
-  const t8_mesh_handle::mesh<> mesh = t8_mesh_handle::mesh<> (forest);
-  EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
-  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+  EXPECT_EQ (mesh->get_num_ghosts (), t8_forest_get_num_ghosts (mesh->get_forest ()));
+  if ((mesh->get_dimension () > 1) && (mesh->get_num_local_elements () > 1)) {
     // Ensure that we actually have ghost elements in this test.
-    EXPECT_GT (mesh.get_num_ghosts (), 0);
+    EXPECT_GT (mesh->get_num_ghosts (), 0);
   }
   else {
     GTEST_SKIP () << "Skipping test as no ghost elements are created for 1D or single element meshes.";
   }
 
   // Check functions for ghost elements.
-  const t8_locidx_t num_local_elements = mesh.get_num_local_elements ();
-  const t8_locidx_t num_ghost_elements = mesh.get_num_ghosts ();
+  const t8_locidx_t num_local_elements = mesh->get_num_local_elements ();
+  const t8_locidx_t num_ghost_elements = mesh->get_num_ghosts ();
   for (t8_locidx_t ighost = num_local_elements; ighost < num_local_elements + num_ghost_elements; ++ighost) {
-    EXPECT_TRUE (mesh[ighost].is_ghost_element ());
-    EXPECT_EQ (level, mesh[ighost].get_level ());
-    EXPECT_LE (0, mesh[ighost].get_num_faces ());
-    EXPECT_LE (0, mesh[ighost].get_num_vertices ());
-    EXPECT_LE (0, mesh[ighost].get_volume ());
-    EXPECT_LE (0, mesh[ighost].get_diameter ());
-    auto centroid = mesh[ighost].get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    EXPECT_EQ (ighost, (*mesh)[ighost].get_element_handle_id ());
+    EXPECT_TRUE ((*mesh)[ighost].is_ghost_element ());
+    EXPECT_EQ (level, (*mesh)[ighost].get_level ());
+    EXPECT_LE (0, (*mesh)[ighost].get_num_faces ());
+    EXPECT_LE (0, (*mesh)[ighost].get_num_vertices ());
+    EXPECT_LE (0, (*mesh)[ighost].get_volume ());
+    EXPECT_LE (0, (*mesh)[ighost].get_diameter ());
+    for (const auto& coordinate : (*mesh)[ighost].get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    auto vertex_coordinates = mesh[ighost].get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    for (int ivertex = 0; ivertex < (*mesh)[ighost].get_num_vertices (); ++ivertex) {
+      for (const auto& coordinate : (*mesh)[ighost].get_vertex_coordinates (ivertex)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
-    EXPECT_LE (0, mesh[ighost].get_face_area (0));
-    auto centroid_face = mesh[ighost].get_face_centroid (0);
-    for (const auto& coordinate : centroid_face) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    // Check face related functions exemplary for first face.
+    EXPECT_LE (0, (*mesh)[ighost].get_face_area (0));
+    for (const auto& coordinate : (*mesh)[ighost].get_face_centroid (0)) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    auto normal_face = mesh[ighost].get_face_normal (0);
-    for (const auto& coordinate : normal_face) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (-1, coordinate);
+    for (const auto& coordinate : (*mesh)[ighost].get_face_normal (0)) {
+      EXPECT_TRUE (coordinate >= -1 && coordinate <= 1);
     }
+    // Check exemplary that caches work for ghost elements.
+    EXPECT_TRUE ((*mesh)[ighost].volume_cache_filled ());
+    EXPECT_LE (0, (*mesh)[ighost].get_volume ());
   }
 }
 
 /** Check that the function \ref t8_mesh_handle::element::get_face_neighbors of the handle works as intended (equal results to forest).*/
 TEST_P (t8_mesh_ghost_test, compare_neighbors_to_forest)
 {
-  ASSERT_TRUE (t8_forest_is_committed (forest));
+  const t8_scheme* scheme = t8_scheme_new_default ();
+  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 = t8_mesh_handle::mesh<> (forest);
   EXPECT_EQ (mesh.get_num_ghosts (), t8_forest_get_num_ghosts (forest));
+  if ((mesh.get_dimension () > 1) && (mesh.get_num_local_elements () > 1)) {
+    // Ensure that we have ghost elements in this test.
+    EXPECT_GT (mesh.get_num_ghosts (), 0);
+  }
 
   // Iterate over the elements of the forest and of the mesh handle simultaneously and compare results.
-  const t8_scheme* scheme = t8_forest_get_scheme (forest);
   auto mesh_iterator = mesh.cbegin ();
   for (t8_locidx_t itree = 0; itree < t8_forest_get_num_local_trees (forest); ++itree) {
-    const t8_eclass_t tree_class = t8_forest_get_tree_class (forest, itree);
     for (t8_locidx_t ielem = 0; ielem < t8_forest_get_tree_num_leaf_elements (forest, itree); ++ielem) {
       // --- Compare elements. ---
       EXPECT_EQ (mesh_iterator->get_local_tree_id (), itree);
       EXPECT_EQ (mesh_iterator->get_local_element_id (), ielem);
       // --- Compare neighbors. ---
       const t8_element_t* elem = t8_forest_get_leaf_element_in_tree (forest, itree, ielem);
-      const int num_faces = scheme->element_get_num_faces (tree_class, elem);
+      const int num_faces = scheme->element_get_num_faces (t8_forest_get_tree_class (forest, itree), elem);
       EXPECT_EQ (mesh_iterator->get_num_faces (), num_faces);
       for (int iface = 0; iface < num_faces; iface++) {
         // --- Get neighbors from forest. ---
@@ -198,16 +193,17 @@ TEST_P (t8_mesh_ghost_test, cache_neighbors)
 {
   using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::competence_pack<cache_neighbors_overwrite>>;
   using element_class = typename mesh_class::element_class;
-  const mesh_class mesh = mesh_class (forest);
+  auto mesh = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class> (eclass, level, sc_MPI_COMM_WORLD, true,
+                                                                            true, false);
   EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
-  if (mesh.get_num_local_elements () == 0) {
+  if (mesh->get_num_local_elements () == 0) {
     GTEST_SKIP () << "No local elements in the mesh to test the cache functionality.";
   }
   const std::vector<const element_class*> unrealistic_neighbors
-    = { &mesh[0], &mesh[mesh.get_num_local_elements () - 1] };
+    = { &((*mesh)[0]), &((*mesh)[mesh->get_num_local_elements () - 1]) };
   const std::vector<int> unrealistic_dual_faces = { 100, 1012000 };
-  for (auto it = mesh.cbegin (); it != mesh.cend (); ++it) {
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     // Check that cache is empty at the beginning.
     EXPECT_FALSE (it->neighbor_cache_filled_any ());
     it->fill_face_neighbor_cache ();
diff --git a/test/mesh_handle/t8_gtest_handle_data.cxx b/test/mesh_handle/t8_gtest_handle_data.cxx
index 68da52abf4..5c3c8668b3 100644
--- a/test/mesh_handle/t8_gtest_handle_data.cxx
+++ b/test/mesh_handle/t8_gtest_handle_data.cxx
@@ -54,8 +54,8 @@ TEST (t8_gtest_handle_data, set_and_get_user_data)
 
   struct dummy_user_data user_data = {
     t8_3D_point ({ 41, 42, 43 }), /* Midpoints of the sphere. */
-    0.2,                          /* Refine if inside this radius. */
-    0.4                           /* Coarsen if outside this radius. */
+    100,                          /* Refine if inside this radius. */
+    3                             /* Coarsen if outside this radius. */
   };
 
   // Set user data for the mesh handle and check that the getter returns the same data.
@@ -74,9 +74,7 @@ struct data_per_element
   double volume;
 };
 
-/** Check that element data can be set for the handle and 
- * that the getter has exchanged data for the ghosts.
- */
+/** Check that element data can be set for the handle and that the getter has exchanged data for the ghosts. */
 TEST (t8_gtest_handle_data, set_and_get_element_data)
 {
   // Define mesh handle.
@@ -88,7 +86,6 @@ TEST (t8_gtest_handle_data, set_and_get_element_data)
     // Ensure that we actually test with ghost elements.
     EXPECT_GT (mesh->get_num_ghosts (), 0);
   }
-  auto forest = mesh->get_forest ();
 
   // Create element data for all local mesh elements.
   std::vector<data_per_element> element_data;
@@ -102,17 +99,20 @@ 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;
   }
-  t8_gloidx_t barrier = t8_forest_get_num_global_trees (forest) / 2.0;
+
+  // Modify element data for elements that are in the first half of the global trees.
+  auto forest = mesh->get_forest ();
+  const 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 });
+  for (auto it = mesh->begin (); it != mesh->end (); ++it) {
+    if (t8_forest_global_tree_id (forest, it->get_local_tree_id ()) < barrier) {
+      it->set_element_data ({ newlevel, newvolume });
     }
   }
   mesh->exchange_ghost_data ();
   // Check for mesh elements with updated data.
-  for (auto &elem : *mesh) {
+  for (const auto &elem : *mesh) {
     if (t8_forest_global_tree_id (forest, elem.get_local_tree_id ()) < barrier) {
       EXPECT_EQ (elem.get_element_data ().level, newlevel);
       EXPECT_EQ (elem.get_element_data ().volume, newvolume);
diff --git a/test/mesh_handle/t8_gtest_mesh_handle.cxx b/test/mesh_handle/t8_gtest_mesh_handle.cxx
index 972f2af26c..874d6d60f5 100644
--- a/test/mesh_handle/t8_gtest_mesh_handle.cxx
+++ b/test/mesh_handle/t8_gtest_mesh_handle.cxx
@@ -22,7 +22,7 @@ along with t8code; if not, write to the Free Software Foundation, Inc.,
 
 /**
  * \file t8_gtest_mesh_handle.cxx
- * Tests if the mesh class of the handle works as intended for different types of predefined template parameter classes. 
+ * Tests if the \ref t8_mesh_handle::mesh class of the handle works as intended for different types of template parameter classes. 
  */
 
 #include <gtest/gtest.h>
@@ -43,18 +43,14 @@ class t8_mesh_handle_test: public testing::TestWithParam<std::tuple<t8_eclass_t,
     eclass = std::get<0> (GetParam ());
     level = std::get<1> (GetParam ());
   }
-  void
-  TearDown () override
-  {
-  }
+
   t8_eclass_t eclass;
   int level;
 };
 
-/** Test some default functionality and the iterator of \ref t8_mesh_handle::mesh class. */
-TEST_P (t8_mesh_handle_test, test_iterator)
+/** Test default \ref t8_mesh_handle::mesh handle class, the iterator and some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_default_mesh_handle)
 {
-  // --- Check default functionality. ---
   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,
@@ -62,21 +58,18 @@ TEST_P (t8_mesh_handle_test, test_iterator)
   EXPECT_FALSE (element_class::has_vertex_cache ());
   EXPECT_FALSE (element_class::has_centroid_cache ());
 
-  // Iterate with the iterator over all mesh elements and check some functionality.
+  // Iterate with the constant iterator over all mesh elements and check some functionality.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->has_vertex_cache ());
     EXPECT_FALSE (it->has_centroid_cache ());
     auto centroid = it->get_centroid ();
     for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    // Test dereference operator.
     auto vertex_coordinates = (*it).get_vertex_coordinates ();
     for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
       for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
   }
@@ -84,128 +77,98 @@ TEST_P (t8_mesh_handle_test, test_iterator)
   // Check loop with indices.
   for (int ielement = 0; ielement < mesh->get_num_local_elements (); ielement++) {
     EXPECT_EQ (level, (*mesh)[ielement].get_level ());
+    EXPECT_EQ (ielement, (*mesh)[ielement].get_element_handle_id ());
   }
 }
 
-/** Test competences. */
-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 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> (
-    eclass, level, sc_MPI_COMM_WORLD, true, true, false);
-  EXPECT_TRUE (element_class_vertex::has_vertex_cache ());
-  EXPECT_FALSE (element_class_vertex::has_centroid_cache ());
-
-  // Iterate with the iterator over all mesh elements and check functionality.
-  for (auto it = mesh_vertex->cbegin (); it != mesh_vertex->cend (); ++it) {
-    EXPECT_FALSE (it->vertex_cache_filled ());
-    EXPECT_EQ (level, it->get_level ());
-    auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
-    }
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
-      }
-    }
-  }
-  // Check cached value.
-  for (auto it = mesh_vertex->cbegin (); it != mesh_vertex->cend (); ++it) {
-    EXPECT_TRUE (it->vertex_cache_filled ());
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
-      }
-    }
-  }
-
-  // --- Version with cached centroid variable. ---
-  using competence_centroid = t8_mesh_handle::competence_pack<t8_mesh_handle::cache_centroid>;
-  using mesh_class_centroid = t8_mesh_handle::mesh<competence_centroid>;
-  using element_class_centroid = typename mesh_class_centroid::element_class;
-  auto mesh_centroid = t8_mesh_handle::handle_hypercube_uniform_default<mesh_class_centroid> (
-    eclass, level, sc_MPI_COMM_WORLD, true, true, false);
-  EXPECT_FALSE (element_class_centroid::has_vertex_cache ());
-  EXPECT_TRUE (element_class_centroid::has_centroid_cache ());
-
-  // Iterate with the iterator over all mesh elements.
-  for (auto it = mesh_centroid->cbegin (); it != mesh_centroid->cend (); ++it) {
-    EXPECT_FALSE (it->centroid_cache_filled ());
-    auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
-    }
-    EXPECT_TRUE (it->centroid_cache_filled ());
-    auto centroid_cached = it->get_centroid ();
-    for (const auto& coordinate : centroid_cached) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
-    }
-  }
-}
-
-/** Test mesh (element) class with more than one competence. */
-TEST_P (t8_mesh_handle_test, test_2_competences)
+/** Test mesh class with predefined competence pack using some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_all_cache_competence_pack)
 {
-  // --- Use competences to cache level and centroid. ---
-  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::cache_competences>;
+  // --- Use predefined competence pack to use all available caching competences. ---
+  using mesh_class = t8_mesh_handle::mesh<t8_mesh_handle::all_cache_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);
   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_area_cache ());
+  EXPECT_TRUE (element_class::has_face_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_normal_cache ());
+  EXPECT_TRUE (element_class::has_face_neighbor_cache ());
 
-  // Iterate with the iterator over all mesh elements.
+  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_FALSE (it->volume_cache_filled ());
     EXPECT_FALSE (it->centroid_cache_filled ());
     EXPECT_FALSE (it->vertex_cache_filled ());
     EXPECT_EQ (level, it->get_level ());
     EXPECT_GE (it->get_volume (), 0);
-    auto centroid = it->get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    for (const auto& coordinate : it->get_centroid ()) {
+      EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
     }
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    for (int ivertex = 0; ivertex < it->get_num_vertices (); ++ivertex) {
+      for (const auto& coordinate : it->get_vertex_coordinates (ivertex)) {
+        EXPECT_TRUE (coordinate >= 0 && coordinate <= 1);
       }
     }
   }
-  // Check if caches are set.
+  // Check if caches are set. If caches are accessed correctly is checked in another test.
   for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
     EXPECT_TRUE (it->volume_cache_filled ());
     EXPECT_TRUE (it->centroid_cache_filled ());
     EXPECT_TRUE (it->vertex_cache_filled ());
-    EXPECT_EQ (level, (*it).get_level ());
-    EXPECT_GE (it->get_volume (), 0);
-    auto centroid = (*it).get_centroid ();
-    for (const auto& coordinate : centroid) {
-      EXPECT_GE (1, coordinate);
-      EXPECT_LE (0, coordinate);
+    EXPECT_FALSE (it->diameter_cache_filled ());
+    if (it->get_num_faces () > 0) {
+      EXPECT_FALSE (it->face_area_cache_filled (0));
+      EXPECT_FALSE (it->face_centroid_cache_filled (0));
+      EXPECT_FALSE (it->face_normal_cache_filled (0));
     }
-    auto vertex_coordinates = it->get_vertex_coordinates ();
-    for (int ivertex = 0; ivertex < (int) vertex_coordinates.size (); ++ivertex) {
-      for (const auto& coordinate : vertex_coordinates[ivertex]) {
-        EXPECT_GE (1, coordinate);
-        EXPECT_LE (0, coordinate);
+    EXPECT_FALSE (it->neighbor_cache_filled_any ());
+  }
+}
+
+/** Test mesh class with predefined face competence pack using some exemplary functionality. */
+TEST_P (t8_mesh_handle_test, test_cache_face_competences_pack)
+{
+  // --- Use predefined competence pack to use all available face caching 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,
+                                                                            true, false);
+  EXPECT_FALSE (element_class::has_volume_cache ());
+  EXPECT_FALSE (element_class::has_diameter_cache ());
+  EXPECT_FALSE (element_class::has_vertex_cache ());
+  EXPECT_FALSE (element_class::has_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_area_cache ());
+  EXPECT_TRUE (element_class::has_face_centroid_cache ());
+  EXPECT_TRUE (element_class::has_face_normal_cache ());
+  EXPECT_TRUE (element_class::has_face_neighbor_cache ());
+
+  // Iterate over all mesh elements and access some exemplary functionality which sets the caches.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    if (it->get_num_faces () == 0) {
+      GTEST_SKIP () << "Skipping test as there are no faces to be tested.";
+    }
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_FALSE (it->face_area_cache_filled (iface));
+      EXPECT_FALSE (it->face_normal_cache_filled (iface));
+      EXPECT_GE (it->get_face_area (iface), 0);
+      for (const auto& coordinate : it->get_face_normal (iface)) {
+        EXPECT_TRUE (coordinate >= -1 && coordinate <= 1);
       }
     }
   }
+  // Check if caches are set. If caches are accessed correctly is checked in another test.
+  for (auto it = mesh->cbegin (); it != mesh->cend (); ++it) {
+    for (int iface = 0; iface < it->get_num_faces (); ++iface) {
+      EXPECT_TRUE (it->face_area_cache_filled (iface));
+      EXPECT_FALSE (it->face_centroid_cache_filled (iface));
+      EXPECT_TRUE (it->face_normal_cache_filled (iface));
+    }
+    EXPECT_FALSE (it->neighbor_cache_filled_any ());
+  }
 }
 
 INSTANTIATE_TEST_SUITE_P (t8_gtest_mesh, t8_mesh_handle_test, testing::Combine (AllEclasses, testing::Range (2, 3)));