tria.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) 2010 - 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_distributed_tria_h
#define dealii_distributed_tria_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/enable_observer_pointer.h>
#include <deal.II/base/mpi_stub.h>
#include <deal.II/base/observer_pointer.h>
#include <deal.II/base/template_constraints.h>
 
#include <deal.II/distributed/p4est_wrappers.h>
#include <deal.II/distributed/tria_base.h>
 
#include <deal.II/grid/tria.h>
 
#include <boost/range/iterator_range.hpp>
 
#include <functional>
#include <list>
#include <set>
#include <type_traits>
#include <utility>
#include <vector>
 
#ifdef DEAL_II_WITH_P4EST
#  include <p4est.h>
#  include <p4est_connectivity.h>
#  include <p4est_ghost.h>
#  include <p8est.h>
#  include <p8est_connectivity.h>
#  include <p8est_ghost.h>
#endif
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
 
namespace FETools
{
  namespace internal
  {
    template <int, int, class>
    class ExtrapolateImplementation;
  }
} // namespace FETools
 
// forward declaration of the data type for periodic face pairs
namespace GridTools
{
  template <typename CellIterator>
  struct PeriodicFacePair;
}
 
namespace parallel
{
  namespace distributed
  {
    template <int, int>
    class TemporarilyMatchRefineFlags;
  }
} // namespace parallel
 
namespace internal
{
  namespace parallel
  {
    namespace distributed
    {
      namespace TriangulationImplementation
      {
        template <int dim, int spacedim>
        void
        exchange_refinement_flags(
          ::parallel::distributed::Triangulation<dim, spacedim> &);
      }
    } // namespace distributed
  }   // namespace parallel
} // namespace internal
#endif
 
 
 
#ifdef DEAL_II_WITH_P4EST
 
namespace parallel
{
  namespace distributed
  {
    template <int dim, int spacedim = dim>
    DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
    class Triangulation
      : public ::parallel::DistributedTriangulationBase<dim, spacedim>
    {
    public:
      using cell_iterator =
        typename ::Triangulation<dim, spacedim>::cell_iterator;
 
      using active_cell_iterator =
        typename ::Triangulation<dim, spacedim>::active_cell_iterator;
 
      enum Settings
      {
        default_setting = 0x0,
        mesh_reconstruction_after_repartitioning = 0x1,
        construct_multigrid_hierarchy = 0x2,
        no_automatic_repartitioning = 0x4,
        communicate_vertices_to_p4est = 0x8
      };
 
 
 
      explicit Triangulation(
        const MPI_Comm mpi_communicator,
        const typename ::Triangulation<dim, spacedim>::MeshSmoothing
          smooth_grid           = (::Triangulation<dim, spacedim>::none),
        const Settings settings = default_setting);
 
      virtual ~Triangulation() override;
 
      virtual void
      clear() override;
 
      bool
      is_multilevel_hierarchy_constructed() const override;
 
      bool
      are_vertices_communicated_to_p4est() const;
 
      void
      execute_transfer(
        const typename ::internal::p4est::types<dim>::forest
          *parallel_forest,
        const typename ::internal::p4est::types<dim>::gloidx
          *previous_global_first_quadrant);
 
      virtual void
      copy_triangulation(
        const ::Triangulation<dim, spacedim> &other_tria) override;
 
      void
      copy_triangulation(const ::Triangulation<dim, spacedim> &other_tria,
                         const Settings                              settings);
 
      virtual void
      create_triangulation(const std::vector<Point<spacedim>> &vertices,
                           const std::vector<CellData<dim>>   &cells,
                           const SubCellData &subcelldata) override;
 
      virtual void
      create_triangulation(
        const TriangulationDescription::Description<dim, spacedim>
          &construction_data) override;
 
      types::subdomain_id
      find_point_owner_rank(const Point<dim> &p);
 
      std::vector<types::subdomain_id>
      find_point_owner_rank(const std::vector<Point<dim>> &points);
 
      virtual void
      execute_coarsening_and_refinement() override;
 
      virtual bool
      prepare_coarsening_and_refinement() override;
 
      void
      repartition();
 
      virtual std::size_t
      memory_consumption() const override;
 
      virtual std::size_t
      memory_consumption_p4est() const;
 
      void
      write_mesh_vtk(const std::string &file_basename) const;
 
      unsigned int
      get_checksum() const;
 
      virtual void
      save(const std::string &file_basename) const override;
 
      virtual void
      load(const std::string &file_basename) override;
 
      void
      load(const typename ::internal::p4est::types<dim>::forest *forest);
 
      const std::vector<types::global_dof_index> &
      get_p4est_tree_to_coarse_cell_permutation() const;
 
      const std::vector<types::global_dof_index> &
      get_coarse_cell_to_p4est_tree_permutation() const;
 
      const typename ::internal::p4est::types<dim>::forest *
      get_p4est() const;
 
      virtual void
      add_periodicity(
        const std::vector<::GridTools::PeriodicFacePair<cell_iterator>> &)
        override;
 
 
    private:
      Settings settings;
 
      bool triangulation_has_content;
 
      typename ::internal::p4est::types<dim>::connectivity *connectivity;
 
      typename ::internal::p4est::types<dim>::forest *parallel_forest;
 
      typename ::internal::p4est::types<dim>::ghost *parallel_ghost;
 
      void
      update_cell_relations();
 
      std::vector<types::global_dof_index>
        coarse_cell_to_p4est_tree_permutation;
      std::vector<types::global_dof_index>
        p4est_tree_to_coarse_cell_permutation;
 
      typename ::internal::p4est::types<dim>::tree *
      init_tree(const int dealii_coarse_cell_index) const;
 
      void
      setup_coarse_cell_to_p4est_tree_permutation();
 
      void copy_new_triangulation_to_p4est(std::integral_constant<int, 2>);
      void copy_new_triangulation_to_p4est(std::integral_constant<int, 3>);
 
      void
      copy_local_forest_to_triangulation();
 
      std::vector<unsigned int>
      get_cell_weights() const;
 
      std::vector<bool>
      mark_locally_active_vertices_on_level(const int level) const;
 
      virtual unsigned int
      coarse_cell_id_to_coarse_cell_index(
        const types::coarse_cell_id coarse_cell_id) const override;
 
      virtual types::coarse_cell_id
      coarse_cell_index_to_coarse_cell_id(
        const unsigned int coarse_cell_index) const override;
 
      template <int, int, class>
      friend class ::FETools::internal::ExtrapolateImplementation;
 
      template <int, int>
      friend class TemporarilyMatchRefineFlags;
    };
 
 
    template <int spacedim>
    DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<1, spacedim>))
    class Triangulation<1, spacedim>
      : public ::parallel::DistributedTriangulationBase<1, spacedim>
    {
    public:
      enum Settings
      {
        default_setting                          = 0x0,
        mesh_reconstruction_after_repartitioning = 0x1,
        construct_multigrid_hierarchy            = 0x2,
        no_automatic_repartitioning              = 0x4,
        communicate_vertices_to_p4est            = 0x8
      };
 
      Triangulation(
        const MPI_Comm mpi_communicator,
        const typename ::Triangulation<1, spacedim>::MeshSmoothing
                       smooth_grid = (::Triangulation<1, spacedim>::none),
        const Settings settings    = default_setting);
 
      virtual ~Triangulation() override;
 
      const std::vector<types::global_dof_index> &
      get_p4est_tree_to_coarse_cell_permutation() const;
 
      virtual void
      load(const std::string &filename) override;
 
      virtual void
      save(const std::string &filename) const override;
 
      virtual bool
      is_multilevel_hierarchy_constructed() const override;
 
      bool
      are_vertices_communicated_to_p4est() const;
 
      void
      update_cell_relations();
 
      std::vector<types::global_dof_index>
        coarse_cell_to_p4est_tree_permutation;
      std::vector<types::global_dof_index>
        p4est_tree_to_coarse_cell_permutation;
 
      virtual std::map<unsigned int, std::set<::types::subdomain_id>>
      compute_level_vertices_with_ghost_neighbors(
        const unsigned int level) const;
 
      virtual std::vector<bool>
      mark_locally_active_vertices_on_level(const unsigned int level) const;
 
      virtual unsigned int
      coarse_cell_id_to_coarse_cell_index(
        const types::coarse_cell_id coarse_cell_id) const override;
 
      virtual types::coarse_cell_id
      coarse_cell_index_to_coarse_cell_id(
        const unsigned int coarse_cell_index) const override;
 
      template <int, int>
      friend class TemporarilyMatchRefineFlags;
    };
  } // namespace distributed
} // namespace parallel
 
 
#else // DEAL_II_WITH_P4EST
 
namespace parallel
{
  namespace distributed
  {
    template <int dim, int spacedim = dim>
    DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
    class Triangulation
      : public ::parallel::DistributedTriangulationBase<dim, spacedim>
    {
    public:
      enum Settings
      {
        default_setting                          = 0x0,
        mesh_reconstruction_after_repartitioning = 0x1,
        construct_multigrid_hierarchy            = 0x2,
        no_automatic_repartitioning              = 0x4,
        communicate_vertices_to_p4est            = 0x8
      };
 
      explicit Triangulation(
        const MPI_Comm /*mpi_communicator*/,
        const typename ::Triangulation<dim, spacedim>::MeshSmoothing
        /*smooth_grid*/
        = (::Triangulation<dim, spacedim>::none),
        const Settings /*settings*/ = default_setting) = delete;
 
      virtual bool
      is_multilevel_hierarchy_constructed() const override
      {
        return false;
      }
 
      bool
      are_vertices_communicated_to_p4est() const
      {
        return false;
      }
 
      virtual void
      save(const std::string & /*filename*/) const override
      {}
 
      virtual void
      load(const std::string & /*filename*/) override
      {}
 
      void
      update_cell_relations()
      {}
    };
  } // namespace distributed
} // namespace parallel
 
 
#endif
 
 
 
namespace parallel
{
  namespace distributed
  {
    template <int dim, int spacedim = dim>
    class TemporarilyMatchRefineFlags : public EnableObserverPointer
    {
    public:
      TemporarilyMatchRefineFlags(::Triangulation<dim, spacedim> &tria);
 
      ~TemporarilyMatchRefineFlags();
 
    private:
      const ObserverPointer<
        ::parallel::distributed::Triangulation<dim, spacedim>>
        distributed_tria;
 
      std::vector<bool> saved_refine_flags;
 
      std::vector<bool> saved_coarsen_flags;
    };
  } // namespace distributed
} // namespace parallel
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif