shared_tria.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2015 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_distributed_shared_tria_h
#define dealii_distributed_shared_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/tria_base.h>
 
#include <deal.II/grid/tria.h>
 
#include <functional>
#include <list>
#include <utility>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace parallel
{
#ifdef DEAL_II_WITH_MPI
 
 
  namespace shared
  {
    template <int dim, int spacedim = dim>
    DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
    class Triangulation
      : public ::parallel::TriangulationBase<dim, spacedim>
    {
    public:
      using active_cell_iterator =
        typename ::Triangulation<dim, spacedim>::active_cell_iterator;
      using cell_iterator =
        typename ::Triangulation<dim, spacedim>::cell_iterator;
 
      enum Settings
      {
        partition_auto = 0x0,
 
        partition_metis = 0x1,
 
        partition_zorder = 0x2,
 
        partition_zoltan = 0x3,
 
        partition_custom_signal = 0x4,
 
        construct_multigrid_hierarchy = 0x8,
      };
 
 
      Triangulation(
        const MPI_Comm mpi_communicator,
        const typename ::Triangulation<dim, spacedim>::MeshSmoothing =
          (::Triangulation<dim, spacedim>::none),
        const bool     allow_artificial_cells = false,
        const Settings settings               = partition_auto);
 
      virtual ~Triangulation() override = default;
 
      virtual bool
      is_multilevel_hierarchy_constructed() const override;
 
      virtual void
      execute_coarsening_and_refinement() override;
 
      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;
 
      virtual void
      copy_triangulation(
        const ::Triangulation<dim, spacedim> &other_tria) override;
 
#  ifdef DOXYGEN
      template <class Archive>
      void
      serialize(Archive &archive, const unsigned int version);
#  else
      // This macro defines the serialize() method that is compatible with
      // the templated save() and load() method that have been implemented.
      BOOST_SERIALIZATION_SPLIT_MEMBER()
#  endif
 
      using parallel::TriangulationBase<dim, spacedim>::save;
 
      using parallel::TriangulationBase<dim, spacedim>::load;
 
      template <class Archive>
      void
      load(Archive &ar, const unsigned int version);
 
      const std::vector<types::subdomain_id> &
      get_true_subdomain_ids_of_cells() const;
 
      const std::vector<types::subdomain_id> &
      get_true_level_subdomain_ids_of_cells(const unsigned int level) const;
 
      bool
      with_artificial_cells() const;
 
    private:
      const Settings settings;
 
      const bool allow_artificial_cells;
 
      void
      partition();
 
      std::vector<types::subdomain_id> true_subdomain_ids_of_cells;
 
      std::vector<std::vector<types::subdomain_id>>
        true_level_subdomain_ids_of_cells;
    };
 
 
 
    template <int dim, int spacedim>
    DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
    template <class Archive>
    void Triangulation<dim, spacedim>::load(Archive           &ar,
                                            const unsigned int version)
    {
      ::Triangulation<dim, spacedim>::load(ar, version);
      partition();
      this->update_number_cache();
    }
  } // namespace shared
#else
 
  namespace shared
  {
    template <int dim, int spacedim = dim>
    DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
    class Triangulation
      : public ::parallel::TriangulationBase<dim, spacedim>
    {
    public:
      Triangulation() = delete;
 
      virtual bool
      is_multilevel_hierarchy_constructed() const override;
 
      const std::vector<types::subdomain_id> &
      get_true_subdomain_ids_of_cells() const;
 
      const std::vector<types::subdomain_id> &
      get_true_level_subdomain_ids_of_cells(const unsigned int level) const;
 
      bool
      with_artificial_cells() const;
 
    private:
      std::vector<types::subdomain_id> true_subdomain_ids_of_cells;
 
      std::vector<types::subdomain_id> true_level_subdomain_ids_of_cells;
    };
  } // namespace shared
 
 
#endif
} // namespace parallel
 
 
namespace internal
{
  namespace parallel
  {
    namespace shared
    {
      template <int dim, int spacedim = dim>
      class TemporarilyRestoreSubdomainIds : public EnableObserverPointer
      {
      public:
        TemporarilyRestoreSubdomainIds(
          const Triangulation<dim, spacedim> &tria);
 
        ~TemporarilyRestoreSubdomainIds();
 
      private:
        const ObserverPointer<
          const ::parallel::shared::Triangulation<dim, spacedim>>
          shared_tria;
 
        std::vector<unsigned int> saved_subdomain_ids;
      };
    } // namespace shared
  }   // namespace parallel
} // namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif