particle_accessor.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2017 - 2021 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_particles_particle_accessor_h
#define dealii_particles_particle_accessor_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/array_view.h>
 
#include <deal.II/grid/tria.h>
 
#include <deal.II/particles/particle.h>
 
DEAL_II_NAMESPACE_OPEN
 
namespace Particles
{
  // Forward declarations
#ifndef DOXYGEN
  template <int, int>
  class ParticleIterator;
  template <int, int>
  class ParticleHandler;
#endif
 
  template <int dim, int spacedim = dim>
  class ParticleAccessor
  {
  public:
    void *
    write_particle_data_to_memory(void *data) const;
 
 
    const void *
    read_particle_data_from_memory(const void *data);
 
    void
    set_location(const Point<spacedim> &new_location);
 
    const Point<spacedim> &
    get_location() const;
 
    void
    set_reference_location(const Point<dim> &new_reference_location);
 
    const Point<dim> &
    get_reference_location() const;
 
    types::particle_index
    get_id() const;
 
    void
    set_property_pool(PropertyPool<dim, spacedim> &property_pool);
 
    bool
    has_properties() const;
 
    void
    set_properties(const std::vector<double> &new_properties);
 
    void
    set_properties(const ArrayView<const double> &new_properties);
 
    const ArrayView<double>
    get_properties();
 
    const ArrayView<const double>
    get_properties() const;
 
    std::size_t
    serialized_size_in_bytes() const;
 
    typename Triangulation<dim, spacedim>::cell_iterator
    get_surrounding_cell(
      const Triangulation<dim, spacedim> &triangulation) const;
 
    template <class Archive>
    void
    serialize(Archive &ar, const unsigned int version);
 
    void
    next();
 
    void
    prev();
 
    bool
    operator!=(const ParticleAccessor<dim, spacedim> &other) const;
 
    bool
    operator==(const ParticleAccessor<dim, spacedim> &other) const;
 
  private:
    ParticleAccessor();
 
    ParticleAccessor(
      const std::multimap<internal::LevelInd, Particle<dim, spacedim>> &map,
      const typename std::multimap<internal::LevelInd,
                                   Particle<dim, spacedim>>::iterator
        &particle);
 
  private:
    std::multimap<internal::LevelInd, Particle<dim, spacedim>> *map;
 
    typename std::multimap<internal::LevelInd,
                           Particle<dim, spacedim>>::iterator particle;
 
    // Make ParticleIterator a friend to allow it constructing
    // ParticleAccessors.
    template <int, int>
    friend class ParticleIterator;
    template <int, int>
    friend class ParticleHandler;
  };
 
 
 
  template <int dim, int spacedim>
  template <class Archive>
  void
  ParticleAccessor<dim, spacedim>::serialize(Archive &          ar,
                                             const unsigned int version)
  {
    return particle->second.serialize(ar, version);
  }
 
 
  // ------------------------- inline functions ------------------------------
 
  template <int dim, int spacedim>
  inline ParticleAccessor<dim, spacedim>::ParticleAccessor()
    : map(nullptr)
    , particle()
  {}
 
 
 
  template <int dim, int spacedim>
  inline ParticleAccessor<dim, spacedim>::ParticleAccessor(
    const std::multimap<internal::LevelInd, Particle<dim, spacedim>> &map,
    const typename std::multimap<internal::LevelInd,
                                 Particle<dim, spacedim>>::iterator & particle)
    : map(const_cast<
          std::multimap<internal::LevelInd, Particle<dim, spacedim>> *>(&map))
    , particle(particle)
  {}
 
 
 
