doxygen/html/CD__NearestNeighborParticleMerge_8H_source.html

/*

 * SPDX-FileCopyrightText: 2021-2026 SINTEF Energy Research

 *

 * SPDX-License-Identifier: GPL-3.0-or-later

 */


#ifndef CD_NEARESTNEIGHBORPARTICLEMERGE_H

#define CD_NEARESTNEIGHBORPARTICLEMERGE_H


// Std includes

#include <algorithm>

#include <functional>

#include <limits>

#include <map>

#include <optional>

#include <unordered_set>

#include <unordered_map>

#include <utility>

#include <vector>


// Chombo includes

#include <RealVect.H>

#include <IntVect.H>


// EBGeometry includes

#include <EBGeometry.hpp>


// Our includes

#include <CD_ParticleSoA.H>

#include <CD_ParticleContainer.H>

#include <CD_ParticleManagement.H>

#include <CD_NamespaceHeader.H>


class AmrMesh;


namespace ParticleManagement {


namespace detail {


template <typename Packed>


struct NNPooledParticle

{

  MergeParticle<Packed> particle;


  bool exposed = false;

};


struct NNFallbackCandidate

{

  ParticleID candidateID;


  Real distanceSquared;


  bool candidateIsLocal;

};


template <typename Packed>


struct NNMergeEdge

{

  Real distanceSquared;


  ParticleID queryID;


  ParticleID candidateID;


  bool candidateIsLocal;


  std::vector<NNFallbackCandidate> fallbackCandidates;

};


template <typename Packed>


struct NNMergeProposal

{

  MergeParticle<Packed> source;


  ParticleID targetID;


  Real distanceSquared;

};


struct NNMergeVerdict

{

  ParticleID proposerID;


  bool accepted;

};


template <typename Packed>


struct NNMergeResult

{

  ParticleID firstID;


  ParticleID secondID;


  MergeParticle<Packed> merged;

};


} // namespace detail


template <typename Packed>

using PayloadCombine = std::function<

  Packed(const Packed& a_first, const Real a_firstWeight, const Packed& a_second, const Real a_secondWeight)>;


using PositionValid = std::function<bool(const RealVect& a_mergedPosition)>;


using IDAllocator = std::function<ParticleID()>;


template <typename Packed>

using MergeCommittedCallback = std::function<void(const MergeParticle<Packed>& a_first,

                                                  const MergeParticle<Packed>& a_second,

                                                  const MergeParticle<Packed>& a_merged)>;


namespace detail {


inline IntVect

cellKeyOf(const RealVect& a_position, const RealVect& a_probLo, const RealVect& a_dx) noexcept;


using NNCellKey = std::pair<int, IntVect>;


struct NNCellKeyHasher

{

  std::size_t


  operator()(const NNCellKey& a_key) const noexcept

  {

    std::size_t hash = LevelTiles::TileHasher()(a_key.second);

    hash ^= static_cast<std::size_t>(static_cast<unsigned int>(a_key.first)) + 0x9e3779b9 + (hash << 6) + (hash >> 2);

    return hash;

  }


};


} // namespace detail


class NNCellBudget

{

public:


  NNCellBudget(const int a_uniform) noexcept : m_uniform(a_uniform)

  {}


  inline void


  reserveOne(const int a_level, const IntVect& a_cell)

  {

    const int count = ++m_reserved[detail::NNCellKey(a_level, a_cell)];


    m_minBudget = std::min(m_minBudget, std::max(0, m_uniform - count));

  }


  inline void


  reserveOne(const int a_level, const RealVect& a_position, const RealVect& a_probLo, const RealVect& a_dx)

  {

    this->reserveOne(a_level, detail::cellKeyOf(a_position, a_probLo, a_dx));

  }


  inline int


  operator()(const detail::NNCellKey& a_key) const noexcept

  {

    if (m_reserved.empty()) {

      return m_uniform;

    }


    const auto it = m_reserved.find(a_key);


    return (it == m_reserved.end()) ? m_uniform : std::max(0, m_uniform - it->second);

  }


  inline int


  minimum() const noexcept

  {

    return m_reserved.empty() ? m_uniform : std::min(m_uniform, m_minBudget);

  }


private:

  int m_uniform;


  int m_minBudget = std::numeric_limits<int>::max();


  std::unordered_map<detail::NNCellKey, int, detail::NNCellKeyHasher> m_reserved;

};


namespace detail {


using NNWalkCell = IntVect;


template <typename Packed, typename Cloud = EBGeometry::PointCloudBVH<Real, ParticleID>>

struct NNSpatialIndex

{

  std::shared_ptr<Cloud> pointCloud;


  std::size_t pointCloudNLocal = 0;


  std::vector<typename Cloud::Hit> pointCloudGraph;


  int pointCloudK = 0;

};


template <typename Packed, typename Cloud = EBGeometry::PointCloudBVH<Real, ParticleID>>

inline void

buildNNSpatialIndex(NNSpatialIndex<Packed, Cloud>&            a_index,

                    const std::vector<MergeParticle<Packed>>& a_localValid,

                    const std::vector<MergeParticle<Packed>>& a_ghosts,

                    const RealVect&                           a_probLo,

                    const RealVect&                           a_dx,

                    const NNCellBudget&                       a_cellBudget,

                    const int                                 a_kNearest) noexcept;


template <typename Packed, typename Cloud = EBGeometry::PointCloudBVH<Real, ParticleID>>

inline void

findNearestNeighborCandidates(std::vector<NNMergeEdge<Packed>>&                          a_edges,

                              const std::vector<MergeParticle<Packed>>&                  a_localValid,

                              const std::vector<MergeParticle<Packed>>&                  a_ghosts,

                              const std::unordered_set<ParticleID>&                      a_consumedIDs,

                              const NNSpatialIndex<Packed, Cloud>&                       a_spatialIndex,

                              const std::unordered_map<NNCellKey, int, NNCellKeyHasher>& a_liveCellCount,

                              const RealVect&                                            a_probLo,

                              const RealVect&                                            a_dx,

                              const NNCellBudget&                                        a_cellBudget,

                              const int                                                  a_maxFallbackCandidates = 0,

                              const std::optional<int> a_maxCellDistance = std::nullopt) noexcept;


struct NNCellMeta

{

  ParticleID globalID;


  bool isLocal;


