STORMM Source Documentation
Loading...
Searching...
No Matches
stormm::mm::CellGridWriter< T, Tacc, Tcalc, T4 > Struct Template Reference

Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces. More...

#include <cellgrid.h>

Collaboration diagram for stormm::mm::CellGridWriter< T, Tacc, Tcalc, T4 >:

Public Member Functions

 CellGridWriter (NonbondedTheme theme_in, int system_count_in, int total_cell_count_in, int total_chain_count_in, int mesh_ticks_in, uint cell_base_capacity_in, float lpos_scale_in, float inv_lpos_scale_in, float frc_scale_in, const ullint *system_cell_grids_in, Tcalc *system_cell_umat_in, T *system_cell_invu_in, T *system_pmig_invu, uint2 *cell_limits_in, uint2 *cell_limits_alt_in, const uint *chain_limits_in, const int *system_chain_bounds_in, const int *chain_system_owner_in, T4 *image_in, T4 *image_alt_in, uchar *migration_keys_in, int *wander_count_in, int *wander_count_alt_in, uint2 *wanderers_in, int *nonimg_atom_idx_in, int *nonimg_atom_idx_alt_in, uint *img_atom_idx_in, uint *img_atom_idx_alt_in, ushort *img_atom_chn_cell_in, ushort *img_atom_chn_cell_alt_in, const int *nt_groups_in, ushort *relevance_in, Tacc *xfrc_in, Tacc *yfrc_in, Tacc *zfrc_in, int *xfrc_ovrf_in, int *yfrc_ovrf_in, int *zfrc_ovrf_in)
 As is other abstracts, the constructor takes a list of inputs for all member variables.
 
 CellGridWriter (const CellGridWriter &original)=default
 The presence of const array sizing members implicitly deletes the copy and move assignment operators, but the default copy and move constructors are valid.
 
 CellGridWriter (CellGridWriter &&original)=default
 

Public Attributes

const NonbondedTheme theme
 
const int system_count
 Number of systems whose spatial decompositions are stored.
 
const int total_cell_count
 The total number of decomposition cells across all systems.
 
const int twice_cell_count
 Twice the number of decomposition cells across all systems.
 
const int total_chain_count
 
const int mesh_ticks
 
const uint cell_base_capacity
 
const float lpos_scale
 
const float inv_lpos_scale
 
const float frc_scale
 
const ullint * system_cell_grids
 
Tcalc * system_cell_umat
 
T * system_cell_invu
 
T * system_pmig_invu
 
uint2cell_limits
 
uint2cell_limits_alt
 
const uint * chain_limits
 
const int * system_chain_bounds
 
const int * chain_system_owner
 
T4 * image
 
T4 * image_alt
 
uchar * migration_keys
 
int * wander_count
 
int * wander_count_alt
 
uint2wanderers
 
int * nonimg_atom_idx
 
int * nonimg_atom_idx_alt
 
uint * img_atom_idx
 
uint * img_atom_idx_alt
 
ushort * img_atom_chn_cell
 
ushort * img_atom_chn_cell_alt
 
const int * nt_groups
 
ushort * relevance
 
Tacc * xfrc
 Accumulators for Cartesian X forces on imaged particles.
 
Tacc * yfrc
 Accumulators for Cartesian Y forces on imaged particles.
 
Tacc * zfrc
 Accumulators for Cartesian Z forces on imaged particles.
 
int * xfrc_ovrf
 Overflow bits for xfrc.
 
int * yfrc_ovrf
 Overflow bits for yfrc.
 
int * zfrc_ovrf
 Overflow bits for zfrc.
 

Detailed Description

template<typename T, typename Tacc, typename Tcalc, typename T4>
struct stormm::mm::CellGridWriter< T, Tacc, Tcalc, T4 >

Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces.

Member Data Documentation

◆ cell_base_capacity

template<typename T, typename Tacc, typename Tcalc, typename T4>
const uint stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::cell_base_capacity

