triangulation_utils.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/mpi.h>
 
#include <deal.II/distributed/tria.h>
 
#include <deal.II/grid/cell_id.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
 
#include <map>
#include <set>
#include <utility>
#include <vector>
 
namespace MeltPoolDG
{
  enum TriangulationType
  {
    shared,
    parallel_distributed,
    parallel_fullydistributed,
    serial
  };
 
  template <int dim, int spacedim = dim>
  TriangulationType
  get_triangulation_type(const dealii::Triangulation<dim, spacedim> &tria);
 
  template <int dim>
  class LevelAdjacentCellsCache
  {
    using tria_iterator = dealii::TriaIterator<dealii::CellAccessor<dim>>;
 
  public:
    void
    build_cache(const dealii::Triangulation<dim> &tria, const unsigned int level);
 
    const std::set<dealii::TriaIterator<dealii::CellAccessor<dim>>> &
    get_adjacent_cells(const tria_iterator &cell) const;
 
    unsigned int
    n_global_cells_on_level() const;
 
  private:
    unsigned int n_global_level_cells = 0;
 
    std::map<tria_iterator, std::set<tria_iterator>> adjacent_cells_cache;
 
    bool is_cache_built = false;
 
    unsigned int cache_level = 0;
 
    void
    assert_cache_built() const;
 
    void
    cache_adjacent_cells(const dealii::Triangulation<dim> &tria, const unsigned int level);
 
    void
    compute_global_cell_count(const dealii::Triangulation<dim> &tria, const unsigned int level);
  };
 
 
  template <int dim>
  class LevelCommunicationPattern
  {
  public:
    LevelCommunicationPattern(const dealii::Triangulation<dim> &tria);
 
    void
    build_pattern(const unsigned int level);
 
    std::map<unsigned int, std::vector<dealii::CellId>>
    cells_to_send() const;
 
    std::map<unsigned int, std::vector<dealii::CellId>>
    cells_to_receive() const;
 
    unsigned
    n_processes_to_send_to() const
    {
      return rank_to_cells_send.size();
    }
 
    unsigned
    n_processes_to_receive_from() const
    {
      return rank_to_cells_receive.size();
    }
 
    unsigned int
    n_send_ranks() const;
 
    unsigned int
    n_receive_ranks() const;
 
    std::vector<unsigned int>
    send_ranks() const;
 
    std::vector<unsigned int>
    receive_ranks() const;
 
  private:
    std::vector<dealii::CellId>
    owned_active_cells_ancestors() const;
 
    std::vector<std::pair<unsigned, std::vector<dealii::CellId>>>
    gather_ancestors(const std::vector<dealii::CellId> &local_ancestor_cells) const;
 
    std::vector<dealii::CellId>
    adjacent_relevant_cells(const dealii::CellId               &cell_id,
                            const std::vector<dealii::CellId>  &owned_active_cell_ancestors,
                            const LevelAdjacentCellsCache<dim> &adjacent_cells_cache) const;
 
    std::vector<std::pair<unsigned, std::vector<dealii::CellId>>>
    relevant_cells_for_ranks(
      const std::vector<std::pair<unsigned, std::vector<dealii::CellId>>> &requested_cells_by_rank,
      const std::vector<dealii::CellId> &owned_active_cell_ancestors) const;
 
    std::vector<std::pair<unsigned, std::vector<dealii::CellId>>>
    exchange_relevant_cells(
      const std::vector<std::pair<unsigned, std::vector<dealii::CellId>>> &cells_to_send) const;
 
    void
    store_rank_cell_maps(
      const std::vector<std::pair<unsigned, std::vector<dealii::CellId>>> &data_to_receive,
      const std::vector<std::pair<unsigned, std::vector<dealii::CellId>>> &data_to_send);
 
    void
    build_communication_pattern();
 
    void
    assert_pattern_built() const;
 
    std::map<unsigned int, std::vector<dealii::CellId>> rank_to_cells_send;
 
    std::map<unsigned int, std::vector<dealii::CellId>> rank_to_cells_receive;
 
    const dealii::Triangulation<dim> &triangulation;
 
    unsigned int partition_level = 0;
 
    const MPI_Comm mpi_communicator;
 
    // the build_pattern() function has been called.
    bool is_pattern_built = false;
  };
} // namespace MeltPoolDG