tria.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2008 - 2017 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/base/std_cxx11/function.h>
#include <deal.II/base/std_cxx11/tuple.h>

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

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

#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 DoFHandler
  {
    namespace Policy
    {
      template <int, int> 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_cxx11::function<void (const cell_iterator &,
                                                            const CellStatus,
                                                            void *)> &pack_callback);

      void
      notify_ready_to_unpack (const unsigned int offset,
                              const std_cxx11::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;

      bool refinement_in_progress;


      unsigned int attached_data_size;

      unsigned int n_attached_datas;

      unsigned int n_attached_deserialize;

      typedef  std_cxx11::function<
      void(typename Triangulation<dim,spacedim>::cell_iterator, CellStatus, void *)
      > pack_callback_t;

      typedef std::pair<unsigned int, pack_callback_t> callback_pair_t;

      typedef std::list<callback_pair_t> callback_list_t;

      callback_list_t attached_data_pack_callbacks;


      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 (::internal::int2type<2>);
      void copy_new_triangulation_to_p4est (::internal::int2type<3>);

      void copy_local_forest_to_triangulation ();

      void attach_mesh_data();

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

      void
      fill_vertices_with_ghost_neighbors
      (std::map<unsigned int, std::set<::types::subdomain_id> >
       &vertices_with_ghost_neighbors);

      void
      fill_level_vertices_with_ghost_neighbors
      (const int level,
       std::map<unsigned int, std::set<::types::subdomain_id> >
       &vertices_with_ghost_neighbors);

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

      template <int, int> friend class ::internal::DoFHandler::Policy::ParallelDistributed;

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


    template <int spacedim>
    class Triangulation<1,spacedim> : public ::parallel::Triangulation<1,spacedim>
    {
    public:
      Triangulation (MPI_Comm mpi_communicator);

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

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

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


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

      void
      fill_vertices_with_ghost_neighbors
      (std::map<unsigned int, std::set<::types::subdomain_id> >
       &vertices_with_ghost_neighbors);

      void
      fill_level_vertices_with_ghost_neighbors
      (const unsigned int level,
       std::map<unsigned int, std::set<::types::subdomain_id> >
       &vertices_with_ghost_neighbors);

      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>
    {
    private:
      Triangulation ();

    };
  }
}


#endif


DEAL_II_NAMESPACE_CLOSE

#endif