Particle Pair Loop#

This section contains documentation for particle pair looping. Particle pair looping is a looping type similar to particle loop except that the kernel operates on two particles.

Table 13 Constructs that are passable to Particle Pair Loops#
Construct	Access Modes
CellDatConst	Read, Write, Add, Min, Max
DescendantProducts	Write
LocalArray	Read, Write, Add
MaskArray	Read, Write
NDLocalArray	Read, Write, Add, Max, Min
ParticleMask	Read, Write
SymVector	Read, Write
ParticlePairLoopIndex	Read
KernelRNG	Read
TupleRNG	Read

Pair Lists Absolute#

These types define iteration sets for Particle Pair Loops. The type of the iteration set determines which pair loop is executed. Typically these absolute pair lists are constructed from pair lists that inherit a base class that corresponds to the pair list type.

template<typename GROUP_TYPE, typename PAIR_LIST_TYPE> struct CellwisePairListAbsolute#: Type for defining the A and B sets along with the pair list.

template<> struct CellwisePairListAbsolute#

#include <cellwise_pair_list_absolute.hpp>

Type for defining the A and B sets along with the pair list where both A and B are ParticleGroups.

Public Functions

inline CellwisePairListAbsolute( ParticleGroupSharedPtr A, ParticleGroupSharedPtr B, CellwisePairListBlockInterfaceSharedPtr pair_list )#

Create cell wise pair list where the pair indices correspond to particle layers in two ParticleGroups A and B. A may equal B.

Parameters:

A – First ParticleGroup which suppies the “i” particles.
B – Second ParticleGroup which suppies the “j” particles.
pair_list – Pair list of particle pairs.

Host Pair List#

The host pair list is a simple pair list construct where pairs are specified only on the host.

class CellwisePairListHost#

#include <cellwise_pair_list_host.hpp>

Type to hold a list of pairs of particles that should collide in each cell.

Public Functions

CellwisePairListHost(const CellwisePairListHost &st) = delete#: Disable (implicit) copies.

CellwisePairListHost &operator=( CellwisePairListHost const &a ) = delete#: Disable (implicit) copies.

CellwisePairListHost(const int num_mesh_cells)#

Parameters:: num_mesh_cells – Number of cells to hold pairs for.

void push_back(const int cell, const int i, const int j)#: Adds a pair of particles to the pair list for a given cell.

int get_next_wave(const int cell, const int layer)#

Parameters:

cell – Cell of particles.
layer – Layer of particle.

Returns:

Minimum wave index that a pair involving the given particle could execute on.

void set_next_wave(const int cell, const int layer, const int wave)#

Parameters:

cell – Cell of particles.
layer – Layer of particle.
wave – Next wave that can include the particle.

void clear()#: Clears all held state.

CellwisePairListHostMap &get()#

Returns:: The host representation of the pair list.

Public Members

int num_mesh_cells = {0}#: Number of cells to hold pairs for.

Simple Pair List#

This simple pair list is a pair list construct where pairs are specified on the host.

class CellwisePairListSimple : public NESO::Particles::CellwisePairList#

#include <cellwise_pair_list_simple.hpp>

Type to hold a list of pairs of particles that should collide in each cell.

Public Functions

CellwisePairListSimple(const CellwisePairListSimple &st) = delete#: Disable (implicit) copies.

CellwisePairListSimple &operator=( CellwisePairListSimple const &a ) = delete#: Disable (implicit) copies.

CellwisePairListSimple( SYCLTargetSharedPtr sycl_target, const int num_mesh_cells )#

Parameters:

sycl_target – Compute device for pairs.
num_mesh_cells – Number of cells to hold pairs for.

void push_back( const std::vector<int> &c, const std::vector<int> &i, const std::vector<int> &j )#

Host callable utility method to push pairs (i,j) onto the cell list for cells c.

Parameters:

c – Cells to push pair (i,j) onto the cell list for.
i – First particles of the pair.
j – Second particles of the pair.

void set(CellwisePairListHostSharedPtr pair_list)#

Set the cell list from a host description of waves of pairs.

Parameters:: pair_list – Host description of pairs.

void clear()#: Empty the pair list.

virtual CellwisePairListDevice get_pair_list() override#

Get a description of the pair list accessible on the device.

Returns:: PairListDevice describing all the particle pairs. The returned object must have a lifetime equal or shorter than this host instance.

virtual CellwisePairListHostMap get_host_pair_list() override#

Get a description of the pair list accessible on the host.

Returns:: Container of pairs for each cell.

virtual INT get_num_pairs() override#

Returns:: The number of pairs in the pair list.

virtual PairMaskSharedPtr get_pair_mask() override#

Returns:: The MaskArray which can be used to mask off pairs. By default all pairs will be enabled.

Public Members

SYCLTargetSharedPtr sycl_target#: Compute device holding pairs.

int num_mesh_cells = {0}#: Number of cells to hold pairs for.

Particle Pair Loop Functions#

Functions that create Particle Pair Loops. These functions accept an absolute pair list as the iteration set specification.

template<typename KERNEL, typename ...ARGS> inline ParticlePairLoopBaseSharedPtr particle_pair_loop( std::string name, std::vector<CellwisePairListAbsolute<ParticleGroup, CellwisePairList>> pair_lists, KERNEL kernel, ARGS... args )#

Create a ParticlePairLoop from cellwise pair lists. This is a helper function to create instances of ParticlePairLoopCellwisePairList. This helper function is for backwards compatibility, the pair_lists vector must be size 1.

Parameters:

name – Name for ParticlePairLoop.
pair_lists – Vector of CellwisePairListAbsolute pair lists.
kernel – Kernel for pair loop.
args – Arguments for pair loop.

Returns: