obstacle_field.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/conditional_ostream.h>
#include <deal.II/base/iterator_range.h>
 
#include <deal.II/fe/mapping.h>
 
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
 
#include <deal.II/particles/particle_accessor.h>
#include <deal.II/particles/particle_handler.h>
 
#include <meltpooldg/particles/dem_time_integrators.hpp>
#include <meltpooldg/particles/dem_util.hpp>
#include <meltpooldg/particles/obstacle_data.hpp>
#include <meltpooldg/particles/obstacle_data_structure.hpp>
#include <meltpooldg/particles/obstacle_forces.hpp>
#include <meltpooldg/particles/particle_accessor.hpp>
#include <meltpooldg/particles/particle_iterator.hpp>
#include <meltpooldg/post_processing/postprocessor.hpp>
#include <meltpooldg/utilities/amr_regions.hpp>
 
#include <ranges>
#include <type_traits>
#include <vector>
 
namespace MeltPoolDG
{
  template <int dim, typename number, typename ObstacleType>
  class ObstacleField
  {
  public:
    ObstacleField(const ObstacleData<number>       &data,
                  const dealii::Triangulation<dim> &triangulation,
                  const dealii::Mapping<dim>       &mapping);
 
    ObstacleField(const ObstacleData<number>                    &data,
                  const dealii::Triangulation<dim>              &triangulation,
                  const dealii::Mapping<dim>                    &mapping,
                  const std::vector<dealii::Point<dim, number>> &obstacle_locations,
                  const std::vector<std::vector<number>>        &obstacle_properties);
 
    void
    advance_time(const number time_step);
 
    void
    compute_loads_on_obstacles();
 
    template <typename ObstacleLoadType>
      requires(!std::is_lvalue_reference_v<ObstacleLoadType>) //
    void
    add_load_type(ObstacleLoadType &&obstacle_load)
    {
      loads.emplace_back(std::move(obstacle_load));
    }
 
    template <typename ObstacleContainer>
    void
    get_obstacles_in_cell(const dealii::TriaIterator<dealii::CellAccessor<dim>> &cell,
                          ObstacleContainer                                     &particles);
 
    boost::container::small_vector<DEMParticleAccessor<dim, number>, 3 * dim>
    find_particles_in_neighborhood(const DEMParticleAccessor<dim, number> &particle,
                                   const number                            relative_tolerance);
 
    void
    compress();
 
    void
    print_accumulated_particle_quantities(const dealii::ConditionalOStream &pout) const;
 
    void
    deserialize();
 
    template <class Archive>
    void
    serialize(Archive &ar, const unsigned int version);
 
    void
    prepare_for_serialization();
 
    std::vector<AMR::AMRRegion<dim, number>>
    get_refinement_regions() const;
 
    void
    prepare_for_coarsening_and_refinement();
 
    void
    unpack_after_coarsening_and_refinement();
 
    void
    register_particle_output(Postprocessor<dim, number> &postprocessor) const;
 
    void
    insert_obstacles(const dealii::Triangulation<dim>              &triangulation,
                     const std::vector<dealii::Point<dim, number>> &obstacle_locations,
                     const std::vector<std::vector<number>>        &obstacle_properties);
 
    std::ranges::subrange<ParticleIterator<dim, number>>
    locally_owned_particle_range() const;
 
    std::ranges::subrange<ParticleIterator<dim, number>>
    ghost_particle_range() const;
 
    typename std::ranges::subrange<ParticleIterator<dim, number>>
    particles_in_cell(typename dealii::Triangulation<dim>::active_cell_iterator cell) const;
 
    unsigned int
    n_global_particles() const;
 
    unsigned int
    n_locally_owned_particles() const;
 
    unsigned int
    n_ghost_particles() const;
 
    const dealii::Triangulation<dim> &
    get_triangulation() const;
 
    MPI_Comm
    get_mpi_communicator() const;
 
    number
    compute_rayleigh_time_step() const;
 
    void
    subscribe_to_data_structure(
      std::function<
        void(CellListParticleHandler<dim, number, ObstacleType> &,
             const typename CellListParticleHandler<dim, number, ObstacleType>::NotifyEvent &)>
        callback);
 
  private:
    const ObstacleData<number> &data;
 
    std::vector<ObstacleLoad<dim, number, ObstacleType>> loads;
 
    CellListParticleHandler<dim, number, ObstacleType> obstacle_data_structure;
 
    MPI_Comm mpi_communicator;
  };
 
  template <int dim, typename number, typename ObstacleType>
  template <typename ObstacleContainer>
  void
  ObstacleField<dim, number, ObstacleType>::get_obstacles_in_cell(
    const dealii::TriaIterator<dealii::CellAccessor<dim>> &cell,
    ObstacleContainer                                     &particles)
  {
    obstacle_data_structure.get_obstacles_in_cell(cell, particles);
  }
 
  template <int dim, typename number, typename ObstacleType>
  template <class Archive>
  void
  ObstacleField<dim, number, ObstacleType>::serialize(Archive &ar, const unsigned int version)
  {
    obstacle_data_structure.serialize(ar, version);
  }
} // namespace MeltPoolDG