.. _program_listing_file_mesh_handle_competences.hxx:

Program Listing for File competences.hxx
========================================

|exhale_lsh| :ref:`Return to documentation for file <file_mesh_handle_competences.hxx>` (``mesh_handle/competences.hxx``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*
   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.
   */
   
   #pragma once
   
   #include <t8.h>
   #include <t8_types/t8_operators.hxx>
   #include <t8_types/t8_vec.hxx>
   #include <vector>
   #include <optional>
   
   namespace t8_mesh_handle
   {
   
   template <typename TUnderlying>
   struct cache_volume: public t8_crtp_operator<TUnderlying, cache_volume>
   {
    public:
     bool
     volume_cache_filled () const
     {
       return m_volume.has_value ();
     }
   
    protected:
     mutable std::optional<double>
       m_volume; 
   };
   
   template <typename TUnderlying>
   struct cache_diameter: public t8_crtp_operator<TUnderlying, cache_diameter>
   {
    public:
     bool
     diameter_cache_filled () const
     {
       return m_diameter.has_value ();
     }
   
    protected:
     mutable std::optional<double>
       m_diameter; 
   };
   
   template <typename TUnderlying>
   struct cache_vertex_coordinates: public t8_crtp_operator<TUnderlying, cache_vertex_coordinates>
   {
    public:
     bool
     vertex_cache_filled () const
     {
       return !m_vertex_coordinates.empty ();
     }
   
    protected:
     mutable std::vector<t8_3D_vec>
       m_vertex_coordinates; 
   };
   
   template <typename TUnderlying>
   struct cache_centroid: public t8_crtp_operator<TUnderlying, cache_centroid>
   {
    public:
     bool
     centroid_cache_filled () const
     {
       return m_centroid.has_value ();
     }
   
    protected:
     mutable std::optional<t8_3D_vec>
       m_centroid; 
   };
   
   // --- Face related caches. ---
   template <typename TUnderlying>
   struct cache_face_areas: t8_crtp_operator<TUnderlying, cache_face_areas>
   {
    public:
     bool
     face_area_cache_filled (int face) const
     {
       return m_face_areas[face].has_value ();
     }
   
    protected:
     mutable std::vector<std::optional<double>> m_face_areas; 
   };
   
   template <typename TUnderlying>
   struct cache_face_centroids: t8_crtp_operator<TUnderlying, cache_face_centroids>
   {
    public:
     bool
     face_centroid_cache_filled (int face) const
     {
       return m_face_centroids[face].has_value ();
     }
   
    protected:
     mutable std::vector<std::optional<t8_3D_vec>> m_face_centroids; 
   };
   
   template <typename TUnderlying>
   struct cache_face_normals: t8_crtp_operator<TUnderlying, cache_face_normals>
   {
    public:
     bool
     face_normal_cache_filled (int face) const
     {
       return m_face_normals[face].has_value ();
     }
   
    protected:
     mutable std::vector<std::optional<t8_3D_vec>> m_face_normals; 
   };
   
   template <typename TUnderlying>
   struct cache_neighbors: t8_crtp_operator<TUnderlying, cache_neighbors>
   {
    public:
     bool
     neighbor_cache_filled (int face) const
     {
       return m_num_neighbors[face].has_value ();
     }
   
     bool
     neighbor_cache_filled_any () const
     {
       for (int iface = 0; iface < this->underlying ().get_num_faces (); ++iface) {
         if (neighbor_cache_filled (iface)) {
           return true;
         }
       }
       return false;
     }
   
    protected:
     mutable std::vector<std::vector<const TUnderlying *>>
       m_neighbors; 
     mutable std::vector<std::optional<int>>
       m_num_neighbors; 
     mutable std::vector<std::vector<int>>
       m_dual_faces; 
   };
   
   }  // namespace t8_mesh_handle