shared_tria.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2008 - 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_distributed_shared_tria_h
#define dealii_distributed_shared_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/tria_base.h>

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

#include <functional>
#include <list>
#include <set>
#include <tuple>
#include <utility>
#include <vector>

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


DEAL_II_NAMESPACE_OPEN

namespace parallel
{
#ifdef DEAL_II_WITH_MPI


  namespace shared
  {
    template <int dim, int spacedim = dim>
    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(
        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;

      /*
       * @copydoc Triangulation::create_triangulation()
       *
       * @note Not inmplemented yet.
       */
      virtual void
      create_triangulation(
        const TriangulationDescription::Description<dim, spacedim>
          &construction_data) override;

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

      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>
    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>
    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

DEAL_II_NAMESPACE_CLOSE

#endif