The maximum capacity of any one cell (all cells in a row along a simulation box's A axis share their excess capacity, making a provision for one cell to take on a much larger number of atoms)

◆ cell_limits

template<typename T, typename Tacc, typename Tcalc, typename T4>
uint2* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::cell_limits

Limits of the atoms in each cell out of the entire current image. The "x" and member of the tuple provides an absolute index within the current image for the lower bound of atoms. The "y" member provides, in its low 16 bits, the system index (the maximum number of systems is set in maximum_cellgrid_systems). The "y" member of the tuple also provides, in its high 16 bits, the number of atoms in the particular cell. The system index must be used to retrieve information in system_cell_grids in order to put the cell in context and see, for example, which other cells are its neighbors.

◆ cell_limits_alt

template<typename T, typename Tacc, typename Tcalc, typename T4>
uint2* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::cell_limits_alt

Limits of atoms in each cell of the next image. The cell_limits member variable above describes the tuple.

◆ chain_limits

template<typename T, typename Tacc, typename Tcalc, typename T4>
const uint* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::chain_limits

Immutable limits on the cell chains within each cell grid. The ith chain cannot hold more than a number of atoms given by chain_limits[i + 1] - chain_limits[i]. The atom capacity across chains in a particular system is consistent, but different systems may have different capacities.

◆ chain_system_owner

template<typename T, typename Tacc, typename Tcalc, typename T4>
const int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::chain_system_owner

Indices of the systems that own each chain. The system which owns the kth chain of cells is given by the value of chain_system_owner[k].

◆ frc_scale

template<typename T, typename Tacc, typename Tcalc, typename T4>
const float stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::frc_scale

Scaling factor to apply to forces prior to accumulation in the available fixed-precision arrays

◆ image

template<typename T, typename Tacc, typename Tcalc, typename T4>
T4* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::image

The array of atom coordinates and property information. This is modifiable so that it can be built by one of a collection of similar kernels.

◆ image_alt

template<typename T, typename Tacc, typename Tcalc, typename T4>
T4* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::image_alt

The next array of atom coordinates, provided so that the new image can be built out-of-place. See the time cycle to understand how this and image point to image or image_alt (and vice-versa) in the original CellGrid object. The construction of image_alt from image is an out-of-place sort.

◆ img_atom_chn_cell

template<typename T, typename Tacc, typename Tcalc, typename T4>
ushort* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::img_atom_chn_cell

The cell index of the chain in which each atom of the image resides. Chains proceed along each system's unit cell A axis.

◆ img_atom_chn_cell_alt

template<typename T, typename Tacc, typename Tcalc, typename T4>
ushort* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::img_atom_chn_cell_alt

The cell index of the chain in which each atom of the alternate image resides

◆ img_atom_idx

template<typename T, typename Tacc, typename Tcalc, typename T4>
uint* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::img_atom_idx

Indices where each atom of the associated synthesis of molecular systems can be found in the image. To figure out the image array location of the kth atom of some PhaseSpaceSynthesis or AtomGraphSynthesis, look up img_atom_idx[k].

◆ img_atom_idx_alt

template<typename T, typename Tacc, typename Tcalc, typename T4>
uint* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::img_atom_idx_alt

Neighbor list alternate image indices for each atom in the synthesis

◆ inv_lpos_scale

template<typename T, typename Tacc, typename Tcalc, typename T4>
const float stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::inv_lpos_scale

The inverse scaling factor applied to coordinates in the images

◆ lpos_scale

template<typename T, typename Tacc, typename Tcalc, typename T4>
const float stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::lpos_scale

The local position scaling factor applied to coordinates in the images (expressed as a 32-bit floating point number, as this will be converted to 64-bit format with no more or less information if needed)

◆ mesh_ticks

template<typename T, typename Tacc, typename Tcalc, typename T4>
const int stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::mesh_ticks

The number of mesh grid spacings per spatial decomposition cell, pertaining to a particle-mesh interaction grid associated with the neighbor list decomposition.

◆ migration_keys

template<typename T, typename Tacc, typename Tcalc, typename T4>
uchar* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::migration_keys

Migration keys for every atom in the image. There is no "alternate" form of this array, as it is filled and then re-initialized over the course of the out-of-place sort that populates image_alt based on image.

◆ nonimg_atom_idx

template<typename T, typename Tacc, typename Tcalc, typename T4>
int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::nonimg_atom_idx

Indices of each atom in the image within the associated synthesis of molecular systems (a PhaseSpaceSynthesis as well as an AtomGraphSynthesis, where atoms are held in topological order). The value of nonimg_atom_idx[k] indicates what atom out of the PhaseSpaceSynthesis and corresponding AtomGraphSynthesis the kth atom of the image really is.

◆ nonimg_atom_idx_alt

template<typename T, typename Tacc, typename Tcalc, typename T4>
int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::nonimg_atom_idx_alt

Synthesis atom indices for each atom in the alternate image

◆ nt_groups

template<typename T, typename Tacc, typename Tcalc, typename T4>
const int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::nt_groups

Concatenated lists of cells associated by the "tower and plate" neutral territory decomposition. The ith group of 16 elements from this list enumerates the cells to associate with the ith cell, whose atom limits are described in the cell_limits or cell_limits_alt arrays.

◆ relevance

template<typename T, typename Tacc, typename Tcalc, typename T4>
ushort* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::relevance

Indicators of the relevance of each atom in the present image to the neighbor list cells surrounding it, in terms of the atom being within range of any volume element of the nearby

◆ system_cell_grids

template<typename T, typename Tacc, typename Tcalc, typename T4>
const ullint* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::system_cell_grids

Dimensions of each cell grid and the starting point for its cells in the array. This array has one element for each system in the underlying coordinate synthesis.

◆ system_cell_invu

template<typename T, typename Tacc, typename Tcalc, typename T4>
T* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::system_cell_invu

Inverse transformation matrix for each system's individual cells. The columns of this matrix indicate the size of the cell.

◆ system_cell_umat

template<typename T, typename Tacc, typename Tcalc, typename T4>
Tcalc* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::system_cell_umat

Transformation matrices for taking Cartesian coordinates into the fractional space of the local coordinate system in each system's individual cells.

◆ system_chain_bounds

template<typename T, typename Tacc, typename Tcalc, typename T4>
const int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::system_chain_bounds

Bounds on the list of chains held by each system. The process is for one or more blocks to look up these limits and then do chains from within the system before looking up new limits and moving on to the next block. With the chain bounds known, the proper limits of atoms found in chain_limits can be accessed, and from those the lists of atoms in each cell of the chain.

◆ system_pmig_invu

template<typename T, typename Tacc, typename Tcalc, typename T4>
T* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::system_pmig_invu

Inverse transformation matrix for each system's individual particle-mesh interaction grid elements. The columns of this matrix indicate the size of the grid elements.

◆ theme

template<typename T, typename Tacc, typename Tcalc, typename T4>
const NonbondedTheme stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::theme

The non-bonded property for which the neighbor list is maintained (electrostatic, van-der Waals, or both)

◆ total_chain_count

template<typename T, typename Tacc, typename Tcalc, typename T4>
const int stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::total_chain_count

The number of cell chains, groups of cells found in a row along the unit cell A axis of one simulation, across all systems

◆ wander_count

template<typename T, typename Tacc, typename Tcalc, typename T4>
int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::wander_count

The number of far-wandering atoms (all such atoms will be considered when computing the population of every cell in the developing image)

◆ wander_count_alt

template<typename T, typename Tacc, typename Tcalc, typename T4>
int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::wander_count_alt

Alternate count for the number of wandering atoms. This serves the tick-tock WHITE-BLACK time cycle paradigm, and is provided so that a kernel processing migration can reset the count for the next cycle without imposing a race condition on the current cycle.

◆ wanderers

template<typename T, typename Tacc, typename Tcalc, typename T4>
uint2* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::wanderers

The array for far-wandering atoms, with the index in the current image (a number which can be traced to a particular cell, but at some effort) in the "x" member and the cell index to which the atom is headed in the "y" member


The documentation for this struct was generated from the following file: