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 ParticleMergeMethod
{
  None,            
  EqualWeightKD,   
  Reinitialize,    
  ReinitializeBVH, 
  NnSfc,           
  NnPairTree,      
  NnPairOneCell,   
  NnPairHash,      
  KdCarve,         
  KdPatch,         
  KdSkinNn,        
  External         
};
 
inline ParticleMergeMethod
mergeMethodFromString(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
buildEqualWeightKDLeaves(const std::vector<P>&                       a_particles,
                         const int                                   a_maxLeaves,
                         const BinaryParticleReconcile<P>&           a_particleReconcile,
                         std::vector<std::pair<const P*, const P*>>& a_leaves) noexcept;
 
template <class P, RealVect P::*position>
inline void
mergeAdjacentNearest(std::vector<P>&                          a_particles,
                     const std::size_t                        a_target,
                     const std::function<void(P&, const P&)>& a_combine) noexcept;
 
} // namespace detail
 
template <class Packed,
          Real Packed::*packWeight,
          RealVect Packed::*packPosition,
          class P,
          class Traits = ParticleTraits<P>>
inline ParticleMerger<P, Traits>
makeSfcNearestNeighborMerger(std::function<Packed(const ParticleSoA<P, Traits>&, std::size_t)> a_gather,
                             std::function<void(Packed&, const Packed&)>                       a_combine,
                             std::function<void(ParticleSoA<P, Traits>&, const Packed&)>       a_scatter) noexcept;
 
template <class Packed,
          Real Packed::*packWeight,
          RealVect Packed::*packPosition,
          class P,
          class Traits = ParticleTraits<P>>
inline ParticleMerger<P, Traits>
makeEqualWeightKDMerger(
  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 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