fully_distributed_tria.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2020 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/distributed/tria_base.h>

#include <deal.II/grid/grid_tools.h>

#include <vector>

#ifdef DEAL_II_WITH_MPI
#  include <mpi.h>
#endif

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>
    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(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);

      virtual void
      execute_coarsening_and_refinement() override;

      virtual bool
      prepare_coarsening_and_refinement() override;

      virtual bool
      has_hanging_nodes() const override;

      virtual std::size_t
      memory_consumption() const override;

      virtual bool
      is_multilevel_hierarchy_constructed() const 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;

      TriangulationDescription::Settings settings;

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

      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