particle_iterator.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <deal.II/base/exception_macros.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/types.h>
 
#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 <meltpooldg/particles/particle_accessor.hpp>
 
#include <cstddef>
#include <iterator>
#include <memory>
#include <optional>
#include <type_traits>
#include <variant>
 
namespace MeltPoolDG
{
  template <int dim, typename number>
  class ParticleIterator
  {
  public:
    using iterator_category = std::bidirectional_iterator_tag;
    using difference_type   = std::ptrdiff_t;
    using value_type        = DEMParticleAccessor<dim, number>;
    using reference         = DEMParticleAccessor<dim, number> &;
    using pointer           = DEMParticleAccessor<dim, number> *;
 
    ParticleIterator() = default;
 
    ParticleIterator(dealii::Particles::ParticleIterator<dim> particle);
 
    ParticleIterator(dealii::Particles::PropertyPool<dim>                       &property_pool,
                     const typename dealii::Particles::PropertyPool<dim>::Handle handle);
 
    DEMParticleAccessor<dim, number> &
    operator*();
 
    const DEMParticleAccessor<dim, number> &
    operator*() const;
 
    DEMParticleAccessor<dim, number> *
    operator->();
 
    const DEMParticleAccessor<dim, number> *
    operator->() const;
 
    [[nodiscard]] bool
    operator!=(const ParticleIterator &c) const;
 
    [[nodiscard]] bool
    operator==(const ParticleIterator &c) const;
 
    ParticleIterator &
    operator++();
 
    ParticleIterator
    operator++(int);
 
    ParticleIterator &
    operator--();
 
    ParticleIterator
    operator--(int);
 
  private:
    std::optional<DEMParticleAccessor<dim, number>> particle_accessor;
 
    struct PropertyPoolIteratorData
    {
      dealii::Particles::PropertyPool<dim>                 *dealii_property_pool = nullptr;
      typename dealii::Particles::PropertyPool<dim>::Handle handle =
        dealii::numbers::invalid_unsigned_int;
 
      void
      operator++() noexcept
      {
        ++handle;
      }
 
      void
      operator--() noexcept
      {
        --handle;
      }
 
      [[nodiscard]] bool
      operator==(const PropertyPoolIteratorData &c) const noexcept
      {
        return handle == c.handle and dealii_property_pool == c.dealii_property_pool;
      }
 
      [[nodiscard]] bool
      operator!=(const PropertyPoolIteratorData &c) const noexcept
      {
        return handle != c.handle or dealii_property_pool != c.dealii_property_pool;
      }
 
      dealii::IteratorState::IteratorStates
      state() const noexcept
      {
        if (dealii_property_pool == nullptr or handle >= dealii_property_pool->n_registered_slots())
          return dealii::IteratorState::IteratorStates::invalid;
        else
          return dealii::IteratorState::IteratorStates::valid;
      }
    };
 
    std::variant<dealii::Particles::ParticleIterator<dim>, PropertyPoolIteratorData>
      deal_ii_iterator;
 
    void
    make_accessor();
 
    void
    refresh_accessor();
  };
 
 
  template <int dim, typename number>
  ParticleIterator<dim, number>::ParticleIterator(dealii::Particles::ParticleIterator<dim> particle)
    : deal_ii_iterator(particle)
  {
    refresh_accessor();
  }
 
  template <int dim, typename number>
  ParticleIterator<dim, number>::ParticleIterator(
    dealii::Particles::PropertyPool<dim>                       &property_pool,
    const typename dealii::Particles::PropertyPool<dim>::Handle handle)
    : deal_ii_iterator(PropertyPoolIteratorData{&property_pool, handle})
  {
    refresh_accessor();
  }
 
  template <int dim, typename number>
  DEMParticleAccessor<dim, number> &
  ParticleIterator<dim, number>::operator*()
  {
    Assert(particle_accessor.has_value(),
           dealii::ExcMessage("Dereferencing invalid ParticleIterator"));
    return *particle_accessor;
  }
 
  template <int dim, typename number>
  const DEMParticleAccessor<dim, number> &
  ParticleIterator<dim, number>::operator*() const
  {
    Assert(particle_accessor.has_value(),
           dealii::ExcMessage("Dereferencing invalid ParticleIterator"));
    return *particle_accessor;
  }
 
  template <int dim, typename number>
  DEMParticleAccessor<dim, number> *
  ParticleIterator<dim, number>::operator->()
  {
    Assert(particle_accessor.has_value(),
           dealii::ExcMessage("Dereferencing invalid ParticleIterator"));
    return std::addressof(**this);
  }
 
  template <int dim, typename number>
  const DEMParticleAccessor<dim, number> *
  ParticleIterator<dim, number>::operator->() const
  {
    Assert(particle_accessor.has_value(),
           dealii::ExcMessage("Dereferencing invalid ParticleIterator"));
    return std::addressof(**this);
  }
 
  template <int dim, typename number>
  [[nodiscard]] bool
  ParticleIterator<dim, number>::operator==(const ParticleIterator &c) const
  {
    return deal_ii_iterator == c.deal_ii_iterator;
  }
 
  template <int dim, typename number>
  [[nodiscard]] bool
  ParticleIterator<dim, number>::operator!=(const ParticleIterator &c) const
  {
    return deal_ii_iterator != c.deal_ii_iterator;
  }
 
  template <int dim, typename number>
  ParticleIterator<dim, number> &
  ParticleIterator<dim, number>::operator++()
  {
    std::visit([&](auto &it) { ++it; }, deal_ii_iterator);
    refresh_accessor();
    return *this;
  }
 
  template <int dim, typename number>
  ParticleIterator<dim, number>
  ParticleIterator<dim, number>::operator++(int)
  {
    ParticleIterator tmp(*this);
    operator++();
    return tmp;
  }
 
  template <int dim, typename number>
  ParticleIterator<dim, number> &
  ParticleIterator<dim, number>::operator--()
  {
    std::visit([&](auto &it) { --it; }, deal_ii_iterator);
    refresh_accessor();
    return *this;
  }
 
  template <int dim, typename number>
  ParticleIterator<dim, number>
  ParticleIterator<dim, number>::operator--(int)
  {
    ParticleIterator tmp(*this);
    operator--();
    return tmp;
  }
 
  template <int dim, typename number>
  void
  ParticleIterator<dim, number>::make_accessor()
  {
    std::visit(
      [&](auto &it) {
        using T = std::decay_t<decltype(it)>;
 
        if constexpr (std::is_same_v<T, dealii::Particles::ParticleIterator<dim>>)
          particle_accessor.emplace(*it);
        else if constexpr (std::is_same_v<T, PropertyPoolIteratorData>)
          particle_accessor.emplace(*it.dealii_property_pool, it.handle);
        else
          AssertThrow(false, dealii::ExcInternalError());
      },
      deal_ii_iterator);
  }
 
  template <int dim, typename number>
  void
  ParticleIterator<dim, number>::refresh_accessor()
  {
    std::visit(
      [&](auto &it) {
        if (it.state() == dealii::IteratorState::IteratorStates::valid)
          make_accessor();
        else
          particle_accessor = std::nullopt;
      },
      deal_ii_iterator);
  }
} // namespace MeltPoolDG