  template <int dim, int spacedim>
  inline const void *
  ParticleAccessor<dim, spacedim>::read_particle_data_from_memory(
    const void *data)
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.read_particle_data_from_memory(data);
  }
 
 
 
  template <int dim, int spacedim>
  inline void *
  ParticleAccessor<dim, spacedim>::write_particle_data_to_memory(
    void *data) const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.write_particle_data_to_memory(data);
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  ParticleAccessor<dim, spacedim>::set_location(const Point<spacedim> &new_loc)
  {
    Assert(particle != map->end(), ExcInternalError());
 
    particle->second.set_location(new_loc);
  }
 
 
 
  template <int dim, int spacedim>
  inline const Point<spacedim> &
  ParticleAccessor<dim, spacedim>::get_location() const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.get_location();
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  ParticleAccessor<dim, spacedim>::set_reference_location(
    const Point<dim> &new_loc)
  {
    Assert(particle != map->end(), ExcInternalError());
 
    particle->second.set_reference_location(new_loc);
  }
 
 
 
  template <int dim, int spacedim>
  inline const Point<dim> &
  ParticleAccessor<dim, spacedim>::get_reference_location() const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.get_reference_location();
  }
 
 
 
  template <int dim, int spacedim>
  inline types::particle_index
  ParticleAccessor<dim, spacedim>::get_id() const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.get_id();
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  ParticleAccessor<dim, spacedim>::set_property_pool(
    PropertyPool<dim, spacedim> &new_property_pool)
  {
    Assert(particle != map->end(), ExcInternalError());
 
    particle->second.set_property_pool(new_property_pool);
  }
 
 
 
  template <int dim, int spacedim>
  inline bool
  ParticleAccessor<dim, spacedim>::has_properties() const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.has_properties();
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  ParticleAccessor<dim, spacedim>::set_properties(
    const std::vector<double> &new_properties)
  {
    Assert(particle != map->end(), ExcInternalError());
 
    particle->second.set_properties(new_properties);
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  ParticleAccessor<dim, spacedim>::set_properties(
    const ArrayView<const double> &new_properties)
  {
    Assert(particle != map->end(), ExcInternalError());
 
    particle->second.set_properties(new_properties);
  }
 
 
 
  template <int dim, int spacedim>
  inline const ArrayView<const double>
  ParticleAccessor<dim, spacedim>::get_properties() const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.get_properties();
  }
 
 
 
  template <int dim, int spacedim>
  inline typename Triangulation<dim, spacedim>::cell_iterator
  ParticleAccessor<dim, spacedim>::get_surrounding_cell(
    const Triangulation<dim, spacedim> &triangulation) const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    const typename Triangulation<dim, spacedim>::cell_iterator cell(
      &triangulation, particle->first.first, particle->first.second);
    return cell;
  }
 
 
 
  template <int dim, int spacedim>
  inline const ArrayView<double>
  ParticleAccessor<dim, spacedim>::get_properties()
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.get_properties();
  }
 
 
 
  template <int dim, int spacedim>
  inline std::size_t
  ParticleAccessor<dim, spacedim>::serialized_size_in_bytes() const
  {
    Assert(particle != map->end(), ExcInternalError());
 
    return particle->second.serialized_size_in_bytes();
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  ParticleAccessor<dim, spacedim>::next()
  {
    Assert(particle != map->end(), ExcInternalError());
    ++particle;
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  ParticleAccessor<dim, spacedim>::prev()
  {
    Assert(particle != map->begin(), ExcInternalError());
    --particle;
  }
 
 
 
  template <int dim, int spacedim>
  inline bool
  ParticleAccessor<dim, spacedim>::
  operator!=(const ParticleAccessor<dim, spacedim> &other) const
  {
    return (map != other.map) || (particle != other.particle);
  }
 
 
 
  template <int dim, int spacedim>
  inline bool
  ParticleAccessor<dim, spacedim>::
  operator==(const ParticleAccessor<dim, spacedim> &other) const
  {
    return (map == other.map) && (particle == other.particle);
  }
 
 
} // namespace Particles
 
DEAL_II_NAMESPACE_CLOSE
 
namespace boost
{
  namespace geometry
  {
    namespace index
    {
      // Forward declaration of bgi::indexable
      template <class T>
      struct indexable;
 
      template <int dim, int spacedim>
      struct indexable<::Particles::ParticleAccessor<dim, spacedim>>
      {
        using result_type = const ::Point<spacedim> &;
 
        result_type
        operator()(const ::Particles::ParticleAccessor<dim, spacedim>
                     &accessor) const
        {
          return accessor.get_location();
        }
      };
    } // namespace index
  }   // namespace geometry
} // namespace boost
 
#endif