particle.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2017 - 2020 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_h
#define dealii_particles_particle_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/array_view.h>
#include <deal.II/base/point.h>
#include <deal.II/base/types.h>
 
#include <deal.II/particles/property_pool.h>
 
#include <cstdint>
 
DEAL_II_NAMESPACE_OPEN
 
namespace types
{
  /* Type definitions */
 
#ifdef DEAL_II_WITH_64BIT_INDICES
 
  using particle_index = uint64_t;
 
#  ifdef DEAL_II_WITH_MPI
 
#    define DEAL_II_PARTICLE_INDEX_MPI_TYPE MPI_UINT64_T
#  endif
 
#else
 
  using particle_index = unsigned int;
 
#  ifdef DEAL_II_WITH_MPI
 
#    define DEAL_II_PARTICLE_INDEX_MPI_TYPE MPI_UNSIGNED
#  endif
#endif
} // namespace types
 
namespace Particles
{
  namespace internal
  {
    using LevelInd = std::pair<int, int>;
  } // namespace internal
 
  template <int dim, int spacedim = dim>
  class Particle
  {
  public:
    Particle();
 
    Particle(const Point<spacedim> &     location,
             const Point<dim> &          reference_location,
             const types::particle_index id);
 
    Particle(const Particle<dim, spacedim> &particle);
 
    Particle(const void *&       begin_data,
             PropertyPool *const property_pool = nullptr);
 
    Particle(Particle<dim, spacedim> &&particle) noexcept;
 
    Particle<dim, spacedim> &
    operator=(const Particle<dim, spacedim> &particle);
 
    Particle<dim, spacedim> &
    operator=(Particle<dim, spacedim> &&particle) noexcept;
 
    ~Particle();
 
    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_id(const types::particle_index &new_id);
 
    void
    set_property_pool(PropertyPool &property_pool);
 
    bool
    has_properties() const;
 
    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;
 
    template <class Archive>
    void
    save(Archive &ar, const unsigned int version) const;
 
    template <class Archive>
    void
    load(Archive &ar, const unsigned int version);
 
#ifdef DOXYGEN
 
    template <class Archive>
    void
    serialize(Archive &archive, const unsigned int version);
#else
    // This macro defines the serialize() method that is compatible with
    // the templated save() and load() method that have been implemented.
    BOOST_SERIALIZATION_SPLIT_MEMBER()
#endif
 
  private:
    Point<spacedim> location;
 
    Point<dim> reference_location;
 
    types::particle_index id;
 
    PropertyPool *property_pool;
 
    PropertyPool::Handle properties;
  };
 
  /* ---------------------- inline and template functions ------------------ */
 
  template <int dim, int spacedim>
  template <class Archive>
  void
  Particle<dim, spacedim>::load(Archive &ar, const unsigned int)
  {
    unsigned int n_properties = 0;
 
    ar &location &reference_location &id &n_properties;
 
    if (n_properties > 0)
      {
        properties = new double[n_properties];
        ar &boost::serialization::make_array(properties, n_properties);
      }
  }
 
  template <int dim, int spacedim>
  template <class Archive>
  void
  Particle<dim, spacedim>::save(Archive &ar, const unsigned int) const
  {
    unsigned int n_properties = 0;
    if ((property_pool != nullptr) &&
        (properties != PropertyPool::invalid_handle))
      n_properties = get_properties().size();
 
    ar &location &reference_location &id &n_properties;
 
    if (n_properties > 0)
      ar &boost::serialization::make_array(properties, n_properties);
  }
} // namespace Particles
 
DEAL_II_NAMESPACE_CLOSE
 
#endif