  int level;

};


using NNCellCloud = EBGeometry::PointCloudBVH<Real, NNCellMeta>;


using NNCellSpatialIndex = std::unordered_map<NNWalkCell, std::shared_ptr<NNCellCloud>, LevelTiles::TileHasher>;


template <typename Packed>

inline void

buildNNCellSpatialIndex(NNCellSpatialIndex&                       a_index,

                        const std::vector<MergeParticle<Packed>>& a_localValid,

                        const std::vector<MergeParticle<Packed>>& a_ghosts,

                        const RealVect&                           a_probLo,

                        const RealVect&                           a_dx,

                        const NNCellBudget&                       a_cellBudget) noexcept;


template <typename Packed>

inline void

findNearestNeighborCandidatesOneCell(std::vector<NNMergeEdge<Packed>>&                          a_edges,

                                     const std::vector<MergeParticle<Packed>>&                  a_localValid,

                                     const std::unordered_set<ParticleID>&                      a_consumedIDs,

                                     const NNCellSpatialIndex&                                  a_cellIndex,

                                     const std::unordered_map<NNCellKey, int, NNCellKeyHasher>& a_liveCellCount,

                                     const RealVect&                                            a_probLo,

                                     const RealVect&                                            a_dx,

                                     const std::vector<RealVect>&                               a_dxByLevel,

                                     const NNCellBudget&                                        a_cellBudget,

                                     const int a_maxFallbackCandidates = 0) noexcept;


template <typename Packed, typename Combine, typename PosValid, typename Allocator, typename OnMerge>

inline void

resolveTrivialTier(

  std::unordered_map<NNCellKey, int, NNCellKeyHasher>&            a_liveCellCount,

  std::unordered_set<ParticleID>&                                 a_consumedIDs,

  std::unordered_set<ParticleID>&                                 a_hasOutgoingCommitment,

  std::vector<NNMergeResult<Packed>>&                             a_results,

  const std::vector<NNMergeEdge<Packed>>&                         a_edges,

  const std::unordered_map<ParticleID, NNPooledParticle<Packed>>& a_particlesByID,

  const Combine&                                                  a_combine,

  const NNCellBudget&                                             a_cellBudget,

  const RealVect&                                                 a_probLo,

  const std::vector<RealVect>&                                    a_dxByLevel,

  const PosValid&                                                 a_isPositionValid,

  const Allocator&                                                a_allocateID,

  const int                                                       a_maxFallbackCandidates = 0,

  const std::optional<int>                                        a_maxCellDistance       = std::nullopt,

  unsigned long long*                                             a_crossLevelMergeCount  = nullptr,

  const OnMerge&                                                  a_onMergeCommitted =

    [](const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&) {

    }) noexcept;


template <typename Packed>

inline void

generateProposals(std::vector<std::vector<NNMergeProposal<Packed>>>&              a_proposalsByDestRank,

                  const std::vector<NNMergeEdge<Packed>>&                         a_edges,

                  const std::unordered_set<ParticleID>&                           a_hasOutgoingCommitment,

                  const std::unordered_map<ParticleID, NNPooledParticle<Packed>>& a_particlesByID,

                  const int                                                       a_numRanks) noexcept;


template <typename Packed, typename Combine, typename PosValid, typename Allocator, typename OnMerge>

inline void

judgeProposals(

  std::unordered_map<NNCellKey, int, NNCellKeyHasher>&            a_liveCellCount,

  std::vector<NNMergeResult<Packed>>&                             a_results,

  std::vector<std::vector<NNMergeVerdict>>&                       a_verdictsByDestRank,

  const std::vector<NNMergeProposal<Packed>>&                     a_incomingProposals,

  const std::unordered_map<ParticleID, NNPooledParticle<Packed>>& a_particlesByID,

  const std::unordered_set<ParticleID>&                           a_consumedIDs,

  const std::unordered_set<ParticleID>&                           a_hasOutgoingCommitment,

  const std::map<ParticleID, ParticleID>&                         a_outgoingTargetOf,

  const Combine&                                                  a_combine,

  const NNCellBudget&                                             a_cellBudget,

  const RealVect&                                                 a_probLo,

  const std::vector<RealVect>&                                    a_dxByLevel,

  const PosValid&                                                 a_isPositionValid,

  const Allocator&                                                a_allocateID,

  const std::optional<int>                                        a_maxCellDistance      = std::nullopt,

  unsigned long long*                                             a_crossLevelMergeCount = nullptr,

  const OnMerge&                                                  a_onMergeCommitted =

    [](const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&) {

    }) noexcept;


inline void

applyVerdicts(std::unordered_set<ParticleID>&    a_consumedIDs,

              const std::vector<NNMergeVerdict>& a_incomingVerdicts) noexcept;


using PositionLocator = std::function<LevelTiles::LevelAndBox(const RealVect& a_position)>;


template <typename Packed>

inline void

placeMergedParticles(std::map<std::pair<int, unsigned int>, std::vector<MergeParticle<Packed>>>& a_localByPatch,

                     std::vector<std::vector<MergeParticle<Packed>>>&                            a_scatterByDestRank,

                     const std::vector<NNMergeResult<Packed>>&                                   a_results,

                     const PositionLocator&                                                      a_locate,

                     const int                                                                   a_thisRank) noexcept;


struct NNPatchWork

{

  int level;


  DataIndex din;


  RealVect dx;

};


template <typename P, typename Packed, typename Traits, typename Gather>

inline void

gatherMergeParticles(ParticleContainer<P, Traits>&                             a_particles,

                     std::vector<NNPatchWork>&                                 a_patchWork,

                     std::vector<std::vector<MergeParticle<Packed>>>&          a_patchLocalValid,

                     std::vector<std::vector<MergeParticle<Packed>>>&          a_patchGhosts,

                     std::unordered_map<ParticleID, NNPooledParticle<Packed>>& a_particlesByID,

                     std::unordered_map<NNCellKey, int, NNCellKeyHasher>&      a_liveCellCount,

                     const AmrMesh&                                            a_amr,

                     const std::string&                                        a_realm,

                     const int                                                 a_finestLevel,

                     const RealVect&                                           a_probLo,

                     const std::vector<RealVect>&                              a_dxByLevel,

                     const int                                                 a_ghostWidth,

                     const Gather&                                             a_gather) noexcept;


template <typename P,

          typename Packed,

          typename Traits,

          typename Combine,

          typename Scatter,

          typename PosValid,

          typename Allocator,

          typename OnMerge>

inline void

finishMergeRound(ParticleContainer<P, Traits>&                             a_particles,

                 std::unordered_map<ParticleID, NNPooledParticle<Packed>>& a_particlesByID,

                 std::unordered_set<ParticleID>&                           a_consumedIDs,

                 std::unordered_map<NNCellKey, int, NNCellKeyHasher>&      a_liveCellCount,

                 std::vector<NNMergeResult<Packed>>&                       a_allResults,

                 unsigned long long*                                       a_crossLevelMergeCount,

                 const AmrMesh&                                            a_amr,

                 const std::string&                                        a_realm,

                 const NNCellBudget&                                       a_cellBudget,

                 const Combine&                                            a_combine,

                 const Scatter&                                            a_scatter,

                 const Allocator&                                          a_allocateID,

                 const std::optional<int>                                  a_maxCellDistance,

                 const PosValid&                                           a_isPositionValid,

                 const RealVect&                                           a_probLo,

                 const std::vector<RealVect>&                              a_dxByLevel,

                 const std::vector<NNPatchWork>&                           a_patchWork,

                 const std::vector<NNMergeEdge<Packed>>&                   a_pooledEdges,

                 const std::unordered_set<ParticleID>&                     a_hasOutgoingCommitment,

                 const OnMerge&                                            a_onMergeCommitted) noexcept;


template <typename P,

          typename Packed,

          typename Traits,

          typename Cloud,

          typename Gather,

          typename Combine,

          typename Scatter,

          typename Allocator,

          typename PosValid,

          typename OnMerge>

inline void

mergeNearestNeighborsRoundImpl(ParticleContainer<P, Traits>& a_particles,

                               unsigned long long*           a_crossLevelMergeCount,

                               const AmrMesh&                a_amr,

                               const NNCellBudget&           a_cellBudget,

                               const Gather&                 a_gather,

                               const Combine&                a_combine,

                               const Scatter&                a_scatter,

                               const Allocator&              a_allocateID,

                               const bool                    a_iterateLocalTierToConvergence,

                               const int                     a_maxFallbackCandidates,

                               const std::optional<int>      a_maxCellDistance,

                               const int                     a_ghostWidth,

                               const PosValid&               a_isPositionValid,

                               const OnMerge&                a_onMergeCommitted);


} // namespace detail


template <typename P,

          typename Packed,

          typename Traits = ParticleTraits<P>,

          typename Gather,

          typename Combine,

          typename Scatter,

          typename Allocator,

          typename PosValid = std::function<bool(const RealVect&)>,

          typename OnMerge  = std::function<

             void(const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&)>>

inline void

mergeNearestNeighborsTree(

  ParticleContainer<P, Traits>& a_particles,

  const AmrMesh&                a_amr,

  const NNCellBudget&           a_cellBudget,

  const Gather&                 a_gather,

  const Combine&                a_combine,

  const Scatter&                a_scatter,

  const Allocator&              a_allocateID,

  const bool                    a_iterateLocalTierToConvergence = false,

  const int                     a_maxFallbackCandidates         = 0,

  const std::optional<int>      a_maxCellDistance               = std::nullopt,

  const int                     a_ghostWidth                    = 1,

  const PosValid&               a_isPositionValid =

    [](const RealVect&) {

      return true;

    },

  unsigned long long* a_crossLevelMergeCount = nullptr,

  const OnMerge&      a_onMergeCommitted =

    [](const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&) {

    });


template <typename P,

          typename Packed,

          typename Traits = ParticleTraits<P>,

          typename Gather,

          typename Combine,

          typename Scatter,

          typename Allocator,

          typename PosValid = std::function<bool(const RealVect&)>,

          typename OnMerge  = std::function<

             void(const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&)>>

inline void

mergeNearestNeighborsHash(

  ParticleContainer<P, Traits>& a_particles,

  const AmrMesh&                a_amr,

  const NNCellBudget&           a_cellBudget,

  const Gather&                 a_gather,

  const Combine&                a_combine,

  const Scatter&                a_scatter,

  const Allocator&              a_allocateID,

  const bool                    a_iterateLocalTierToConvergence = false,

  const int                     a_maxFallbackCandidates         = 0,

  const std::optional<int>      a_maxCellDistance               = std::nullopt,

  const int                     a_ghostWidth                    = 1,

  const PosValid&               a_isPositionValid =

    [](const RealVect&) {

      return true;

    },

  unsigned long long* a_crossLevelMergeCount = nullptr,

  const OnMerge&      a_onMergeCommitted =

    [](const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&) {

    });


template <typename P,

          typename Packed,

          typename Traits = ParticleTraits<P>,

          typename Gather,

          typename Combine,

          typename Scatter,

          typename Allocator,

          typename PosValid = std::function<bool(const RealVect&)>,

          typename OnMerge  = std::function<

             void(const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&)>>

inline void

mergeNearestNeighborsOneCell(

  ParticleContainer<P, Traits>& a_particles,

  const AmrMesh&                a_amr,

  const NNCellBudget&           a_cellBudget,

  const Gather&                 a_gather,

  const Combine&                a_combine,

  const Scatter&                a_scatter,

  const Allocator&              a_allocateID,

  const bool                    a_iterateLocalTierToConvergence = false,

  const int                     a_maxFallbackCandidates         = 0,

  const PosValid&               a_isPositionValid =

    [](const RealVect&) {

      return true;

    },

  unsigned long long* a_crossLevelMergeCount = nullptr,

  const OnMerge&      a_onMergeCommitted =

    [](const MergeParticle<Packed>&, const MergeParticle<Packed>&, const MergeParticle<Packed>&) {

    });


} // namespace ParticleManagement


#include <CD_NamespaceFooter.H>


#include <CD_NearestNeighborParticleMergeImplem.H>


#endif

CD_NearestNeighborParticleMergeImplem.H
Implementation of CD_NearestNeighborParticleMerge.H.

CD_ParticleContainer.H
Declaration of an AMR-hierarchy container that owns per-patch ParticleSoA leaves.

CD_ParticleManagement.H
Namespace containing various particle management utilities.

CD_ParticleSoA.H
Declaration of ParticleSoA, an arena-backed Struct-of-Arrays particle container.

ParticleID
std::int64_t ParticleID
Global particle identifier type (container-owned metadata column; fixed-width for I/O).
Definition CD_ParticleSoA.H:161

AmrMesh
Class for handling spatial operations.
Definition CD_AmrMesh.H:45

ParticleContainer
AMR-hierarchy container of computational particles, stored per patch in Struct-of-Arrays form.
Definition CD_ParticleContainer.H:123

ParticleManagement::NNCellBudget
The per-cell particle count this merge drains each cell down to.
Definition CD_NearestNeighborParticleMerge.H:372

ParticleManagement::NNCellBudget::reserveOne
void reserveOne(const int a_level, const IntVect &a_cell)
Reserve one slot in a cell, lowering that cell's budget by one.
Definition CD_NearestNeighborParticleMerge.H:388

ParticleManagement::NNCellBudget::operator()
int operator()(const detail::NNCellKey &a_key) const noexcept
The budget for one cell: the uniform count less that cell's reservations, floored at 0.
Definition CD_NearestNeighborParticleMerge.H:416

ParticleManagement::NNCellBudget::NNCellBudget
NNCellBudget(const int a_uniform) noexcept
Construct a uniform budget. Deliberately implicit – a bare count is the common case.
Definition CD_NearestNeighborParticleMerge.H:378

ParticleManagement::NNCellBudget::reserveOne
void reserveOne(const int a_level, const RealVect &a_position, const RealVect &a_probLo, const RealVect &a_dx)
Reserve one slot in the cell a position falls in.
Definition CD_NearestNeighborParticleMerge.H:405

ParticleManagement::NNCellBudget::minimum
int minimum() const noexcept
The smallest budget any cell has.
Definition CD_NearestNeighborParticleMerge.H:435

ParticleManagement::detail::cellKeyOf
IntVect cellKeyOf(const RealVect &a_position, const RealVect &a_probLo, const RealVect &a_dx) noexcept
The unclamped, position-derived cell index a given physical position falls in.
Definition CD_NearestNeighborParticleMergeImplem.H:254

ParticleManagement::detail::NNCellKey
std::pair< int, IntVect > NNCellKey
A cell key together with the AMR level it was computed on – see cellKeyOf()'s warning.
Definition CD_NearestNeighborParticleMerge.H:323

ParticleManagement
Namespace for various particle management tools.
Definition CD_KDParticleMerge.H:33

ParticleManagement::IDAllocator
std::function< ParticleID()> IDAllocator
Illustrative signature of the fresh-id allocator: produce one globally-unique id for a newly created ...
Definition CD_NearestNeighborParticleMerge.H:278

ParticleManagement::MergeCommittedCallback
std::function< void(const MergeParticle< Packed > &a_first, const MergeParticle< Packed > &a_second, const MergeParticle< Packed > &a_merged)> MergeCommittedCallback
Optional per-merge diagnostic callback: observe every individual merge as it commits.
Definition CD_NearestNeighborParticleMerge.H:294

ParticleManagement::mergeNearestNeighborsOneCell
void mergeNearestNeighborsOneCell(ParticleContainer< P, Traits > &a_particles, const AmrMesh &a_amr, const NNCellBudget &a_cellBudget, const Gather &a_gather, const Combine &a_combine, const Scatter &a_scatter, const Allocator &a_allocateID, const bool a_iterateLocalTierToConvergence=false, const int a_maxFallbackCandidates=0, const PosValid &a_isPositionValid=[](const RealVect &) { return true;}, unsigned long long *a_crossLevelMergeCount=nullptr, const OnMerge &a_onMergeCommitted=[](const MergeParticle< Packed > &, const MergeParticle< Packed > &, const MergeParticle< Packed > &) { })
Run one full round of the one-cell nearest-neighbor merge: the same distributed propose/judge/verdict...
Definition CD_NearestNeighborParticleMergeImplem.H:1876

ParticleManagement::mergeNearestNeighborsHash
void mergeNearestNeighborsHash(ParticleContainer< P, Traits > &a_particles, const AmrMesh &a_amr, const NNCellBudget &a_cellBudget, const Gather &a_gather, const Combine &a_combine, const Scatter &a_scatter, const Allocator &a_allocateID, const bool a_iterateLocalTierToConvergence=false, const int a_maxFallbackCandidates=0, const std::optional< int > a_maxCellDistance=std::nullopt, const int a_ghostWidth=1, const PosValid &a_isPositionValid=[](const RealVect &) { return true;}, unsigned long long *a_crossLevelMergeCount=nullptr, const OnMerge &a_onMergeCommitted=[](const MergeParticle< Packed > &, const MergeParticle< Packed > &, const MergeParticle< Packed > &) { })
Run one full round of the nearest-neighbor merge algorithm, identical in every respect to mergeNeares...
Definition CD_NearestNeighborParticleMergeImplem.H:1832

