tria.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2008 - 2021 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_distributed_tria_h
#define dealii_distributed_tria_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/subscriptor.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_MPI
#  include <mpi.h>
#endif
 
#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
 
#ifdef DEAL_II_WITH_P4EST
 
// 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
#  endif
 
namespace parallel
{
  namespace distributed
  {
    template <int dim, int spacedim = dim>
    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;
 
      enum Settings
      {
        default_setting = 0x0,
        mesh_reconstruction_after_repartitioning = 0x1,
        construct_multigrid_hierarchy = 0x2,
        no_automatic_repartitioning = 0x4
      };
 
 
 
      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;
 
      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;
 
      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
      execute_coarsening_and_refinement() override;
 
      virtual bool
      prepare_coarsening_and_refinement() override;
 
      void
      repartition();
 
 
      virtual bool
      has_hanging_nodes() const override;
 
      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 &filename) const override;
 
      virtual void
      load(const std::string &filename,
           const bool         autopartition = true) 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;
 
      virtual void
      update_cell_relations() override;
 
      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>
    class Triangulation<1, spacedim>
      : public ::parallel::DistributedTriangulationBase<1, spacedim>
    {
    public:
      enum Settings
      {
        default_setting                          = 0x0,
        mesh_reconstruction_after_repartitioning = 0x1,
        construct_multigrid_hierarchy            = 0x2
      };
 
      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,
           const bool         autopartition = true) override;
 
      virtual void
      save(const std::string &filename) const override;
 
      virtual bool
      is_multilevel_hierarchy_constructed() const override;
 
      virtual void
      update_cell_relations() override;
 
      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>
    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
      };
 
      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;
      }
 
      virtual void
      save(const std::string & /*filename*/) const override
      {}
 
      virtual void
      load(const std::string & /*filename*/,
           const bool /*autopartition*/ = true) override
      {}
 
      virtual void
      update_cell_relations() override
      {}
    };
  } // namespace distributed
} // namespace parallel
 
 
#endif
 
 
namespace parallel
{
  namespace distributed
  {
    template <int dim, int spacedim = dim>
    class TemporarilyMatchRefineFlags : public Subscriptor
    {
    public:
      TemporarilyMatchRefineFlags(::Triangulation<dim, spacedim> &tria);
 
      ~TemporarilyMatchRefineFlags();
 
    private:
      const SmartPointer<
        ::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