property_pool.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_property_pool_h
#define dealii_particles_property_pool_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/array_view.h>
#include <deal.II/base/point.h>
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace types
{
  /* Type definitions */
 
#ifdef DEAL_II_WITH_64BIT_INDICES
  using particle_index = std::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
{
  template <int dim, int spacedim = dim>
  class PropertyPool
  {
  public:
    using Handle = unsigned int;
 
    static const Handle invalid_handle;
 
    PropertyPool(const unsigned int n_properties_per_slot);
 
    ~PropertyPool();
 
    void
    clear();
 
    Handle
    register_particle();
 
    void
    deregister_particle(Handle &handle);
 
    const Point<spacedim> &
    get_location(const Handle handle) const;
 
    void
    set_location(const Handle handle, const Point<spacedim> &new_location);
 
    const Point<dim> &
    get_reference_location(const Handle handle) const;
 
    void
    set_reference_location(const Handle      handle,
                           const Point<dim> &new_reference_location);
 
    types::particle_index
    get_id(const Handle handle) const;
 
    void
    set_id(const Handle handle, const types::particle_index &new_id);
 
    ArrayView<double>
    get_properties(const Handle handle);
 
    void
    reserve(const std::size_t size);
 
    unsigned int
    n_properties_per_slot() const;
 
    unsigned int
    n_slots() const;
 
    unsigned int
    n_registered_slots() const;
 
    void
    sort_memory_slots(const std::vector<Handle> &handles_to_sort);
 
  private:
    const unsigned int n_properties;
 
    std::vector<Point<spacedim>> locations;
 
    std::vector<Point<dim>> reference_locations;
 
    std::vector<types::particle_index> ids;
 
    std::vector<double> properties;
 
    std::vector<Handle> currently_available_handles;
  };
 
 
 
  /* ---------------------- inline and template functions ------------------ */
 
  template <int dim, int spacedim>
  inline const Point<spacedim> &
  PropertyPool<dim, spacedim>::get_location(const Handle handle) const
  {
    const std::vector<double>::size_type data_index =
      (handle != invalid_handle) ? handle : 0;
 
    // Ideally we would need to assert that 'handle' has not been deallocated
    // by searching through 'currently_available_handles'. However, this
    // is expensive and this function is performance critical, so instead
    // just check against the array range, and rely on the fact
    // that handles are invalidated when handed over to
    // deallocate_properties_array().
    Assert(data_index <= locations.size() - 1,
           ExcMessage("Invalid location handle. This can happen if the "
                      "handle was duplicated and then one copy was deallocated "
                      "before trying to access the properties."));
 
    return locations[data_index];
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  PropertyPool<dim, spacedim>::set_location(const Handle           handle,
                                            const Point<spacedim> &new_location)
  {
    const std::vector<double>::size_type data_index =
      (handle != invalid_handle) ? handle : 0;
 
    // Ideally we would need to assert that 'handle' has not been deallocated
    // by searching through 'currently_available_handles'. However, this
    // is expensive and this function is performance critical, so instead
    // just check against the array range, and rely on the fact
    // that handles are invalidated when handed over to
    // deallocate_properties_array().
    Assert(data_index <= locations.size() - 1,
           ExcMessage("Invalid location handle. This can happen if the "
                      "handle was duplicated and then one copy was deallocated "
                      "before trying to access the properties."));
 
    locations[data_index] = new_location;
  }
 
 
 
  template <int dim, int spacedim>
  inline const Point<dim> &
  PropertyPool<dim, spacedim>::get_reference_location(const Handle handle) const
  {
    const std::vector<double>::size_type data_index =
      (handle != invalid_handle) ? handle : 0;
 
    // Ideally we would need to assert that 'handle' has not been deallocated
    // by searching through 'currently_available_handles'. However, this
    // is expensive and this function is performance critical, so instead
    // just check against the array range, and rely on the fact
    // that handles are invalidated when handed over to
    // deallocate_properties_array().
    Assert(data_index <= reference_locations.size() - 1,
           ExcMessage("Invalid location handle. This can happen if the "
                      "handle was duplicated and then one copy was deallocated "
                      "before trying to access the properties."));
 
    return reference_locations[data_index];
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  PropertyPool<dim, spacedim>::set_reference_location(
    const Handle      handle,
    const Point<dim> &new_reference_location)
  {
    const std::vector<double>::size_type data_index =
      (handle != invalid_handle) ? handle : 0;
 
    // Ideally we would need to assert that 'handle' has not been deallocated
    // by searching through 'currently_available_handles'. However, this
    // is expensive and this function is performance critical, so instead
    // just check against the array range, and rely on the fact
    // that handles are invalidated when handed over to
    // deallocate_properties_array().
    Assert(data_index <= reference_locations.size() - 1,
           ExcMessage("Invalid location handle. This can happen if the "
                      "handle was duplicated and then one copy was deallocated "
                      "before trying to access the properties."));
 
    reference_locations[data_index] = new_reference_location;
  }
 
 
 
  template <int dim, int spacedim>
  inline types::particle_index
  PropertyPool<dim, spacedim>::get_id(const Handle handle) const
  {
    const std::vector<double>::size_type data_index =
      (handle != invalid_handle) ? handle : 0;
 
    // Ideally we would need to assert that 'handle' has not been deallocated
    // by searching through 'currently_available_handles'. However, this
    // is expensive and this function is performance critical, so instead
    // just check against the array range, and rely on the fact
    // that handles are invalidated when handed over to
    // deallocate_properties_array().
    Assert(data_index <= ids.size() - 1,
           ExcMessage("Invalid location handle. This can happen if the "
                      "handle was duplicated and then one copy was deallocated "
                      "before trying to access the properties."));
 
    return ids[data_index];
  }
 
 
 
  template <int dim, int spacedim>
  inline void
  PropertyPool<dim, spacedim>::set_id(const Handle                 handle,
                                      const types::particle_index &new_id)
  {
    const std::vector<double>::size_type data_index =
      (handle != invalid_handle) ? handle : 0;
 
    // Ideally we would need to assert that 'handle' has not been deallocated
    // by searching through 'currently_available_handles'. However, this
    // is expensive and this function is performance critical, so instead
    // just check against the array range, and rely on the fact
    // that handles are invalidated when handed over to
    // deallocate_properties_array().
    Assert(data_index <= ids.size() - 1,
           ExcMessage("Invalid location handle. This can happen if the "
                      "handle was duplicated and then one copy was deallocated "
                      "before trying to access the properties."));
 
    ids[data_index] = new_id;
  }
 
 
 
  template <int dim, int spacedim>
  inline ArrayView<double>
  PropertyPool<dim, spacedim>::get_properties(const Handle handle)
  {
    const std::vector<double>::size_type data_index =
      (handle != invalid_handle) ? handle * n_properties : 0;
 
    // Ideally we would need to assert that 'handle' has not been deallocated
    // by searching through 'currently_available_handles'. However, this
    // is expensive and this function is performance critical, so instead
    // just check against the array range, and rely on the fact
    // that handles are invalidated when handed over to
    // deallocate_properties_array().
    Assert(data_index <= properties.size() - n_properties,
           ExcMessage("Invalid property handle. This can happen if the "
                      "handle was duplicated and then one copy was deallocated "
                      "before trying to access the properties."));
 
    return ArrayView<double>(properties.data() + data_index, n_properties);
  }
 
 
 
  template <int dim, int spacedim>
  inline unsigned int
  PropertyPool<dim, spacedim>::n_slots() const
  {
    return locations.size();
  }
 
 
} // namespace Particles
 
DEAL_II_NAMESPACE_CLOSE
 
#endif