ParticleManagement::PayloadCombine
std::function< Packed(const Packed &a_first, const Real a_firstWeight, const Packed &a_second, const Real a_secondWeight)> PayloadCombine
Illustrative signature of the combine callback: produce a merged particle's opaque payload from its t...
Definition CD_NearestNeighborParticleMerge.H:252

ParticleManagement::mergeNearestNeighborsTree
void mergeNearestNeighborsTree(ParticleContainer< P, Traits > &a_particles, const AmrMesh &a_amr, const NNCellBudget &a_cellBudget, const Gather &a_gather, const Combine &a_combine, const Scatter &a_scatter, const Allocator &a_allocateID, const bool a_iterateLocalTierToConvergence=false, const int a_maxFallbackCandidates=0, const std::optional< int > a_maxCellDistance=std::nullopt, const int a_ghostWidth=1, const PosValid &a_isPositionValid=[](const RealVect &) { return true;}, unsigned long long *a_crossLevelMergeCount=nullptr, const OnMerge &a_onMergeCommitted=[](const MergeParticle< Packed > &, const MergeParticle< Packed > &, const MergeParticle< Packed > &) { })
Run one full round (one timestep's worth) of the nearest-neighbor merge algorithm.
Definition CD_NearestNeighborParticleMergeImplem.H:1788

ParticleManagement::PositionValid
std::function< bool(const RealVect &a_mergedPosition)> PositionValid
Illustrative signature of the position-validity predicate for a would-be merged particle.
Definition CD_NearestNeighborParticleMerge.H:266

LevelTiles::LevelAndBox
Result of a point->block query. See findDestination.
Definition CD_LevelTiles.H:123

LevelTiles::TileHasher
Hash functor for using IntVect tiles as unordered_map keys.
Definition CD_LevelTiles.H:55

ParticleManagement::MergeParticle
Minimal, payload-agnostic description of one particle as input to a distributed merge.
Definition CD_ParticleManagement.H:430

ParticleManagement::detail::NNCellKeyHasher
Hash functor for NNCellKey – REQUIRED whenever NNCellKey is used as a hash-map key; NNCellKey must ne...
Definition CD_NearestNeighborParticleMerge.H:336

ParticleManagement::detail::NNCellKeyHasher::operator()
std::size_t operator()(const NNCellKey &a_key) const noexcept
Hash operator.
Definition CD_NearestNeighborParticleMerge.H:343

ParticleManagement::detail::NNFallbackCandidate
One additional ranked candidate beyond a query's primary nearest neighbor.
Definition CD_NearestNeighborParticleMerge.H:86

ParticleManagement::detail::NNFallbackCandidate::candidateID
ParticleID candidateID
Global id of this candidate.
Definition CD_NearestNeighborParticleMerge.H:90

ParticleManagement::detail::NNFallbackCandidate::candidateIsLocal
bool candidateIsLocal
True iff this candidate is a locally-valid particle in the SAME patch as the query (i....
Definition CD_NearestNeighborParticleMerge.H:101

ParticleManagement::detail::NNFallbackCandidate::distanceSquared
Real distanceSquared
Squared distance between the query particle and this candidate.
Definition CD_NearestNeighborParticleMerge.H:95

ParticleManagement::detail::NNMergeEdge
One candidate merge edge: a single particle's own nearest-neighbor query result.
Definition CD_NearestNeighborParticleMerge.H:115

ParticleManagement::detail::NNMergeEdge::candidateID
ParticleID candidateID
Global id of the candidate (query's nearest neighbor). May be a local valid particle (same patch) or ...
Definition CD_NearestNeighborParticleMerge.H:131

ParticleManagement::detail::NNMergeEdge::candidateIsLocal
bool candidateIsLocal
True iff the candidate is a locally-valid particle in the SAME patch as the query (i....
Definition CD_NearestNeighborParticleMerge.H:139

ParticleManagement::detail::NNMergeEdge::distanceSquared
Real distanceSquared
Squared distance between the query particle and its candidate.
Definition CD_NearestNeighborParticleMerge.H:119

ParticleManagement::detail::NNMergeEdge::fallbackCandidates
std::vector< NNFallbackCandidate > fallbackCandidates
Next-nearest candidates beyond candidateID, in ascending distanceSquared order.
Definition CD_NearestNeighborParticleMerge.H:149

ParticleManagement::detail::NNMergeEdge::queryID
ParticleID queryID
Global id of the query particle (always locally valid/owned – ghosts never initiate a query).
Definition CD_NearestNeighborParticleMerge.H:125

ParticleManagement::detail::NNMergeProposal
A cross-patch merge proposal: one particle's own nearest-neighbor query result, bundled as a self-con...
Definition CD_NearestNeighborParticleMerge.H:163

ParticleManagement::detail::NNMergeProposal::targetID
ParticleID targetID
Global id of the particle being proposed to. Owned by the receiving (judge) rank.
Definition CD_NearestNeighborParticleMerge.H:173

ParticleManagement::detail::NNMergeProposal::source
MergeParticle< Packed > source
The proposer's own particle (full data) – always locally valid/owned by the sending rank.
Definition CD_NearestNeighborParticleMerge.H:168

ParticleManagement::detail::NNMergeProposal::distanceSquared
Real distanceSquared
Squared distance between source and the target. Duplicated from the originating NNMergeEdge so the ju...
Definition CD_NearestNeighborParticleMerge.H:179

ParticleManagement::detail::NNMergeResult
One resolved merge: the two consumed particles' ids and the newly created merged particle (not yet pl...
Definition CD_NearestNeighborParticleMerge.H:212

ParticleManagement::detail::NNMergeResult::secondID
ParticleID secondID
Global id of the second consumed particle. For a trivial-tier result, this is the local candidate....
Definition CD_NearestNeighborParticleMerge.H:223

ParticleManagement::detail::NNMergeResult::merged
MergeParticle< Packed > merged
The newly created merged particle: weighted-centroid position, weighted-average opaque payload (compu...
Definition CD_NearestNeighborParticleMerge.H:231

ParticleManagement::detail::NNMergeResult::firstID
ParticleID firstID
Global id of the first consumed particle. For a trivial-tier result, this is the query particle....
Definition CD_NearestNeighborParticleMerge.H:217

ParticleManagement::detail::NNMergeVerdict
The judge's reply to one proposal.
Definition CD_NearestNeighborParticleMerge.H:190

ParticleManagement::detail::NNMergeVerdict::accepted
bool accepted
True iff the judge accepted this specific proposal (i.e. it was the winning candidate for its target ...
Definition CD_NearestNeighborParticleMerge.H:202

ParticleManagement::detail::NNMergeVerdict::proposerID
ParticleID proposerID
Global id of the proposer this verdict is a reply to (i.e. NNMergeProposal::source's id)....
Definition CD_NearestNeighborParticleMerge.H:196

ParticleManagement::detail::NNPooledParticle
Pooled per-round record for one particle: the particle plus its cached boundary-exposure flag.
Definition CD_NearestNeighborParticleMerge.H:64

ParticleManagement::detail::NNPooledParticle::particle
MergeParticle< Packed > particle
The pooled particle (position/weight/ids/level/payload).
Definition CD_NearestNeighborParticleMerge.H:68

ParticleManagement::detail::NNPooledParticle::exposed
bool exposed
Whether this local valid particle's cell touches a patch boundary (has ghost targets)....
Definition CD_NearestNeighborParticleMerge.H:74

ParticleTraits
Traits class that a user specializes to describe the PAYLOAD columns of a particle type....
Definition CD_ParticleSoA.H:192