CD_ParticleManagement.H

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2021-2026 SINTEF Energy Research
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
 
#ifndef CD_PARTICLEMANAGEMENT_H
#define CD_PARTICLEMANAGEMENT_H
 
// Std includes
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
// Chombo includes
#include <RealVect.H>
#include <MayDay.H>
 
// Our includes
#include <CD_CellInfo.H>
#include <CD_ParticleSoA.H>
#include <CD_NamespaceHeader.H>
 
namespace ParticleManagement {
 
enum class KDPartition
{
  Weight,      
  Count,       
  Hybrid,      
  WeightCapped 
};
 
enum class KDSplitPlacement
{
  Center, 
  Jitter, 
  Cell    
};
 
enum class KDPlacement
{
  Centroid, 
  Sample,   
  Random    
};
 
enum class KDAmrBoundary
{
  Carve, 
  Nn     
};
 
enum class NNSearch
{
  Tree,   
  Hash,   
  OneCell 
};
 
enum class ParticleMergeMethod
{
  None,         
  KdCell,       
  KdPatch,      
  KdAmr,        
  NnAmr,        
  Reinitialize, 
  External      
};
 
inline ParticleMergeMethod
mergeMethodFromString(const std::string& a_str) noexcept;
 
inline KDPartition
kdPartitionFromString(const std::string& a_str) noexcept;
 
inline KDPlacement
kdPlacementFromString(const std::string& a_str) noexcept;
 
inline KDSplitPlacement
kdSplitPlacementFromString(const std::string& a_str) noexcept;
 
inline KDAmrBoundary
kdAmrBoundaryFromString(const std::string& a_str) noexcept;
 
inline NNSearch
nnSearchFromString(const std::string& a_str) noexcept;
 
template <class P, class Traits = ParticleTraits<P>>
using ParticleMerger = std::function<
  void(ParticleSoA<P, Traits>& a_particles, const CellInfo& a_cellInfo, const int a_numTargetParticles)>;
 
template <class P>
using BinaryParticleReconcile = std::function<void(P& p1, P& p2, const P& p0)>;
 
namespace detail {
 
template <class P, Real P::*weight, RealVect P::*position>
inline void
buildKDCellLeaves(const std::vector<P>&                           a_particles,
                  const int                                       a_maxLeaves,
                  const Real                                      a_weightMedianLength,
                  const bool                                      a_capWeights,
                  const std::function<RealVect(const RealVect&)>& a_splitPosition,
                  const BinaryParticleReconcile<P>&               a_particleReconcile,
                  std::vector<std::pair<const P*, const P*>>&     a_leaves) noexcept;
 
} // namespace detail
 
template <class Packed,
          Real Packed::*packWeight,
          RealVect Packed::*packPosition,
          class P,
          class Traits = ParticleTraits<P>>
inline ParticleMerger<P, Traits>
makeKDCellMerger(
  const Real                                                                                  a_weightMedianCellWidths,
  const bool                                                                                  a_capWeights,
  const KDSplitPlacement                                                                      a_splitPlacement,
  std::function<RealVect()>                                                                   a_probLo,
  std::function<Packed(const ParticleSoA<P, Traits>&, std::size_t)>                           a_gather,
  BinaryParticleReconcile<Packed>                                                             a_reconcile,
  std::function<void(ParticleSoA<P, Traits>&, const Packed*, const Packed*, const CellInfo&)> a_scatterLeaf) noexcept;
 
template <class Context, class P, class Traits = ParticleTraits<P>>
inline ParticleMerger<P, Traits>
makeReinitializeMerger(std::function<std::pair<long long, Context>(const ParticleSoA<P, Traits>&)> a_aggregate,
                       std::function<void(ParticleSoA<P, Traits>&, const RealVect&, long long, const Context&)> a_emit,
                       std::function<RealVect()> a_probLo) noexcept;
 
template <typename P, typename Traits, typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline void
removePhysicalParticles(ParticleSoA<P, Traits>& a_particles, const T a_numPhysPartToRemove) noexcept;
 
template <typename P, typename Traits>
static inline void
deleteParticles(ParticleSoA<P, Traits>& a_particles, const Real a_weightThresh) noexcept;
 
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline void
partitionParticleWeights(std::vector<T>& a_weights,
                         const T         a_numPhysicalParticles,
                         const T         a_maxCompParticles) noexcept;
 
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline std::vector<T>
partitionParticleWeights(const T a_numPhysicalParticles, const T a_maxCompParticles) noexcept;
 
namespace detail {
 
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline T
partitionParticles(const T a_numParticles);
 
} // namespace detail
 
template <typename P, typename Traits, typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline void
drawRandomParticles(ParticleSoA<P, Traits>&          a_particles,
                    const T                          a_numParticles,
                    const std::function<RealVect()>& a_distribution);
 
template <typename P, typename Traits, typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline void
drawGaussianParticles(ParticleSoA<P, Traits>& a_particles,
                      const T                 a_numParticles,
                      const RealVect&         a_center,
                      const Real              a_radius) noexcept;
 
template <typename P, typename Traits, typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline void
drawBoxParticles(ParticleSoA<P, Traits>& a_particles,
                 const T                 a_numParticles,
                 const RealVect&         a_loCorner,
                 const RealVect&         a_hiCorner) noexcept;
 
template <typename P, typename Traits, typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
static inline void
drawSphereParticles(ParticleSoA<P, Traits>& a_particles,
                    const T                 a_numParticles,
                    const RealVect&         a_center,
                    const Real              a_radius) noexcept;
 
template <typename Packed>
struct MergeParticle
{
  RealVect position = RealVect::Zero;
 
  Real weight = 0.0;
 
  ParticleID globalID = -1;
 
  RankID ownerRank = -1;
 
  bool isGhost = false;
 
  int level = 0;
 
  Packed payload;
};
 
} // namespace ParticleManagement
 
#include <CD_NamespaceFooter.H>
 
#include <CD_ParticleManagementImplem.H>
 
#endif