tria_levels.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 1998 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_tria_levels_h
#define dealii_tria_levels_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/point.h>
 
#include <deal.II/grid/reference_cell.h>
#include <deal.II/grid/tria_objects.h>
#include <deal.II/grid/tria_objects_orientations.h>
 
#include <cstdint>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace internal
{
  namespace TriangulationImplementation
  {
    template <int dim, int spacedim = dim>
    class TriaLevel
    {
    public:
      TriaLevel(const unsigned int max_children_per_cell,
                const unsigned int max_faces_per_cell,
                const unsigned int max_vertices_per_cell)
        : children_per_object(max_children_per_cell)
        , faces_per_object(max_faces_per_cell)
        , vertices_per_object(max_vertices_per_cell)
        , cells(dim, max_children_per_cell, max_faces_per_cell)
        , face_orientations(0, max_faces_per_cell)
      {}

      TriaLevel();

      void
      allocate(const std::size_t n_cells, const bool orientation_needed);

      void
      allocate_end(const std::size_t n_new_cells,
                   const bool        orientation_needed,
                   const bool        has_tetrahedra);

      std::size_t
      size() const;

      int
      neighbor_index(const int index, const unsigned int face_no) const;

      int
      neighbor_level(const int index, const unsigned int face_no) const;

      void
      set_neighbor(const int          index,
                   const unsigned int face_no,
                   const int          neighbor_level,
                   const int          neighbor_index);

      void
      set_cached_vertex_index(const int          index,
                              const unsigned int vertex_no,
                              const unsigned int vertex_index);

      unsigned int
      cached_vertex_index(const int index, const unsigned int vertex_no) const;

      unsigned int children_per_object;

      unsigned int faces_per_object;

      unsigned int vertices_per_object;

      std::vector<std::uint8_t> refine_flags;

      std::vector<std::uint8_t> refine_choice;

      std::vector<bool> coarsen_flags;

      std::vector<unsigned int> active_cell_indices;

      std::vector<types::global_cell_index> global_active_cell_indices;

      std::vector<types::global_cell_index> global_level_cell_indices;

      std::vector<types::subdomain_id> subdomain_ids;

      std::vector<types::subdomain_id> level_subdomain_ids;

      std::vector<int> parents;

      std::vector<bool> direction_flags;

      TriaObjects cells;

      TriaObjectsOrientations face_orientations;

      std::vector<ReferenceCell<dim>> reference_cell;

      std::size_t
      memory_consumption() const;

      template <class Archive>
      void
      serialize(Archive &ar, const unsigned int version);
 
    private:
      std::vector<std::int8_t> neighbor_levels;

      std::vector<int> neighbor_indices;

      std::vector<unsigned int> cell_vertex_indices_cache;
    };
 
 
 
    template <int dim, int spacedim>
    std::size_t
    TriaLevel<dim, spacedim>::size() const
    {
      Assert(refine_flags.size() == coarsen_flags.size() &&
               refine_flags.size() == active_cell_indices.size() &&
               refine_flags.size() == global_active_cell_indices.size() &&
               refine_flags.size() == global_level_cell_indices.size() &&
               refine_flags.size() == subdomain_ids.size() &&
               refine_flags.size() == level_subdomain_ids.size() &&
               refine_flags.size() == cells.n_objects(),
             ExcInternalError());
      if constexpr (dim > 1)
        Assert(refine_flags.size() == reference_cell.size(),
               ExcInternalError());
 
      return refine_flags.size();
    }
 
 
 
    template <int dim, int spacedim>
    inline int
    TriaLevel<dim, spacedim>::neighbor_index(const int          index,
                                             const unsigned int face_no) const
    {
      Assert(index >= 0, ExcInternalError());
      AssertIndexRange(face_no, faces_per_object);
      const std::size_t i = index * faces_per_object + face_no;
      AssertIndexRange(i, neighbor_indices.size());
      return neighbor_indices[i];
    }
 
 
 
    template <int dim, int spacedim>
    inline int
    TriaLevel<dim, spacedim>::neighbor_level(const int          index,
                                             const unsigned int face_no) const
    {
      Assert(index >= 0, ExcInternalError());
      AssertIndexRange(face_no, faces_per_object);
      const std::size_t i = index * faces_per_object + face_no;
      AssertIndexRange(i, neighbor_levels.size());
      return neighbor_levels[i];
    }
 
 
 
    template <int dim, int spacedim>
    inline void
    TriaLevel<dim, spacedim>::set_neighbor(const int          index,
                                           const unsigned int face_no,
                                           const int          neighbor_level,
                                           const int          neighbor_index)
    {
      Assert(index >= 0, ExcInternalError());
      AssertIndexRange(face_no, faces_per_object);
      Assert(neighbor_level >= -1,
             ExcMessage("The neighbor level must be -1 (for a cell at the "
                        "boundary) or a nonnegative number."));
      Assert(neighbor_level < int(numbers::max_n_levels), ExcInternalError());
      Assert(neighbor_index >= -1,
             ExcMessage("The neighbor index must be -1 (for a cell at the "
                        "boundary) or a nonnegative number."));
      const std::size_t i = index * faces_per_object + face_no;
      AssertIndexRange(i, neighbor_levels.size());
      AssertIndexRange(i, neighbor_indices.size());
      neighbor_levels[i]  = neighbor_level;
      neighbor_indices[i] = neighbor_index;
    }
 
 
 
    template <int dim, int spacedim>
    inline void
    TriaLevel<dim, spacedim>::set_cached_vertex_index(
      const int          index,
      const unsigned int vertex_no,
      const unsigned int vertex_index)
    {
      Assert(index >= 0, ExcInternalError());
      AssertIndexRange(vertex_no, vertices_per_object);
      const std::size_t i =
        std::size_t(index) * vertices_per_object + vertex_no;
      AssertIndexRange(i, cell_vertex_indices_cache.size());
      cell_vertex_indices_cache[i] = vertex_index;
    }
 
 
 
    template <int dim, int spacedim>
    inline unsigned int
    TriaLevel<dim, spacedim>::cached_vertex_index(
      const int          index,
      const unsigned int vertex_no) const
    {
      Assert(index >= 0, ExcInternalError());
      AssertIndexRange(vertex_no, vertices_per_object);
      const std::size_t i =
        std::size_t(index) * vertices_per_object + vertex_no;
      AssertIndexRange(i, cell_vertex_indices_cache.size());
      return cell_vertex_indices_cache[i];
    }
 
 
 
    template <int dim, int spacedim>
    template <class Archive>
    void
    TriaLevel<dim, spacedim>::serialize(Archive &ar, const unsigned int)
    {
      ar &refine_flags &coarsen_flags;
 
      ar &children_per_object;
      ar &faces_per_object;
      ar &vertices_per_object;
 
      // do not serialize `active_cell_indices` and `vertex_indices_cache`
      // here. instead of storing them to the stream and re-reading them again
      // later, we just rebuild them in Triangulation::load()
 
      ar &neighbor_levels;
      ar &neighbor_indices;
      ar &subdomain_ids;
      ar &level_subdomain_ids;
      ar &parents;
      ar &direction_flags;
      ar &cells;
      ar &face_orientations;
      ar &reference_cell;
 
      // we do need to resize them so they can be populated in the other
      // functions though.
      if (cell_vertex_indices_cache.size() !=
          refine_flags.size() * vertices_per_object)
        {
          cell_vertex_indices_cache.assign(refine_flags.size() *
                                             vertices_per_object,
                                           numbers::invalid_unsigned_int);
          active_cell_indices.assign(refine_flags.size(),
                                     numbers::invalid_unsigned_int);
          global_active_cell_indices.assign(refine_flags.size(),
                                            numbers::invalid_coarse_cell_id);
          global_level_cell_indices.assign(refine_flags.size(),
                                           numbers::invalid_coarse_cell_id);
        }
    }
 
  } // namespace TriangulationImplementation
} // namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif