dem_background_triangulation_tools.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/point.h>
 
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/tria.h>
 
#include <meltpooldg/particles/obstacle_data_structure.hpp>
#include <meltpooldg/particles/obstacle_field.hpp>
#include <meltpooldg/particles/particle_accessor.hpp>
 
#include <boost/container/small_vector.hpp>
 
namespace MeltPoolDG
{
  template <int dim, typename number, typename ObstacleType>
  void
  generate_data_structure_optimal_hyper_rectangle(dealii::Triangulation<dim>       &triangulation,
                                                  const dealii::Point<dim, number> &p1,
                                                  const dealii::Point<dim, number> &p2,
                                                  const number max_particle_radius)
  {
    const number min_vertex_distance =
      CellListParticleHandler<dim, number, ObstacleType>::minimal_cell_vertex_distance(
        max_particle_radius);
 
    const dealii::Tensor<1, dim, number> domain_size = p2 - p1;
    std::vector<unsigned int>            repetitions(dim);
    // As the cell list particle handler requires at least two levels in the triangulation we first
    // create a triangulation with half the number of cells in each direction and then refine it
    // globally once.
    for (unsigned int d = 0; d < dim; ++d)
      repetitions[d] = 0.5 * std::max(1u,
                                      static_cast<unsigned int>(std::floor(
                                        std::abs(domain_size[d]) / min_vertex_distance)));
 
    dealii::GridGenerator::subdivided_hyper_rectangle(triangulation, repetitions, p1, p2);
    triangulation.refine_global(1);
  }
 
  template <int dim, typename number, typename ObstacleType>
  void
  set_particle_count_partitioning_weight(ObstacleField<dim, number, ObstacleType> &obstacle_field,
                                         dealii::Triangulation<dim>               &triangulation)
  {
    const auto weight_function =
      [&obstacle_field](const typename dealii::Triangulation<dim>::cell_iterator &cell,
                        const dealii::CellStatus) -> unsigned int {
      // Size of the container is a guess which should ensure that no dynamic memory allocations
      // are required for most cases.
      boost::container::small_vector<DEMParticleAccessor<dim, number>, 5 * dim> particles_in_cell;
      obstacle_field.get_obstacles_in_cell(cell, particles_in_cell);
      return static_cast<unsigned int>(particles_in_cell.size());
    };
    triangulation.signals.weight.connect(weight_function);
  }
} // namespace MeltPoolDG