particle_accessor.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2017 - 2019 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_data(void *&data) const;

    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 &property_pool);

    bool
    has_properties() const;

    void
    set_properties(const std::vector<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;

  protected:
    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);
  }


} // namespace Particles

DEAL_II_NAMESPACE_CLOSE

#endif