tria.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2008 - 2018 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_distributed_tria_h
#define dealii_distributed_tria_h


#include <deal.II/base/config.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/template_constraints.h>
#include <deal.II/grid/tria.h>

#include <deal.II/distributed/tria_base.h>
#include <deal.II/distributed/p4est_wrappers.h>

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

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

#ifdef DEAL_II_WITH_P4EST
#include <p4est_connectivity.h>
#include <p4est.h>
#include <p4est_ghost.h>

#include <p8est_connectivity.h>
#include <p8est.h>
#include <p8est_ghost.h>
#endif


DEAL_II_NAMESPACE_OPEN

#ifdef DEAL_II_WITH_P4EST

namespace internal
{
  namespace DoFHandlerImplementation
  {
    namespace Policy
    {
      template <typename> class ParallelDistributed;
    }
  }
}

namespace FETools
{
  namespace internal
  {
    template <int, int, class> class ExtrapolateImplementation;
  }
}

//forward declaration of the data type for periodic face pairs
namespace GridTools
{
  template <typename CellIterator> struct PeriodicFacePair;
}

namespace parallel
{
  namespace distributed
  {


    template <int dim, int spacedim = dim>
    class Triangulation : public ::parallel::Triangulation<dim,spacedim>
    {
    public:
      typedef typename ::Triangulation<dim,spacedim>::cell_iterator        cell_iterator;

      typedef typename ::Triangulation<dim,spacedim>::active_cell_iterator active_cell_iterator;

      typedef typename ::Triangulation<dim,spacedim>::CellStatus CellStatus;

      enum Settings
      {
        default_setting = 0x0,
        mesh_reconstruction_after_repartitioning = 0x1,
        construct_multigrid_hierarchy = 0x2,
        no_automatic_repartitioning = 0x4
      };



      Triangulation (MPI_Comm mpi_communicator,
                     const typename ::Triangulation<dim,spacedim>::MeshSmoothing
                     smooth_grid = (::Triangulation<dim,spacedim>::none),
                     const Settings settings = default_setting);

      virtual ~Triangulation ();

      virtual void clear ();

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

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

      virtual void execute_coarsening_and_refinement ();

      virtual bool prepare_coarsening_and_refinement ();

      void repartition ();

      void
      communicate_locally_moved_vertices (const std::vector<bool> &vertex_locally_moved);


      virtual
      bool has_hanging_nodes() const;

      virtual std::size_t memory_consumption () const;

      virtual std::size_t memory_consumption_p4est () const;

      void write_mesh_vtk (const char *file_basename) const;

      unsigned int get_checksum () const;

      void save(const char *filename) const;

      void load(const char *filename,
                const bool autopartition = true);

      unsigned int
      register_data_attach (const std::size_t size,
                            const std::function<void (const cell_iterator &,
                                                      const CellStatus,
                                                      void *)> &pack_callback);

      void
      notify_ready_to_unpack (const unsigned int handle,
                              const std::function<void (const cell_iterator &,
                                                        const CellStatus,
                                                        const void *)> &unpack_callback);

      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;

      virtual void
      add_periodicity
      (const std::vector<::GridTools::PeriodicFacePair<cell_iterator> > &);


    private:

      virtual void update_number_cache ();

      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;

      struct CellAttachedData
      {
        unsigned int cumulative_fixed_data_size;

        unsigned int n_attached_datas;

        unsigned int n_attached_deserialize;

        using pack_callback_t = std::function<void (typename Triangulation<dim,spacedim>::cell_iterator,
                                                    CellStatus,
                                                    void *)>;

        std::map<unsigned int, pack_callback_t> pack_callbacks;
      };

      CellAttachedData cell_attached_data;

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

      void attach_mesh_data();

      std::vector<unsigned int>
      get_cell_weights();

      virtual std::map<unsigned int, std::set<::types::subdomain_id> >
      compute_vertices_with_ghost_neighbors () const;

      std::vector<bool>
      mark_locally_active_vertices_on_level(const int level) const;

      template <typename> friend class ::internal::DoFHandlerImplementation::Policy::ParallelDistributed;

      template <int,int,class> friend class ::FETools::internal::ExtrapolateImplementation;
    };


    template <int spacedim>
    class Triangulation<1,spacedim> : public ::parallel::Triangulation<1,spacedim>
    {
    public:

      enum Settings
      {
        default_setting = 0x0,
        mesh_reconstruction_after_repartitioning = 0x1,
        construct_multigrid_hierarchy = 0x2
      };

      Triangulation (MPI_Comm mpi_communicator,
                     const typename ::Triangulation<1,spacedim>::MeshSmoothing
                     smooth_grid = (::Triangulation<1,spacedim>::none),
                     const Settings settings = default_setting);

      virtual ~Triangulation ();

      const std::vector<types::global_dof_index> &
      get_p4est_tree_to_coarse_cell_permutation() const;

      void
      communicate_locally_moved_vertices (const std::vector<bool> &vertex_locally_moved);

      void load(const char *filename,
                const bool autopartition = true);

      void save(const char *filename) const;

      unsigned int
      register_data_attach (const std::size_t size,
                            const std::function<void (const typename ::Triangulation<1,spacedim>::cell_iterator &,
                                                      const typename ::Triangulation<1,spacedim>::CellStatus,
                                                      void *)> &pack_callback);

      void
      notify_ready_to_unpack (const unsigned int offset,
                              const std::function<void (const typename ::Triangulation<1,spacedim>::cell_iterator &,
                                                        const typename ::Triangulation<1,spacedim>::CellStatus,
                                                        const void *)> &unpack_callback);

      std::vector<types::global_dof_index> coarse_cell_to_p4est_tree_permutation;
      std::vector<types::global_dof_index> p4est_tree_to_coarse_cell_permutation;


//TODO: The following variable should really be private, but it is used in dof_handler_policy.cc ...
      Settings settings;

      std::map<unsigned int, std::set<::types::subdomain_id> >
      compute_vertices_with_ghost_neighbors () const;

      std::map<unsigned int, std::set<::types::subdomain_id> >
      compute_level_vertices_with_ghost_neighbors (const unsigned int level) const;

      std::vector<bool>
      mark_locally_active_vertices_on_level(const unsigned int level) const;

    };
  }
}


#else // DEAL_II_WITH_P4EST

namespace parallel
{
  namespace distributed
  {
    template <int dim, int spacedim = dim>
    class Triangulation : public ::parallel::Triangulation<dim,spacedim>
    {
    public:
      Triangulation () = delete;
    };
  }
}


#endif


DEAL_II_NAMESPACE_CLOSE

#endif