Program Listing for File competences.hxx

↰ Return to documentation for file (mesh_handle/competences.hxx)

/*
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