particle_accessor.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/particles/particle_accessor.h>
#include <deal.II/particles/property_pool.h>
 
#include <meltpooldg/particles/dem_util.hpp>
#include <meltpooldg/particles/particle.hpp>
 
#include <functional>
 
namespace MeltPoolDG
{
  template <int dim, typename number>
  class DEMParticleAccessor
  {
  public:
    DEMParticleAccessor(dealii::Particles::ParticleAccessor<dim> &particle);
 
    DEMParticleAccessor(dealii::Point<dim, number>   &location,
                        dealii::ArrayView<number>     properties,
                        dealii::types::particle_index particle_id);
 
    DEMParticleAccessor(
      dealii::Particles::PropertyPool<dim>                       &property_pool,
      const typename dealii::Particles::PropertyPool<dim>::Handle handle) noexcept;
 
    DEMParticleAccessor(const DEMParticleAccessor &other) noexcept = default;
 
    DEMParticleAccessor(DEMParticleAccessor &&other) noexcept = default;
 
    DEMParticleAccessor &
    operator=(DEMParticleAccessor &&other) noexcept = default;
 
    DEMParticleAccessor &
    operator=(const DEMParticleAccessor &other) noexcept = default;
 
    dealii::Point<dim, number> &
    get_location();
 
    const dealii::Point<dim, number> &
    get_location() const;
 
    dealii::Tensor<1, dim, number>
    linear_velocity() const;
 
    number &
    linear_velocity(const unsigned int dimension);
 
    const number &
    linear_velocity(const unsigned int dimension) const;
 
    number &
    linear_acceleration(const unsigned int dimension);
 
    dealii::Tensor<1, axial_dim<dim>, number>
    get_angular_velocity() const;
 
    number &
    angular_acceleration(const unsigned int dimension);
 
    number &
    angular_velocity(const unsigned int dimension);
 
    const number &
    angular_velocity(const unsigned int dimension) const;
 
    dealii::Tensor<1, axial_dim<dim>, number>
    angular_velocity() const;
 
    number &
    force(const unsigned int dimension);
 
    const number &
    force(const unsigned int dimension) const;
 
    dealii::Tensor<1, dim, number>
    force() const;
 
    void
    set_force(const dealii::Tensor<1, dim, number> &force);
 
    void
    add_force(const dealii::Tensor<1, dim, number> &force);
 
    void
    set_torque(const dealii::Tensor<1, axial_dim<dim>, number> &torque);
 
    void
    add_torque(const dealii::Tensor<1, axial_dim<dim>, number> &torque);
 
    number &
    torque(const unsigned int dimension);
 
    const number &
    torque(const unsigned int dimension) const;
 
    dealii::Tensor<1, axial_dim<dim>, number>
    torque() const;
 
    dealii::types::particle_index
    id() const;
 
    dealii::types::particle_index
    local_id() const;
 
    number &
    radius();
 
    const number &
    radius() const;
 
    number &
    mass();
 
    const number &
    mass() const;
 
    number &
    density();
 
    const number &
    density() const;
 
    number &
    get_property(const typename SphericalParticle<dim, number>::Properties property);
 
    const number &
    get_property(const typename SphericalParticle<dim, number>::Properties property) const;
 
    typename dealii::Triangulation<dim>::active_cell_iterator
    get_surrounding_cell() const;
 
  private:
    std::reference_wrapper<dealii::Point<dim, number>> location;
 
    dealii::ArrayView<number> properties;
 
    typename dealii::Triangulation<dim>::active_cell_iterator surrounding_cell;
 
    dealii::types::particle_index particle_id;
 
    dealii::types::particle_index local_particle_id = dealii::numbers::invalid_unsigned_int;
  };
 
 
  template <int dim, typename number>
  DEMParticleAccessor<dim, number>::DEMParticleAccessor(
    dealii::Particles::ParticleAccessor<dim> &particle)
    : location(particle.get_location())
    , properties(particle.get_properties())
    , surrounding_cell(particle.get_surrounding_cell())
    , particle_id(particle.get_id())
    , local_particle_id(particle.get_local_index())
  {}
 
  template <int dim, typename number>
  DEMParticleAccessor<dim, number>::DEMParticleAccessor(dealii::Point<dim, number>   &location,
                                                        dealii::ArrayView<number>     properties,
                                                        dealii::types::particle_index particle_id)
    : location(location)
    , properties(properties)
    , particle_id(particle_id)
  {}
 
  template <int dim, typename number>
  DEMParticleAccessor<dim, number>::DEMParticleAccessor(
    dealii::Particles::PropertyPool<dim>                       &property_pool,
    const typename dealii::Particles::PropertyPool<dim>::Handle handle) noexcept
    : location(property_pool.get_location(handle))
    , properties(property_pool.get_properties(handle))
    , particle_id(property_pool.get_id(handle))
  {}
 
  template <int dim, typename number>
  dealii::Point<dim, number> &
  DEMParticleAccessor<dim, number>::get_location()
  {
    return location;
  }
 
  template <int dim, typename number>
  const dealii::Point<dim, number> &
  DEMParticleAccessor<dim, number>::get_location() const
  {
    return location;
  }
 
  template <int dim, typename number>
  dealii::Tensor<1, dim, number>
  DEMParticleAccessor<dim, number>::linear_velocity() const
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    dealii::Tensor<1, dim, number> velocity;
    for (int dimension = 0; dimension < dim; ++dimension)
      velocity[dimension] =
        properties[SphericalParticle<dim, number>::Properties::velocity + dimension];
    return velocity;
  }
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::linear_velocity(const unsigned int dimension)
  {
    AssertIndexRange(dimension, dim);
    return properties[SphericalParticle<dim, number>::Properties::velocity + dimension];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::linear_velocity(const unsigned int dimension) const
  {
    AssertIndexRange(dimension, dim);
    return properties[SphericalParticle<dim, number>::Properties::velocity + dimension];
  }
 
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::linear_acceleration(const unsigned int dimension)
  {
    AssertIndexRange(dimension, dim);
    return properties[SphericalParticle<dim, number>::Properties::acceleration + dimension];
  }
 
  template <int dim, typename number>
  dealii::Tensor<1, axial_dim<dim>, number>
  DEMParticleAccessor<dim, number>::get_angular_velocity() const
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    dealii::Tensor<1, axial_dim<dim>, number> velocity;
    for (int dimension = 0; dimension < axial_dim<dim>; ++dimension)
      velocity[dimension] =
        properties[SphericalParticle<dim, number>::Properties::angular_velocity + dimension];
    return velocity;
  }
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::angular_acceleration(const unsigned int dimension)
  {
    AssertIndexRange(dimension, axial_dim<dim>);
    return properties[SphericalParticle<dim, number>::Properties::angular_acceleration + dimension];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::angular_velocity(const unsigned int dimension) const
  {
    AssertIndexRange(dimension, axial_dim<dim>);
    return properties[SphericalParticle<dim, number>::Properties::angular_velocity + dimension];
  }
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::angular_velocity(const unsigned int dimension)
  {
    AssertIndexRange(dimension, axial_dim<dim>);
    return properties[SphericalParticle<dim, number>::Properties::angular_velocity + dimension];
  }
 
  template <int dim, typename number>
  dealii::Tensor<1, axial_dim<dim>, number>
  DEMParticleAccessor<dim, number>::angular_velocity() const
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    dealii::Tensor<1, axial_dim<dim>, number> angular_velocity_vector;
    for (int dimension = 0; dimension < axial_dim<dim>; ++dimension)
      {
        angular_velocity_vector[dimension] = angular_velocity(dimension);
      }
    return angular_velocity_vector;
  }
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::force(const unsigned int dimension)
  {
    AssertIndexRange(dimension, dim);
    return properties[SphericalParticle<dim, number>::Properties::force + dimension];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::force(const unsigned int dimension) const
  {
    AssertIndexRange(dimension, dim);
    return properties[SphericalParticle<dim, number>::Properties::force + dimension];
  }
 
  template <int dim, typename number>
  dealii::Tensor<1, dim, number>
  DEMParticleAccessor<dim, number>::force() const
  {
    dealii::Tensor<1, dim, number> force_vector;
    for (unsigned int dimension = 0; dimension < dim; ++dimension)
      force_vector[dimension] = force(dimension);
    return force_vector;
  }
 
  template <int dim, typename number>
  void
  DEMParticleAccessor<dim, number>::set_force(const dealii::Tensor<1, dim, number> &force)
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    for (int dimension = 0; dimension < dim; ++dimension)
      properties[SphericalParticle<dim, number>::Properties::force + dimension] = force[dimension];
  }
 
  template <int dim, typename number>
  void
  DEMParticleAccessor<dim, number>::add_force(const dealii::Tensor<1, dim, number> &force)
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    for (int dimension = 0; dimension < dim; ++dimension)
      properties[SphericalParticle<dim, number>::Properties::force + dimension] += force[dimension];
  }
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::torque(const unsigned int dimension)
  {
    AssertIndexRange(dimension, axial_dim<dim>);
    return properties[SphericalParticle<dim, number>::Properties::torque + dimension];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::torque(const unsigned int dimension) const
  {
    AssertIndexRange(dimension, axial_dim<dim>);
    return properties[SphericalParticle<dim, number>::Properties::torque + dimension];
  }
 
  template <int dim, typename number>
  dealii::Tensor<1, axial_dim<dim>, number>
  DEMParticleAccessor<dim, number>::torque() const
  {
    dealii::Tensor<1, axial_dim<dim>, number> torque_vector;
    for (unsigned int dimension = 0; dimension < axial_dim<dim>; ++dimension)
      torque_vector[dimension] = torque(dimension);
    return torque_vector;
  }
 
  template <int dim, typename number>
  void
  DEMParticleAccessor<dim, number>::set_torque(
    const dealii::Tensor<1, axial_dim<dim>, number> &torque)
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    for (int dimension = 0; dimension < axial_dim<dim>; ++dimension)
      properties[SphericalParticle<dim, number>::Properties::torque + dimension] =
        torque[dimension];
  }
 
  template <int dim, typename number>
  void
  DEMParticleAccessor<dim, number>::add_torque(
    const dealii::Tensor<1, axial_dim<dim>, number> &torque)
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    for (int dimension = 0; dimension < axial_dim<dim>; ++dimension)
      properties[SphericalParticle<dim, number>::Properties::torque + dimension] +=
        torque[dimension];
  }
 
  template <int dim, typename number>
  dealii::types::particle_index
  DEMParticleAccessor<dim, number>::id() const
  {
    return particle_id;
  }
 
  template <int dim, typename number>
  dealii::types::particle_index
  DEMParticleAccessor<dim, number>::local_id() const
  {
    Assert(local_particle_id != dealii::numbers::invalid_unsigned_int,
           dealii::ExcMessage("The local particle ID is only valid for locally owned particles."));
    return local_particle_id;
  }
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::radius()
  {
    return properties[SphericalParticle<dim, number>::Properties::radius];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::radius() const
  {
    return properties[SphericalParticle<dim, number>::Properties::radius];
  }
 
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::mass()
  {
    return properties[SphericalParticle<dim, number>::Properties::mass];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::mass() const
  {
    return properties[SphericalParticle<dim, number>::Properties::mass];
  }
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::density()
  {
    return properties[SphericalParticle<dim, number>::Properties::density];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::density() const
  {
    return properties[SphericalParticle<dim, number>::Properties::density];
  }
 
 
  template <int dim, typename number>
  number &
  DEMParticleAccessor<dim, number>::get_property(
    const typename SphericalParticle<dim, number>::Properties property)
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    return properties[property];
  }
 
  template <int dim, typename number>
  const number &
  DEMParticleAccessor<dim, number>::get_property(
    const typename SphericalParticle<dim, number>::Properties property) const
  {
    Assert(!properties.empty(), dealii::ExcInternalError());
    return properties[property];
  }
 
  template <int dim, typename number>
  typename dealii::Triangulation<dim>::active_cell_iterator
  DEMParticleAccessor<dim, number>::get_surrounding_cell() const
  {
    Assert(surrounding_cell.state() == dealii::IteratorState::valid,
           dealii::ExcMessage("The surrounding cell is only valid for locally owned particles."));
    return surrounding_cell;
  }
} // namespace MeltPoolDG