property_pool.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2017 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#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;
 
    Point<spacedim> &
    get_location(const Handle handle);
 
    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, ::MemorySpace::Host>
    get_properties(const Handle handle)
    {
      // The implementation is up here inside the class declaration because
      // NVCC (at least in 12.5 and 12.6) otherwise produce a compile error:
      //
      // error: no declaration matches ‘::ArrayView<__remove_cv(const
      // double)> ::Particles::PropertyPool<dim,
      // spacedim>::get_properties(Handle)’
      //
      // See https://github.com/dealii/dealii/issues/17148
 
      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);
    }
 
 
    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 Point<spacedim> &
  PropertyPool<dim, spacedim>::get_location(const Handle handle)
  {
    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, ::MemorySpace::Host>
  //   PropertyPool<dim, spacedim>::get_properties(const Handle handle)
 
 
 
  template <int dim, int spacedim>
  inline unsigned int
  PropertyPool<dim, spacedim>::n_slots() const
  {
    return locations.size();
  }
 
 
} // namespace Particles
 
DEAL_II_NAMESPACE_CLOSE
 
#endif