fully_distributed_tria.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.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 <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;
 
      using CellStatus =
        typename ::Triangulation<dim, spacedim>::CellStatus;
 
      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;
 
      DEAL_II_DEPRECATED
      virtual void
      load(const std::string &filename, const bool autopartition) 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;
 
      virtual void
      update_cell_relations() override;
 
      virtual void
      update_number_cache() override;
 
      TriangulationDescription::Settings settings;
 
      std::function<void(::Triangulation<dim, spacedim> &,
                         const unsigned int)>
        partitioner;
 
      SmartPointer<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