easier competence checks

Author: lenaploetzke

mesh_handle/element.hxx

@@ -59,7 +59,7 @@ namespace t8_mesh_handle
  */
 template <typename mesh_class, template <typename> class... TCompetence>
 class element: public TCompetence<element<mesh_class, TCompetence...>>... {
- protected:
+ private:
   using SelfType
     = 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. */
@@ -84,7 +84,7 @@ 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);
     }
 
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       // Resize neighbor caches for clean access to the caches.
       const int num_faces = this->get_num_faces ();
       this->m_num_neighbors.resize (num_faces);
@@ -104,10 +104,6 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.volume_cache_filled (); };
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function volume_cache_filled. */
-  static constexpr bool volume_cache_exists = (false || ... || volume_cache_defined<TCompetence> ());
-
   /** 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.
@@ -118,10 +114,6 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.vertex_cache_filled (); };
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function vertex_cache_filled. */
-  static constexpr bool vertex_cache_exists = (false || ... || vertex_cache_defined<TCompetence> ());
-
   /** 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.
@@ -132,10 +124,6 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.centroid_cache_filled (); };
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  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 neighbor_cache_filled.
    * \tparam T The competence to be checked.
    * \return true if T implements the function, false if not.
@@ -146,9 +134,6 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   {
     return requires (T<SelfType>& competence) { competence.neighbor_cache_filled (0); };
   }
-  /** This variable is true if any of the given competences \a TCompetence implements 
-  a function neighbor_cache_filled. */
-  static constexpr bool neighbor_cache_exists = (false || ... || neighbor_cache_defined<TCompetence> ());
 
  public:
   // --- Public functions to check if caches exist. ---
@@ -159,7 +144,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   static constexpr bool
   has_volume_cache ()
   {
-    return volume_cache_exists;
+    return (false || ... || volume_cache_defined<TCompetence> ());
   }
   /**
    * Function that checks if a cache for the vertex coordinates exists.
@@ -168,7 +153,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   static constexpr bool
   has_vertex_cache ()
   {
-    return vertex_cache_exists;
+    return (false || ... || vertex_cache_defined<TCompetence> ());
   }
 
   /**
@@ -178,7 +163,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   static constexpr bool
   has_centroid_cache ()
   {
-    return centroid_cache_exists;
+    return (false || ... || centroid_cache_defined<TCompetence> ());
   }
 
   /**
@@ -188,7 +173,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   static constexpr bool
   has_face_neighbor_cache ()
   {
-    return neighbor_cache_exists;
+    return (false || ... || neighbor_cache_defined<TCompetence> ());
   }
 
   // --- Functionality of the element. In each function, it is checked if a cached version exists (and is used then). ---
@@ -235,7 +220,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   double
   get_volume () const
   {
-    if constexpr (volume_cache_exists) {
+    if constexpr (has_volume_cache ()) {
       if (this->volume_cache_filled ()) {
         return this->m_volume.value ();
       }
@@ -255,7 +240,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   get_vertex_coordinates () const
   {
     // Check if we have a cached version and if the cache has already been filled.
-    if constexpr (vertex_cache_exists) {
+    if constexpr (has_vertex_cache ()) {
       if (this->vertex_cache_filled ()) {
         return this->m_vertex_coordinates;
       }
@@ -269,7 +254,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       t8_forest_element_coordinate (m_mesh->m_forest, m_tree_id, element, icorner, vertex_coordinates[icorner].data ());
     }
     // Fill the cache in the cached version.
-    if constexpr (vertex_cache_exists) {
+    if constexpr (has_vertex_cache ()) {
       this->m_vertex_coordinates = std::move (vertex_coordinates);
       return this->m_vertex_coordinates;
     }
@@ -285,15 +270,15 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
   get_centroid () const
   {
     // Check if we have a cached version and if the cache has already been filled.
-    if constexpr (centroid_cache_exists) {
+    if constexpr (has_centroid_cache ()) {
       if (this->centroid_cache_filled ()) {
         return this->m_centroid.value ();
       }
     }
     t8_3D_point coordinates;
     t8_forest_element_centroid (m_mesh->m_forest, m_tree_id, get_element (), coordinates.data ());
     // Fill the cache in the cached version.
-    if constexpr (centroid_cache_exists) {
+    if constexpr (has_centroid_cache ()) {
       this->m_centroid = coordinates;
     }
     return coordinates;
@@ -304,13 +289,12 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
    * \param [in]  face          The index of the face across which the face neighbors are searched.
    * \param [out] dual_faces    On output the face id's of the neighboring elements' faces.
    * \return Vector of length num_neighbors with pointers to the elements neighboring at the given face.
-   * \note For ghost elements, the functionality to calculate face neighbors is currently not provided.
    */
   std::vector<const SelfType*>
   get_face_neighbors (int face, std::optional<std::reference_wrapper<std::vector<int>>> dual_faces = std::nullopt) const
   {
     SC_CHECK_ABORT (!m_is_ghost_element, "get_face_neighbors is not implemented for ghost elements.\n");
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       if (this->neighbor_cache_filled (face)) {
         if (dual_faces) {
           dual_faces->get () = this->m_dual_faces[face];
@@ -334,7 +318,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
     for (int ineighs = 0; ineighs < num_neighbors; ineighs++) {
       neighbors_handle.push_back (&((*m_mesh)[neighids[ineighs]]));
     }
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       // Also store num_neighbors in cache to indicate that the cache is filled if a face does not have any neighbor.
       this->m_num_neighbors[face] = num_neighbors;
       this->m_dual_faces[face].assign (dual_faces_internal, dual_faces_internal + num_neighbors);
@@ -347,7 +331,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
       T8_FREE (dual_faces_internal);
       T8_FREE (neighids);
     }
-    if constexpr (neighbor_cache_exists) {
+    if constexpr (has_face_neighbor_cache ()) {
       return this->m_neighbors[face];
     }
     return neighbors_handle;
@@ -358,7 +342,7 @@ class element: public TCompetence<element<mesh_class, TCompetence...>>... {
    */
   void
   fill_face_neighbor_cache () const
-    requires (neighbor_cache_exists)
+    requires (has_face_neighbor_cache ())
   {
     for (int iface = 0; iface < get_num_faces (); iface++) {
       get_face_neighbors (iface);