fully_distributed_tria.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2019 - 2025 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_fully_distributed_tria_h
#define dealii_fully_distributed_tria_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/mpi_stub.h>
 
#include <deal.II/distributed/repartitioning_policy_tools.h>
#include <deal.II/distributed/tria_base.h>
 
#include <deal.II/grid/tria_description.h>
 
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
// forward declaration of the data type for periodic face pairs
namespace GridTools
{
  template <typename CellIterator>
  struct PeriodicFacePair;
}
#endif
 
namespace parallel
{
  namespace fullydistributed
  {
    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;

      explicit Triangulation(const MPI_Comm mpi_communicator);

      virtual ~Triangulation() = default;

      void
      create_triangulation(
        const TriangulationDescription::Description<dim, spacedim>
          &construction_data) override;

      virtual void
      create_triangulation(const std::vector<Point<spacedim>>       &vertices,
                           const std::vector<::CellData<dim>> &cells,
                           const SubCellData &subcelldata) override;

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

      void
      set_partitioner(
        const std::function<void(::Triangulation<dim, spacedim> &,
                                 const unsigned int)> &partitioner,
        const TriangulationDescription::Settings      &settings);

      void
      set_partitioner(
        const RepartitioningPolicyTools::Base<dim, spacedim> &partitioner,
        const TriangulationDescription::Settings             &settings);

      void
      repartition();

      virtual void
      execute_coarsening_and_refinement() override;

      virtual bool
      prepare_coarsening_and_refinement() override;

      virtual std::size_t
      memory_consumption() const override;
 
      virtual bool
      is_multilevel_hierarchy_constructed() const override;

      virtual void
      save(const std::string &filename) const override;

      virtual void
      load(const std::string &filename) override;
 
    private:
      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;

      void
      update_cell_relations();
 
      virtual void
      update_number_cache() override;

      TriangulationDescription::Settings settings;

      std::function<void(::Triangulation<dim, spacedim> &,
                         const unsigned int)>
        partitioner;

      ObserverPointer<const RepartitioningPolicyTools::Base<dim, spacedim>>
        partitioner_distributed;

      std::vector<std::pair<types::coarse_cell_id, unsigned int>>
        coarse_cell_id_to_coarse_cell_index_vector;

      std::vector<types::coarse_cell_id>
        coarse_cell_index_to_coarse_cell_id_vector;

      bool currently_processing_create_triangulation_for_internal_usage;

      bool
        currently_processing_prepare_coarsening_and_refinement_for_internal_usage;
    };
 
  } // namespace fullydistributed
} // namespace parallel
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif