tria_base.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) 2015 - 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_base_h
#define dealii_distributed_tria_base_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/partitioner.h>
#include <deal.II/base/template_constraints.h>
 
#include <deal.II/grid/tria.h>
 
#include <functional>
#include <list>
#include <set>
#include <utility>
#include <vector>
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace parallel
{
  template <int dim, int spacedim = dim>
  DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
  class TriangulationBase : public ::Triangulation<dim, spacedim>
  {
  public:
    TriangulationBase(
      const MPI_Comm mpi_communicator,
      const typename ::Triangulation<dim, spacedim>::MeshSmoothing
                 smooth_grid = (::Triangulation<dim, spacedim>::none),
      const bool check_for_distorted_cells = false);

    virtual ~TriangulationBase() override;

    virtual MPI_Comm
    get_mpi_communicator() const override;

    virtual bool
    is_multilevel_hierarchy_constructed() const = 0;

    virtual void
    copy_triangulation(
      const ::Triangulation<dim, spacedim> &old_tria) override;

    unsigned int
    n_locally_owned_active_cells() const;

    virtual types::global_cell_index
    n_global_active_cells() const override;

    virtual std::size_t
    memory_consumption() const override;
 

    virtual unsigned int
    n_global_levels() const override;

    types::subdomain_id
    locally_owned_subdomain() const override;

    const std::set<types::subdomain_id> &
    ghost_owners() const;

    const std::set<types::subdomain_id> &
    level_ghost_owners() const;
 
    std::weak_ptr<const Utilities::MPI::Partitioner>
    global_active_cell_index_partitioner() const override;
 
    std::weak_ptr<const Utilities::MPI::Partitioner>
    global_level_cell_index_partitioner(
      const unsigned int level) const override;

    virtual std::vector<types::boundary_id>
    get_boundary_ids() const override;

    virtual std::vector<types::manifold_id>
    get_manifold_ids() const override;

    void
    communicate_locally_moved_vertices(
      const std::vector<bool> &vertex_locally_moved);
 
    virtual types::coarse_cell_id
    n_global_coarse_cells() const override;

    virtual void
    clear() override;
 
  protected:
    const MPI_Comm mpi_communicator;

    types::subdomain_id my_subdomain;

    types::subdomain_id n_subdomains;

    struct NumberCache
    {
      unsigned int n_locally_owned_active_cells;

      types::global_cell_index n_global_active_cells;

      types::coarse_cell_id number_of_global_coarse_cells;

      unsigned int n_global_levels;

      std::set<types::subdomain_id> ghost_owners;

      std::set<types::subdomain_id> level_ghost_owners;

      std::shared_ptr<const Utilities::MPI::Partitioner>
        active_cell_index_partitioner;

      std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
        level_cell_index_partitioners;
 
      NumberCache();
    };
 
    NumberCache number_cache;

    virtual void
    update_number_cache();

    void
    reset_global_cell_indices();
  };
 

  template <int dim, int spacedim = dim>
  DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
  class DistributedTriangulationBase
    : public ::parallel::TriangulationBase<dim, spacedim>
  {
  public:
    DistributedTriangulationBase(
      const MPI_Comm mpi_communicator,
      const typename ::Triangulation<dim, spacedim>::MeshSmoothing
                 smooth_grid = (::Triangulation<dim, spacedim>::none),
      const bool check_for_distorted_cells = false);
 
    using cell_iterator =
      typename ::Triangulation<dim, spacedim>::cell_iterator;

    virtual bool
    has_hanging_nodes() const override;

    using Triangulation<dim, spacedim>::save;
 

    using Triangulation<dim, spacedim>::load;
  };
 
} // namespace parallel
 
DEAL_II_NAMESPACE_CLOSE
 
#endif