STORMM Source Documentation
|
Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces. More...
#include <cellgrid.h>
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 |
uint2 * | cell_limits |
uint2 * | cell_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 |
uint2 * | wanderers |
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. | |
Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces.
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)
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.
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.
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.
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].
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
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.
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.
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.
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
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].
uint* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::img_atom_idx_alt |
Neighbor list alternate image indices for each atom in the synthesis
const float stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::inv_lpos_scale |
The inverse scaling factor applied to coordinates in the images
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)
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.
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.
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.
int* stormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >::nonimg_atom_idx_alt |
Synthesis atom indices for each atom in the alternate image
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.
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
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.
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.
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.
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.
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.
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)
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
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)
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.
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