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