Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

▼Nstormm
►Ncard
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CCoreKlManager	A class to guide the implementation of GPU kernels, with selected thread counts per block and block counts per launch grid for a specific GPU based on the workload. This object is constructed in a stepwise manner, with each kind of work unit contributing new launch specifications
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHpcConfig	Take an image of the available system hardware. One or more GPUs can be assigned to a thread based on this information
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CHybridLabel	A Hybrid object's immutable identifying information, stored as a const member variable within the Hybrid object itself
Cint2
CKernelFormat	Encapsulate the operations to store and retrieve information about a kernel's format
CKernelManager	Parent class for other kernel managers, incorporating the common dictionary of kernel keys and GPU details
CLedger	A struct for storing records of all active Hybrid memory arrays. This will also store tables of identifiers that indicate the most recent state of a group of Hybrid arrays, which can be accessed by structs of pointers to make sure that they reflect the most recent state of all their underlying arrays
CLedgerEntry	Entries of the memory ledger recording not just a copy of the immutable type data but also allocation sizes and allocation states
CMeshKlManager	Collect and dispense the launch parameters for various mesh-based kernels. The launches for these kernels will generally take place in the context of a BackgroundMesh object, whether during its construction or for its application
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
►Nchemistry
CApprox	Class for handling comparisons of floating-point results versus expected values in unit tests. The general form is to take a vector of real numbers and apply the comparison across all entries
CAtomEquivalence	Collect the set of symmetry-related and interchangeable groups for one or more molecules within a topology
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomMask	An atom selection within a system. Internally, this stores a bitmask, one bit for every particle, to denote whether it is in the mask. The object also stores the original string upon which the mask was constructed and a description of the mask, as it is a significant computation to build
CAtomRank	Compute ranks for each atom from one or more molecules, assigning a unique (but, essentially arbitrary) integer to each atom based on whether its connections to other atoms in the system can be deemed unique. If the matchBondingPattern() function below returns TRUE for atoms i and j, then atoms i and j will have the same integer rank in this object
CBondedNode	A struct to serve as a tracker of progress through a molecule in the search for loops. Proceeding forward in the search, every link will have come from one and only one previous link, but could go in multiple directions thereafter
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
CChemicalFeaturesReader	Abstract of the chemical features object: this is about as complex as an object with a single abstract should get
CCondensate	Condense the data format, and possibly offer a reduced representation of coordinates, along with work units detailing which systems should be imported by each block on a given GPU
CCondensateReader	Read-only abstract for the Condensate class. In most cases, the read-only abstract will be preferred as modifications to coordinates should happen in the original synthesis object with its fixed precision arrays
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoordinateSeriesReader	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
CCoupledEdit	A pairing of some process (a ConformationEdit, being a rotation about a bond, flipping groups across an isomeric cis-trans bond, or inversion of a chiral center) with an integer index to indicate its association with some list or group. This struct serves the SynthesisPermutor (see synthesis_permutor.h and the synthesis namespace) as well as the IsomerPlan object (see above). In Hybrid objects, it is transmutable with int2
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CIndigoAtomCenter	Enumerate the possible combinations of formal charge state and the orders of bonds relevant to a particular atom. Also list the other atoms linked by those bonds
CIndigoFragment	A fragment of a structure detailed with the Indigo scoring function
CIndigoTable	Table of options and optimization targets for an Indigo formal charge and bond order assignment
CIsomerPlan	A shorthand form of a conformational degree of freedom, which could be a rotable bond, cis-trans invertible bond, or chiral center
CMaskComponent	A mask is a series of operators and more primitive masks. This struct comprises both things, with an indicator as to what it contains. A complete mask for a given scope is composed by stepping through a list of these objects
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CSelectionItem	The quantum of an atom mask: a specific name, or a numerical range, of atoms or residues. A vector of these composes one part of an atom mask. Multiple masks combine according to additional operators (not '!', and '&', as well as or '|') in order to compile a single ambmask. This struct is unguarded
CStopWatch	Object for managing calls to the C-standard function gettimeofday(), calculating deltas and categorizing time spent according to a developer's wishes. Calls to gettimeofday() are precise to microseconds, and take considerably less time than that. With the option to lookup a section by numerical index, the timing can have no impact whatsoever on any serious computation, and even lookup by section name is relatively fast thanks to the findStringInVector() function. The relative time can be computed in a number of ways, so that the timer can be called less frequently but not accrue all of the time since it last sampled the computation
CTextGuard	Structure for specifying the features of a comment in some text file
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
►Ndata_types
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
Cchar2
Cchar3
Cchar4
CCombineIDp	A combination of integer and double data. Like other mixed tuples in this library, this will maintain the x, y, z, and w member variable naming conventions
Cdouble2
Cdouble3
Cdouble4
CEcumenical2	Mimic critical CUDA typecasting intrinsics with simple unions {
CEcumenical4
CEcumenical8
Cfloat2
Cfloat3
Cfloat4
Cint2
Cint3
Cint4
Cint95_t	A mixed tuple for 95-bit integer accumulation. This is the proper way to take double-precision floating point arithmetic into fixed precision format with minimal loss
Clonglong2
Clonglong3
Clonglong4
Cshort2
Cshort3
Cshort4
Cuchar2
Cuchar3
Cuchar4
Cuint2
Cuint3
Cuint4
Culonglong2
Culonglong3
Culonglong4
Cushort2
Cushort3
Cushort4
CValueWithCounter	Templated, combined type for tagging any data type with an associated integer count
CVec2	A template-compatible class for implementing vectorized two-tuples in C++ code, based on a single scalar type
CVec3	A template-compatible class for implementing vectorized three-tuples in C++ code, based on a single scalar type
CVec4	A template-compatible class for implementing vectorized four-tuples in C++ code, based on a single scalar type
►Ndiskutil
CBinaryFileContent
CBinaryFileKey	The table of contents keeps a list of arrays and specific values as well as text-based strings describing them. The strings can come from Hybrid objects' labels, for example, but can also accept arbitrary character strings
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
►Ndisplay
CNamelistEmulator	Collection of variables to transcribe information contained within a namelist
CNamelistToken	Link a string containing the human-readable title of a namelist to a function pointer which produces a complete, but probably uninitialized, namelist emulator containing all of the relevant keywords
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
►Ndocs
CCppScope	Describe a named C++ scope in terms of its place in a file, the namespaces it occupies, and any annotation that appears to be associated with it
CObjectIdentifier	Stores data on instances of an object (i.e. a function or struct found in a given file
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CTextGuard	Structure for specifying the features of a comment in some text file
►Nenergy
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CBrickwork	This class will subdivide a series of simulatiion boxes, whose lengths are whole numbers on all sides, into a set of partitions which keep to specified limits and cover the entire space in a number of rectangular partitions as close as possible to a specified number. The partitions can be ordered by size
CCacheResource	An object to hold temporary data for a particular work unit (whether bonded or non-bonded), resident in GMEM but private to a particular thread block. This object must be allocated in such a way as to be ready to hold the private workspaces of any thread blocks that will make use of it. The object is arranged to support operations based on PhaseSpaceSynthesis respresentations of systems' coordinates and forces
CCacheResourceKit	Abstract for the CacheResource object, accessible as a C-style struct and suitable for passing to GPU kernels as a kernel argument
CCellGrid	An object to manage the spatial decomposition of a system of particles. The general strategy is to arrange particles in a grid of cells, each at least half the direct-space cutoff in width in all directions. A work unit entails computing all interactions assigned to one of the cells. This is done using a neutral-territory decomposition the lines of the "tower-plate" arrangement, which consists of seventeen cells:
CCellGridReader	Read-only abstract for the CellGrid object. This is unused in typical MD applications, when it is always the case that the cell grid positions and atom content are being updated or forces are being accumulated, but it may be useful when the cell grid is in demand strictly as a directory of which atoms are close to one another for building or detailing some other object. The associated workspace variables are not included in this form of the abstract
CCellGridWriter	Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces
CCellOriginsReader
CCellOriginsWriter
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CConvolutionKit	Any abstract of the convolution manager is read-only
CConvolutionManager	Collect elements for performing the reciprocal space convolution in many systems. This class works most directly in conjunction with a PMIGrid object, and is expected to reference the same PhaseSpaceSynthesis and CellGrid objects. This object will also point to the underlying AtomGraphSynthesis (topology synthesis). Terminology in this object follows from the 1995 Smooth Particle Mesh Ewald publication:
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoordinateSeriesReader	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
CCoordinateSeriesWriter	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
CCoreKlManager	A class to guide the implementation of GPU kernels, with selected thread counts per block and block counts per launch grid for a specific GPU based on the workload. This object is constructed in a stepwise manner, with each kind of work unit contributing new launch specifications
CForwardExclusionMask	This exclusion mask relies on the reality that, in most topologies, the bulk of one atom's exclusions will be found within the next 32 atoms listed in the topology. If an atom excludes other atoms beyond this range, a separate index records the position at which this happens and provides either an index into a list of additional atoms or, if possible, the index of one other reference index in the topology followed by a second mask of 32 atoms which indicate exclusions relative to the reference index. To keep the list as compact as possible, the exclusion mask only considers "forward" exclusions, meaning excluded atoms with higher index than the one for which the mask is made. There is no double-counting: if atom 1 excludes atom 5, then atom 5 does not note an exclusion of atom 1
CForwardExclusionMaskReader	The abstract for the forward exclusion mask turns out to be shorter than that for the StaticExclusionMask
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CImplicitSolventKit	Information needed for Generalized Born (and perhaps other) implicit solvent methods. This information is collected into an object separate from the non-bonded kit because only a subset of calculations will use GB for the solvent conditions
CImplicitSolventRecipe
CImplicitSolventWorkspace	A small collection of arrays to manage temporary accumulators for computing Born radii and their derivatives
CISWorkspaceKit	A simple abstract for the implicit solvent workspace. There are not readers and writers as the only useful application involves this workspace being writeable
CLayeredPotential	A long-ranged potential can be broken down into a series of successively smoother potentials applicable over longer and longer ranges. This object will manage a process whereby each potential and its first three derivatives decay exactly to zero at the specified boundary. The process generates some very complicated forms, particularly in the shortest-range potential where the effects assigned to all longer-ranged potentials must be subtracted off, but use of logarithmic adaptive splines can absorb the complexity
CLayeredPotentialMetrics	Collect the details needed to formulate a layered potential, including the length of each layer's cutoff (for direct particle-particle interactions), expected size of the unit cell (if applicable), mixing rule or Coulomb's constant, and the primary exponential coefficients for fitting successive smoothing functions
CLocalExclusionMask	The local exclusion mask is an generalized form of the ForwardExclusionMask, listing all exclusions in various ranges of an atom followed by additional masks. Like the ForwardExclusionMask, all atoms are assigned an index, but it points to a primary array of profiles, not quite like the primary masks of the ForwardExclusionList. There are a finite number of profiles, each containing a three-bit code to indicate how it is to be used
CLocalExclusionMaskReader	A lean, read-only abstract for the LocalExclusionMask class
CLogScaleSpline	A logarithmic spline can be very useful for interpolating functions that are steepest at low values of the argument, provided that the argument is never negative. This is a useful class of functions for describing inter-atomic potentials. The strategy is to utilize the logarithmic nature (and IEEE format) of a floating point number, taking the highest N bits of the mantissa and the exponent as an unsigned integer (because measurements of absolute distance will never be negative, the highest bit (the sign bit) will always be set to zero). It is most useful if the square root operation can be avoided altogether, indexing the table by the square of the function argument. This creates a more accurate table as well as saving arithmetic, although obtaining function derivatives (as a function of the argument, not its square) from the table becomes more expensive. In fact, this object abandons continuous derivatives in the tables and instead splines the derivative of the desired function as a separate logarithmic table
CLogSplineTable	Abstract for the logarithmic splined function object, containing the table and critical constants for evaluating it
CMMControlKit	The C-style, always writeable abstract for the MolecularMechanicsControls object. To not be able to modify this object's contents would be nonsensical, as it is intended to to keep counters of the simulation time step as well as force evaluation work units
CMolecularMechanicsControls	A collection of contol data for molecular mechanics simulations, conveying the current step number, progress counters through various work units, the time step, RATTLE tolerance, and other critical parameters to guide calculations. This common struct accommodates both molecular dynamics and molecular mechanics energy minimizations, and can be created from control objects derived from &dynamics or &minimize namelists
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CNrgLayerKit	The abstract of the LayeredPotential class provides only one of the layers. Kernels can be called with one or more such abstracts, but due to the logarithmic nature of the volume of particles applying each potential a "one size fits all" implementation is not practical. Furthermore, due to the way in which successive layers of the potential soften, multiple time step approaches which only invoke one to two layers of the potentials at a time are feasible
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
CPMIGrid	An object to hold a series of meshes for accumulating density from condensed-phase molecular systems and transforming it into potential, whether for charges and electrostatics or dispersion sources and van-der Waals interactions. This supports the particle-mesh interactions (PMI) of the particle-particle / particle-mesh potential partitioning common in several simulation techniques
CPMIGridAccumulator	A writeable abstract which reinterprets some pointers to enable split fixed-precision accumulation within the PMIGrid object
CPMIGridFPReader	A read-only abstract which can interpret the PMIGrid data in split fixed-precision format
CPMIGridReader	A read-only abstract for the Particle-Mesh Interaction Grid class
CPMIGridWriter	A writeable abstract for the Particle-Mesh Interaction Grid class
CPPIeKit	An equivalent abstract which delivers the tabulated data with all tuples broken into separate arrays of their individual components. This abstract is obtained with distinct accessors from PPITable, below. The "e" is for "element-wise."
CPPIKit	Abstract for the particle-particle interaction table, with pointers to energies and forces and sizing constants for navigating the excluded versus non-excluded interactions. Like the LogScaleSpline abstract, this is read-only
CPPITable	A tabulated non-bonded potential, with or without exclusions, to be used in the context of particle-particle, particle-mesh calculations. The key is to create two tables, one for the non-excluded form of the interaction and the other for the excluded form. The entries for each table will then be concatenated, such that all non-excluded interactions are contiguous and then all exclude interactions are contiguous. The offset for accessing an excluded interaction based on an index calculated from a particle-particle distance is stored alongside the tabulated splines in the abstract
CPsSynthesisBorders	A read-only abstract for the system demarcations in the object. This information is sometimes critical, and needed on the CPU host even as the general abstract is needed on the GPU device
CPsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CPsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CRestraintApparatus	A collection of all restraints pertaining to a specific topology for the purposes of one simulation, energy minimization, or even a single molecular mechanics calculation
CRestraintKit	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
CScoreCard	Track the energy components of a collection of systems in an HPC-capable array. This object uses the familiar trick of defining an enumerator (StateVariables) with a final entry to indicate its total length, so that if more energy components need to be tracked in the future the storage and indexing can automatically adjust with new entries
CScoreCardReader	Read-only abstract for the ScoreCard object. This is needed more for completeness than anything else, but could be useful in cases where virials are to be translated into rescaling coefficients on the GPU and then immediately used to rescale positions in a Berendsen barostatting situation
CScoreCardWriter	Writeable abstract for the ScoreCard object, useful for accumulating energies in many kernels
CSeMaskSynthesisReader	The read-only abstract for a static exclusion mask compilation. This provides access in a similar format to the static exclusion mask reader for a single system
CStaticExclusionMask	A simple pair list for an all-to-all calculation with exclusion masks. The list stores masks for 16 x 16 tiles of atoms indexed according to the atom order in some original topology. Each 16 x 16 tile mask will store the exclusions of 16 sending and 16 receiving atoms in the low 16 bits of an unsigned integer (probably 32-bit, but 16-bit format is also acceptable). The 16 x 16 tile masks are, in turn, arranged in groups of 16 x 16 such that each group of tiles covers the interactions of two consecutive sequences of 256 atoms apiece, for a total of 65,536 unique bits in 32kB (which counts the wasted high bits in each sending atom's mask as well as the reserved nature of the second sixteen bits). Many groups will have no exclusions at all, and these will all index into the first group stored in a master list. In this manner, a system of N atoms can have a complete pairlist constructed with ((N + 255) / 256)^2 super-tiles, with a storage requirement growing as N^2 but with a very small prefactor. With further hierarchical ordering, the pair list could even become O(N log N) in storage requirements. In the present scheme, simple pair lists can be built for very large systems if the exclusions are not spread throughout: a system of 131072 atoms with exclusions only between atoms +/-255 indices from one another would have space requirements of at most 52MB, probably much less. It is far better than the 2GB which would be required to store every exclusion as a unique bit
CStaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
CStaticExclusionMaskSynthesis	An exclusion mask object for a compilation of systems. All systems are represented in full detail, and a series of systems using the same topology will each get their own entries in the supertile map indices array, filtering on down to tile indices and the unique mask data
CSyAtomUpdateKit	Collect the virtual site details and constraint parameters of the topology synthesis into a single abstract. This is designed to work in the context of the valence work units from the same topology synthesis, whether in a standalone function or as an extra step in a workflow that compute valence interactions and then moves particles
CSyNonbondedKit	Collect the critical non-bonded parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis. Compared to the abstracts for a single system's AtomGraph, this merges the ImplicitSolventKit and NonbondedKit. For comparison, the SyValenceKit object merges the information for valence interactions, constraints, and virtual sites abstracts from the single topology's set of abstracts
CSyRestraintKit	Collect the critical restraint parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CSyValenceKit	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CThermostat	Store the parameters for a simulation thermostat. Includes Berendsen, Andersen, and Langevin methods. This class can be assembled like many of the control objects, i.e. MinimizationControls, based on namelists
CThermostatWriter	Partially writeable abstract for the Thermostat object. As with the MMControlKit struct (see the library header mm_controls.h), the step member variable is modifiable so that it can be updated without setting it in the parent object and regenerating the entire abstract
CTileManager	When tiles are loaded for what could be partial batches of atoms, it is critical for threads of the warp to be able to quickly calculate which atoms to load and perhaps replicate. After the tile has been evaluated, a rearrangement may be necessary to put atoms back in an order that the accumulated forces can be reduced and then added back to global arrays. This class will store tables of relative reading assignments and the preparatory rearrangements needed for the reduction step. The tables will be read with full L1-caching protocols to occupy a few kB of L1 with frequent re-use during particle-particle interaction tile evaluation
CTilePlan	The abstract of the TileManager contains pointers to direct the relative indexing of atom reads and the rearrangements that follow the tile evaluation needed to bring the the atoms back into an arrangement suitable for reducing the forces. The abstract is writeable
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
CValenceWorkUnit	An object to collect the components of a valence work unit (which will also track frozen atoms to implement coordinate updates, velocity updates, and constraints). While the work unit is encoded in the AtomGraphSynthesis object, the assembly is best done by a dedicated object with plenty of its own methods operating on a single topology (AtomGraph). All systems in the AtomGraphSynthesis are designed to function independently of one another–the only difference is that they have consensus tables of most parameters and differen atom indexing. Translating a valence work unit into a list of instructions within an AtomGraphSynthesis is therefore a critical member function of this class
CVirtualSiteKit	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
►Ngeneralized_born_defaults
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CNeckGeneralizedBornKit	Abstract for the NeckGeneralizedBornTable object, in single- or double-precision
CNeckGeneralizedBornTable	Object to hold a complex array of constants referenced by various GB calculations using the "neck" formalism for the union of spheres. This is an object of its own to encapsulate the underlying Hybrid data structures
►Nmm
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CCacheResource	An object to hold temporary data for a particular work unit (whether bonded or non-bonded), resident in GMEM but private to a particular thread block. This object must be allocated in such a way as to be ready to hold the private workspaces of any thread blocks that will make use of it. The object is arranged to support operations based on PhaseSpaceSynthesis respresentations of systems' coordinates and forces
CCellGrid	An object to manage the spatial decomposition of a system of particles. The general strategy is to arrange particles in a grid of cells, each at least half the direct-space cutoff in width in all directions. A work unit entails computing all interactions assigned to one of the cells. This is done using a neutral-territory decomposition the lines of the "tower-plate" arrangement, which consists of seventeen cells:
CCellGridReader	Read-only abstract for the CellGrid object. This is unused in typical MD applications, when it is always the case that the cell grid positions and atom content are being updated or forces are being accumulated, but it may be useful when the cell grid is in demand strictly as a directory of which atoms are close to one another for building or detailing some other object. The associated workspace variables are not included in this form of the abstract
CCellGridWriter	Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CConstraintKit	Information needed to manage constraint groups. This additional abstract is needed due to the way that some collections of rigid bonds all connect to the same atom, and because analytic SETTLE constraints are a thing
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoreKlManager	A class to guide the implementation of GPU kernels, with selected thread counts per block and block counts per launch grid for a specific GPU based on the workload. This object is constructed in a stepwise manner, with each kind of work unit contributing new launch specifications
CDynamicsControls	Object to encapsulate molecular dynamics control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CImplicitSolventKit	Information needed for Generalized Born (and perhaps other) implicit solvent methods. This information is collected into an object separate from the non-bonded kit because only a subset of calculations will use GB for the solvent conditions
CImplicitSolventWorkspace	A small collection of arrays to manage temporary accumulators for computing Born radii and their derivatives
CISWorkspaceKit	A simple abstract for the implicit solvent workspace. There are not readers and writers as the only useful application involves this workspace being writeable
CLineMinimization	This object serves a synthesis of systems. Hold the move multipliers for all of them and energies obtained by moving various distances along the conjugate gradient vector. This provides a basis for solving a cubic polynomial to identify the best move along the computed gradient
CLinMinReader	Abstract for the line minimization object incorporating write access
CLinMinWriter	Abstract for the line minimization object incorporating write access
CLocalExclusionMask	The local exclusion mask is an generalized form of the ForwardExclusionMask, listing all exclusions in various ranges of an atom followed by additional masks. Like the ForwardExclusionMask, all atoms are assigned an index, but it points to a primary array of profiles, not quite like the primary masks of the ForwardExclusionList. There are a finite number of profiles, each containing a three-bit code to indicate how it is to be used
CLocalExclusionMaskReader	A lean, read-only abstract for the LocalExclusionMask class
CMinimizeControls	Object to encapsulate energy minimization control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CMMControlKit	The C-style, always writeable abstract for the MolecularMechanicsControls object. To not be able to modify this object's contents would be nonsensical, as it is intended to to keep counters of the simulation time step as well as force evaluation work units
CMolecularMechanicsControls	A collection of contol data for molecular mechanics simulations, conveying the current step number, progress counters through various work units, the time step, RATTLE tolerance, and other critical parameters to guide calculations. This common struct accommodates both molecular dynamics and molecular mechanics energy minimizations, and can be created from control objects derived from &dynamics or &minimize namelists
CMotionSweeper	Object to manage and stage recentering and momentum removal for a coordinate synthesis. The object does not support asynchronous work unit scheduling but does contain two alternating sets of accumulators so that one set can be initialized when the other is in use
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
CPPPMControls	Object to encapsulate electrostatic and Lennard-Jones particle-mesh interaction controls. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CPrecisionControls	Object to encapsulate energy precision control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CPsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CPsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CReductionBridge	Allocate space for reduction operations to store temporary accumulations, bridging the gap between gathering and scattering operations
CReductionKit	Collect the simple components needed to guide reductions across all systems in a topology synthesis (or the corresponding compilation of coordinates): the number of work units, the strategy, and the list of work unit abstracts
CRestraintApparatus	A collection of all restraints pertaining to a specific topology for the purposes of one simulation, energy minimization, or even a single molecular mechanics calculation
CRestraintKit	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
CScoreCard	Track the energy components of a collection of systems in an HPC-capable array. This object uses the familiar trick of defining an enumerator (StateVariables) with a final entry to indicate its total length, so that if more energy components need to be tracked in the future the storage and indexing can automatically adjust with new entries
CScoreCardWriter	Writeable abstract for the ScoreCard object, useful for accumulating energies in many kernels
CStaticExclusionMask	A simple pair list for an all-to-all calculation with exclusion masks. The list stores masks for 16 x 16 tiles of atoms indexed according to the atom order in some original topology. Each 16 x 16 tile mask will store the exclusions of 16 sending and 16 receiving atoms in the low 16 bits of an unsigned integer (probably 32-bit, but 16-bit format is also acceptable). The 16 x 16 tile masks are, in turn, arranged in groups of 16 x 16 such that each group of tiles covers the interactions of two consecutive sequences of 256 atoms apiece, for a total of 65,536 unique bits in 32kB (which counts the wasted high bits in each sending atom's mask as well as the reserved nature of the second sixteen bits). Many groups will have no exclusions at all, and these will all index into the first group stored in a master list. In this manner, a system of N atoms can have a complete pairlist constructed with ((N + 255) / 256)^2 super-tiles, with a storage requirement growing as N^2 but with a very small prefactor. With further hierarchical ordering, the pair list could even become O(N log N) in storage requirements. In the present scheme, simple pair lists can be built for very large systems if the exclusions are not spread throughout: a system of 131072 atoms with exclusions only between atoms +/-255 indices from one another would have space requirements of at most 52MB, probably much less. It is far better than the 2GB which would be required to store every exclusion as a unique bit
CStaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
CStaticExclusionMaskSynthesis	An exclusion mask object for a compilation of systems. All systems are represented in full detail, and a series of systems using the same topology will each get their own entries in the supertile map indices array, filtering on down to tile indices and the unique mask data
CStopWatch	Object for managing calls to the C-standard function gettimeofday(), calculating deltas and categorizing time spent according to a developer's wishes. Calls to gettimeofday() are precise to microseconds, and take considerably less time than that. With the option to lookup a section by numerical index, the timing can have no impact whatsoever on any serious computation, and even lookup by section name is relatively fast thanks to the findStringInVector() function. The relative time can be computed in a number of ways, so that the timer can be called less frequently but not accrue all of the time since it last sampled the computation
CSyAtomUpdateKit	Collect the virtual site details and constraint parameters of the topology synthesis into a single abstract. This is designed to work in the context of the valence work units from the same topology synthesis, whether in a standalone function or as an extra step in a workflow that compute valence interactions and then moves particles
CSyNonbondedKit	Collect the critical non-bonded parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis. Compared to the abstracts for a single system's AtomGraph, this merges the ImplicitSolventKit and NonbondedKit. For comparison, the SyValenceKit object merges the information for valence interactions, constraints, and virtual sites abstracts from the single topology's set of abstracts
CSynthesisCacheMap	Encode a map between the systems of a snythesis and those of a SystemCache. The synthesis is expected to replicate the systems present in the cache, perhaps in a different order, perhaps to varying degrees for each system
CSyRestraintKit	Collect the critical restraint parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CSystemCache	Simple but central struct to store the primitive form of the collection of systems that most STORMM applications will work with. There are topologies, coordinate sets, and a list of indices to indicate how they mix and match. This object exists on the CPU and in host memory only, but the topology and coordinate contents have CUDA-capable memory components
CSyValenceKit	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CThermostat	Store the parameters for a simulation thermostat. Includes Berendsen, Andersen, and Langevin methods. This class can be assembled like many of the control objects, i.e. MinimizationControls, based on namelists
CThermostatReader	Read-only abstract for the Thermostat object
CThermostatWriter	Partially writeable abstract for the Thermostat object. As with the MMControlKit struct (see the library header mm_controls.h), the step member variable is modifiable so that it can be updated without setting it in the parent object and regenerating the entire abstract
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
CVirtualSiteKit	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
►Nmodeling
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CForceFieldElement	A versatile object for collecting the parameters and scope of applicability of any molecular mechanics force field term. This relies on enumerations to inform whether the term applies to atom types or atom and residue names and the nature of the term
►Nnamelist
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomMask	An atom selection within a system. Internally, this stores a bitmask, one bit for every particle, to denote whether it is in the mask. The object also stores the original string upon which the mask was constructed and a description of the mask, as it is a significant computation to build
CBoundedRestraint
CChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
CCommandLineParser	A class for collecting command line information. The class object will function somewhat like a namelist in that it gets loaded with keywords and can return the help messages for its contents upon receiving such a directive, but unlike namelists this one object is designed to be reconfigured for specific programs (even test programs, when it appears nested within the TestEnvironment class)
CConformerControls	Class to encapsulate the data that can be extracted from the &conformer namelist
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CDynamicsControls	Object to encapsulate molecular dynamics control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CFFMorphControls	Object to encapsulate force field morphing operations. Take information from an input file or a series of setters and validate each piece of data as it appears with private member functions
CFilesControls	Distill the results of file identification, producing clean lists of free topologies, free coordinate files, and linked topology / coordinate systems. Record output and trajectory files, if available
CForceFieldElement	A versatile object for collecting the parameters and scope of applicability of any molecular mechanics force field term. This relies on enumerations to inform whether the term applies to atom types or atom and residue names and the nature of the term
CMdlMolDataRequest	A request for one of a sanctioned list of information types to be included in a data item of an SD file. When printing an SD file, MdlMolDataItem objects will be created based on these requests
CMeshControls	Encapsulate the data extracted from a &receptor namelist to define a grid-mapped representation of a rigid macromolecular structure
CMinimizeControls	Object to encapsulate energy minimization control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CMoleculeSystem	Object to encapsulate a system, a coupled set of coordinates and a single topology. This can be used to enforce conf.stormm to read certain coordinates in the context of a particular topology, even when other viable topologies might be available
CNamelistElement	One keyword found in a namelist, ready to store the namelist variable moniker, the type, and the value read from the input file
CNamelistEmulator	Collection of variables to transcribe information contained within a namelist
CNamelistToken	Link a string containing the human-readable title of a namelist to a function pointer which produces a complete, but probably uninitialized, namelist emulator containing all of the relevant keywords
CNiceControls	Object to encapsulate job control and restraint information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPPPMControls	Object to encapsulate electrostatic and Lennard-Jones particle-mesh interaction controls. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CPrecisionControls	Object to encapsulate energy precision control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CRandomControls	Object to encapsulate random number generation controls. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CReceptorControls	Encapsulate the data extracted from a &receptor namelist to define a grid-mapped representation of a rigid macromolecular structure
CRemdControls	Encapsulating the data extracted from the REMD namelist
CRenderOptions
CReportControls	Collect output directives relating to the diagnostics file. While the output frequency is controlled by another namelist such as &minimize or &dynamics, STORMM is designed to handle many trajectories and thus the user is faced with a choice of what information to present and in what format
CReportTable	Tables in output file sections work differently than tables dumped to the terminal window. These tables will take in an array of data with some dimensions and then find the best way to organize it, storing all columns and rows as a series of strings
CRestraintControls	Object to encapsulate and dispense restraint information collected from a single &restraint namelist
CSceneControls	Collect output directives relating to scenes that STORMM might render through a matrix package, MatPlotLib, or PyMol. While the exact contents of the scene to be rendered will be determined by the application and perhaps a particular process within it, the stylistic details will be contained in one of these namelists. The namelist contents will primarily go into a RenderOptions object, but one notable element that the namelist contains is a label that can be used by the calling program to control which of multiple RenderOptions objects the contents should be directed into
CSolventControls	Object to encapsulate the data that can be extracted from a &solvent namelist. Typical C++ construction. Having this object, like others accompanying their respective namelists, makes the transition between namelists and custom-formatted control objects much simpler
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CTextGuard	Structure for specifying the features of a comment in some text file
CUserSettings	Object to hold general user input data, including file names or regular expressions for topology and coordinate files, energy minimization settings, analysis protocols, and output controls
►Nnumerics
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
►Nparse
CCitation	A means for numbering and tracking citations or other documented sources of information
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CTextGuard	Structure for specifying the features of a comment in some text file
►Nrandom
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CRan2Generator	Stores the state of a Ran2 pseudo-random number generator. Member functions produce random numbers along various distributions, as required. While it is not as performant to have a member function, these random number generators are intended for convenience and unit testing purposes. Developers that wish to use higher-performance random number generators should use the Xoroshiro128Generator (below) or link other libraries for the C++ layer (i.e. Intel MKL) or libraries that run on the GPU layer (i.e. cuRAND)
CRandomNumberMill	An series of "Xorshiro128+" generators, with state vectors for all of them and the means for seeding the series based on long jumps from a single state vector
CXoroshiro128pGenerator	The "Xoroshiro128+" random number generator. It's decent, but not recommended for situations where a quarter million or more streams are producing random number sequences in unison. Those streams can end up containing correlated patterns. This generator has been shown to fail BigCrush
CXoshiro256ppGenerator	The "Xoshiro256++" random number generator. While not cryptographically useful, it is a rock-solid random number generator for both floating-point and 64-bit integer results
►Nreporting
CProgressBar
►Nrestraints
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomMask	An atom selection within a system. Internally, this stores a bitmask, one bit for every particle, to denote whether it is in the mask. The object also stores the original string upon which the mask was constructed and a description of the mask, as it is a significant computation to build
CBoundedRestraint
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CFlatBottomPlan	Unguarded struct to hold elemens of a flat bottom restraint. Two such objects can hold the initial and final states of a restraint, as well as the steps at which each state takes effect
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CRestraintApparatus	A collection of all restraints pertaining to a specific topology for the purposes of one simulation, energy minimization, or even a single molecular mechanics calculation
CRestraintKit	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
►Nreview
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CBackgroundMesh	A workspace for constructing a pure potential mesh based on the frozen atoms of a large molecule. If the large molecule has nonrigid components, they must be excluded from contributing to the grid. In addition, any atoms up to 1:4 (connected by three bonds or less) must also be excluded from the grid-based potential. Computations on these atoms will not be accurate off the grid, but since they are frozen the consequences are mitigated
CBackgroundMeshReader	The templated, writeable abstract of a BackgroundMesh object
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoordinateSeriesReader	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
CFilesControls	Distill the results of file identification, producing clean lists of free topologies, free coordinate files, and linked topology / coordinate systems. Record output and trajectory files, if available
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CMeshFFKit	An object to store the probe's specific non-bonded parameters and softcore function coefficients used in mesh construction or mechanics
CMeshFoundation	A small object to hold the essential descriptors of the molecule
CMeshParameters	Encode the critical dimensions of a regular, rectilinear mesh. The locations of mesh points as well as spacings are stored as fixed-precision integers to ensure consistency and high performance on architectures with deficient 64-bit floating point arithmetic
CMeshParamKit	The abstract of a MeshParameters object is read-only (modify the original to get a new abstract if the dimensions change), but templated to prune the information present
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
COrderedList	The ability to express multiple items as an ordered list in formatted output is a great luxury in a command-line code. This object will accept multiple text strings and manage their presentation as a list with appropriate identifiers
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CRenderOptions
CReportControls	Collect output directives relating to the diagnostics file. While the output frequency is controlled by another namelist such as &minimize or &dynamics, STORMM is designed to handle many trajectories and thus the user is faced with a choice of what information to present and in what format
CReportTable	Tables in output file sections work differently than tables dumped to the terminal window. These tables will take in an array of data with some dimensions and then find the best way to organize it, storing all columns and rows as a series of strings
CScoreCard	Track the energy components of a collection of systems in an HPC-capable array. This object uses the familiar trick of defining an enumerator (StateVariables) with a final entry to indicate its total length, so that if more energy components need to be tracked in the future the storage and indexing can automatically adjust with new entries
CSectionContents	Any output file is expected to break into sections, which should be numbered in order and formatted consistently. This object will collect the elements of a section and provide methods for automatically writing them to an arbitrary output file
CSynthesisCacheMap	Encode a map between the systems of a snythesis and those of a SystemCache. The synthesis is expected to replicate the systems present in the cache, perhaps in a different order, perhaps to varying degrees for each system
CSynthesisMapReader	A set of pointers to critical arrays in the map below
CSystemCache	Simple but central struct to store the primitive form of the collection of systems that most STORMM applications will work with. There are topologies, coordinate sets, and a list of indices to indicate how they mix and match. This object exists on the CPU and in host memory only, but the topology and coordinate contents have CUDA-capable memory components
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CTickCounter	Make an array of integral settings and tick it forward (or backward). The analogy is a series of wheels A - N, each with n_A, n_B, ... , n_N settings. With each tick, the lowest wheel (position 0 of the array) advances one tick. When each wheel completes one revolution, it triggers an advance of the next wheel. This collapses to a simple base-K counting system for a series of wheels with equal numbers of K settings apiece
CUserSettings	Object to hold general user input data, including file names or regular expressions for topology and coordinate files, energy minimization settings, analysis protocols, and output controls
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
CWatcher	Exists to take note of 'significant' events that may occur while propagating a trajectory or during an energy minimization. Various O(N) processes may be recorded without adding significantly to the simulation cost, which could provide valuable information as to why it may be failing or even indicate problems in situations that appear otherwise normal
CWatcherReader	The read-only abstract for the Watcher class is available to make reports out of a Watcher object passed by const reference
CWatcherWriter	The writeable abstract for a Watcher class will be provided as a formal argument to various molecular simulations functions that record checks for it
►Nstmath
CApprox	Class for handling comparisons of floating-point results versus expected values in unit tests. The general form is to take a vector of real numbers and apply the comparison across all entries
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CClusterManager	An object to track the clusters into which a set of data points can be sorted
CClusterManagerKit	An abstract of the cluster manager suitable for rapid access and modification in the C++ layer, or submission as an argument to an HPC kernel. As with any collection of C-style pointers, the abstract is only valid so long as the object it references does not get resized
CCondensate	Condense the data format, and possibly offer a reduced representation of coordinates, along with work units detailing which systems should be imported by each block on a given GPU
CConjGradSubstrate	Collect pointers needed for conjugate gradient reduction operations, normalizing forces and mixing the results with a separate vector containing some memory of previous iterations. This object re-purposes data in the PhaseSpaceSynthesis object such as the velocities and prior position arrays. Absent from this object is a sense of where each system within the compiled synthesis starts and stops
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoreKlManager	A class to guide the implementation of GPU kernels, with selected thread counts per block and block counts per launch grid for a specific GPU based on the workload. This object is constructed in a stepwise manner, with each kind of work unit contributing new launch specifications
CGenericRdSubstrate	Collect pointers to data subject to reduction operations. Reductions can happen on up to three data sets at once, with one consistent fixed-precision scaling factor (if fixed-precision applies)
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHilbertSFC	Draw a Hilbert space-filling curve
CHpcMatrix	A matrix object that can traverse CPU and GPU memory
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CHybridLabel	A Hybrid object's immutable identifying information, stored as a const member variable within the Hybrid object itself
CJfErfc	Implement Norbert Juffa's fast erfc(alpha * x) approximation for 32-bit floating point computations. In the most prominent case for molecular dynamics, alpha corresponds to the "Ewald coefficient."
CLogScaleSpline	A logarithmic spline can be very useful for interpolating functions that are steepest at low values of the argument, provided that the argument is never negative. This is a useful class of functions for describing inter-atomic potentials. The strategy is to utilize the logarithmic nature (and IEEE format) of a floating point number, taking the highest N bits of the mantissa and the exponent as an unsigned integer (because measurements of absolute distance will never be negative, the highest bit (the sign bit) will always be set to zero). It is most useful if the square root operation can be avoided altogether, indexing the table by the square of the function argument. This creates a more accurate table as well as saving arithmetic, although obtaining function derivatives (as a function of the argument, not its square) from the table becomes more expensive. In fact, this object abandons continuous derivatives in the tables and instead splines the derivative of the desired function as a separate logarithmic table
CLogSplineTable	Abstract for the logarithmic splined function object, containing the table and critical constants for evaluating it
CMMControlKit	The C-style, always writeable abstract for the MolecularMechanicsControls object. To not be able to modify this object's contents would be nonsensical, as it is intended to to keep counters of the simulation time step as well as force evaluation work units
CMolecularMechanicsControls	A collection of contol data for molecular mechanics simulations, conveying the current step number, progress counters through various work units, the time step, RATTLE tolerance, and other critical parameters to guide calculations. This common struct accommodates both molecular dynamics and molecular mechanics energy minimizations, and can be created from control objects derived from &dynamics or &minimize namelists
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CPsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CRan2Generator	Stores the state of a Ran2 pseudo-random number generator. Member functions produce random numbers along various distributions, as required. While it is not as performant to have a member function, these random number generators are intended for convenience and unit testing purposes. Developers that wish to use higher-performance random number generators should use the Xoroshiro128Generator (below) or link other libraries for the C++ layer (i.e. Intel MKL) or libraries that run on the GPU layer (i.e. cuRAND)
CReductionBridge	Allocate space for reduction operations to store temporary accumulations, bridging the gap between gathering and scattering operations
CReductionKit	Collect the simple components needed to guide reductions across all systems in a topology synthesis (or the corresponding compilation of coordinates): the number of work units, the strategy, and the list of work unit abstracts
CReductionWorkUnit	A work unit to describe the manner in which groups of atoms in each structure of a synthesis come together to contribute to a single result. Reduction work units serve one and only one system apiece. The maximum size of these work units can be specified when they are created, in a manner analogous to valence or non-bonded work units, but is not limited by space in the GPU L1 cache so that, for practical optimizations, gather and scatter operations can be combined into all-reduce operations with a single kernel launch
CTickCounter	Make an array of integral settings and tick it forward (or backward). The analogy is a series of wheels A - N, each with n_A, n_B, ... , n_N settings. With each tick, the lowest wheel (position 0 of the array) advances one tick. When each wheel completes one revolution, it triggers an advance of the next wheel. This collapses to a simple base-K counting system for a series of wheels with equal numbers of K settings apiece
CTricubicCell	One element of a three-dimensional, space-filling tile representing a three-dimensional function to be interpolated by a tricubic spline
CTricubicStencil	A bundle of a 64 x 64 matrix, encoding the transformation of function values and derivatives at a stencil of points inside a tricubic mesh element into coefficients for that mesh element expressing the interpolated tricubic function. The type of stencil is also indicated, to keep this information coupled
CTwinPointer	A twin pointer, useful for performing partial-pivoting Gaussian elimination on row-major matrices
CValueWithCounter	Templated, combined type for tagging any data type with an associated integer count
CXoshiro256ppGenerator	The "Xoshiro256++" random number generator. While not cryptographically useful, it is a rock-solid random number generator for both floating-point and 64-bit integer results
►Nstructure
CAtomEquivalence	Collect the set of symmetry-related and interchangeable groups for one or more molecules within a topology
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CAtomMask	An atom selection within a system. Internally, this stores a bitmask, one bit for every particle, to denote whether it is in the mask. The object also stores the original string upon which the mask was constructed and a description of the mask, as it is a significant computation to build
CBackgroundMesh	A workspace for constructing a pure potential mesh based on the frozen atoms of a large molecule. If the large molecule has nonrigid components, they must be excluded from contributing to the grid. In addition, any atoms up to 1:4 (connected by three bonds or less) must also be excluded from the grid-based potential. Computations on these atoms will not be accurate off the grid, but since they are frozen the consequences are mitigated
CBackgroundMeshComposition	A class to hold the details of multiple BackgroundMesh objects taking the same molecular basis. It is termed a composition, not a synthesis, as it deals with multiple aspects of a single system (or multiple aspects of many snapshots of the same system), not a series of many systems
CBackgroundMeshReader	The templated, writeable abstract of a BackgroundMesh object
CBackgroundMeshWriter	The templated, writeable abstract of a BackgroundMesh object
CCacheResource	An object to hold temporary data for a particular work unit (whether bonded or non-bonded), resident in GMEM but private to a particular thread block. This object must be allocated in such a way as to be ready to hold the private workspaces of any thread blocks that will make use of it. The object is arranged to support operations based on PhaseSpaceSynthesis respresentations of systems' coordinates and forces
CCacheResourceKit	Abstract for the CacheResource object, accessible as a C-style struct and suitable for passing to GPU kernels as a kernel argument
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
CChemicalFeaturesReader	Abstract of the chemical features object: this is about as complex as an object with a single abstract should get
CClashReport	An object for listing the clashes between atoms of a system
CComboGraphLJModel	An object to manage the combination of Lennard-Jones parameters from two topologies. This can be used to insert "NBFix" pair-specific (off-rule) parameters where neither topology by itself might contain the requisite information. It can also be used to build parameter tables for a union of the two underlying topologies and produce arrays indices into that table for a new topology
CCondensate	Condense the data format, and possibly offer a reduced representation of coordinates, along with work units detailing which systems should be imported by each block on a given GPU
CCondensateReader	Read-only abstract for the Condensate class. In most cases, the read-only abstract will be preferred as modifications to coordinates should happen in the original synthesis object with its fixed precision arrays
CCondensateWriter	Writeable abstract for the Condensate class, wherein coordinates (only) can be modified as a consequence of certain analyses
CConstraintKit	Information needed to manage constraint groups. This additional abstract is needed due to the way that some collections of rigid bonds all connect to the same atom, and because analytic SETTLE constraints are a thing
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoordinateSeriesReader	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
CCoordinateSeriesWriter	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
CCoreKlManager	A class to guide the implementation of GPU kernels, with selected thread counts per block and block counts per launch grid for a specific GPU based on the workload. This object is constructed in a stepwise manner, with each kind of work unit contributing new launch specifications
Cdouble3
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CIsomerPlan	A shorthand form of a conformational degree of freedom, which could be a rotable bond, cis-trans invertible bond, or chiral center
CMdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
CMdlMolAtomList	An atom list entry (this object can be assembled either from one of the deprecated V2000 format lines after the bonds block, or from one of the "M ALS" properties)
CMdlMolBond	A bond, as presented in the MDL molecule file format. This unguarded struct will be returned to the developer from a private array inside of the MdlMolObj object, so further protection would be a hindrance
CMdlMolDataItem	Store a data item from within an SD file. Data items begin with a line of the form "> <ITEM_NAME>" (additional specifications are possible), end with a single blank line, and can contain customized format information. The information will be read as a series of raw strings, one per line and each representing a whole line. Once read, member functions of the class can extract specific integer, real, char4, or string coded data from within the item
CMdlMolDataRequest	A request for one of a sanctioned list of information types to be included in a data item of an SD file. When printing an SD file, MdlMolDataItem objects will be created based on these requests
CMdlMolProperty	A molecular or atomic property read from an MDL .mol or SDF file
CMeshBasicsKit	Abstract for the MeshFoundation object to encapsulate pointers to its data on the host or the device
CMeshFFKit	An object to store the probe's specific non-bonded parameters and softcore function coefficients used in mesh construction or mechanics
CMeshForceField	A class to hold the rules by which the system underlying a mesh object interacts with its surroundings. The mesh object itself may have one probe or an array of them (for an array of potential surfaces), but the constants, rules, and modifying potentials in this object will determine how those probes interact with the underlying system
CMeshFoundation	A small object to hold the essential descriptors of the molecule
CMeshKlManager	Collect and dispense the launch parameters for various mesh-based kernels. The launches for these kernels will generally take place in the context of a BackgroundMesh object, whether during its construction or for its application
CMeshParameters	Encode the critical dimensions of a regular, rectilinear mesh. The locations of mesh points as well as spacings are stored as fixed-precision integers to ensure consistency and high performance on architectures with deficient 64-bit floating point arithmetic
CMeshParamKit	The abstract of a MeshParameters object is read-only (modify the original to get a new abstract if the dimensions change), but templated to prune the information present
CMeshRulerKit
CMeshRulers	A collection of coordinate vectors describing each axis of a mesh. If the mesh axes track Cartesian axes, then all member variables but a_line_x, b_line_y, and c_line_z plus their overflow arrays will be zero
CMolObjSTextGroup	An SText group from an MDL MOL (.mol) or SDF file. This information is used only by old ISIS / Desktop programs and is otherwise deprecated
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CPairLJInteraction	A struct to encode two atom types and the Lennard-Jones parameters by which they interact
CPdb
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CPsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CPsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CReportControls	Collect output directives relating to the diagnostics file. While the output frequency is controlled by another namelist such as &minimize or &dynamics, STORMM is designed to handle many trajectories and thus the user is faced with a choice of what information to present and in what format
CRestraintApparatus	A collection of all restraints pertaining to a specific topology for the purposes of one simulation, energy minimization, or even a single molecular mechanics calculation
CRMSDPlan	Collect instructions for one or more systems (intend to work with any coordinate object, including the PhaseSpaceSynthesis)
CRMSDPlanReader	Read-only abstract for the RMSDPlan object, containing pointers to various buckets of atom indices
CScoreCard	Track the energy components of a collection of systems in an HPC-capable array. This object uses the familiar trick of defining an enumerator (StateVariables) with a final entry to indicate its total length, so that if more energy components need to be tracked in the future the storage and indexing can automatically adjust with new entries
CStaticExclusionMask	A simple pair list for an all-to-all calculation with exclusion masks. The list stores masks for 16 x 16 tiles of atoms indexed according to the atom order in some original topology. Each 16 x 16 tile mask will store the exclusions of 16 sending and 16 receiving atoms in the low 16 bits of an unsigned integer (probably 32-bit, but 16-bit format is also acceptable). The 16 x 16 tile masks are, in turn, arranged in groups of 16 x 16 such that each group of tiles covers the interactions of two consecutive sequences of 256 atoms apiece, for a total of 65,536 unique bits in 32kB (which counts the wasted high bits in each sending atom's mask as well as the reserved nature of the second sixteen bits). Many groups will have no exclusions at all, and these will all index into the first group stored in a master list. In this manner, a system of N atoms can have a complete pairlist constructed with ((N + 255) / 256)^2 super-tiles, with a storage requirement growing as N^2 but with a very small prefactor. With further hierarchical ordering, the pair list could even become O(N log N) in storage requirements. In the present scheme, simple pair lists can be built for very large systems if the exclusions are not spread throughout: a system of 131072 atoms with exclusions only between atoms +/-255 indices from one another would have space requirements of at most 52MB, probably much less. It is far better than the 2GB which would be required to store every exclusion as a unique bit
CStaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
CSyAtomUpdateKit	Collect the virtual site details and constraint parameters of the topology synthesis into a single abstract. This is designed to work in the context of the valence work units from the same topology synthesis, whether in a standalone function or as an extra step in a workflow that compute valence interactions and then moves particles
CSyNonbondedKit	Collect the critical non-bonded parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis. Compared to the abstracts for a single system's AtomGraph, this merges the ImplicitSolventKit and NonbondedKit. For comparison, the SyValenceKit object merges the information for valence interactions, constraints, and virtual sites abstracts from the single topology's set of abstracts
CSynthesisCacheMap	Encode a map between the systems of a snythesis and those of a SystemCache. The synthesis is expected to replicate the systems present in the cache, perhaps in a different order, perhaps to varying degrees for each system
CSynthesisMapReader	A set of pointers to critical arrays in the map below
CSystemCache	Simple but central struct to store the primitive form of the collection of systems that most STORMM applications will work with. There are topologies, coordinate sets, and a list of indices to indicate how they mix and match. This object exists on the CPU and in host memory only, but the topology and coordinate contents have CUDA-capable memory components
CSyValenceKit	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CTricubicCell	One element of a three-dimensional, space-filling tile representing a three-dimensional function to be interpolated by a tricubic spline
CTricubicStencil	A bundle of a 64 x 64 matrix, encoding the transformation of function values and derivatives at a stencil of points inside a tricubic mesh element into coefficients for that mesh element expressing the interpolated tricubic function. The type of stencil is also indicated, to keep this information coupled
CTriposMol	The Tripos mol2 format, as annotated in the mol2 .pdf document found within this source directory
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
CVirtualSiteKit	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
►Nsynthesis
CApprox	Class for handling comparisons of floating-point results versus expected values in unit tests. The general form is to take a vector of real numbers and apply the comparison across all entries
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CBrickwork	This class will subdivide a series of simulatiion boxes, whose lengths are whole numbers on all sides, into a set of partitions which keep to specified limits and cover the entire space in a number of rectangular partitions as close as possible to a specified number. The partitions can be ordered by size
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
CClashReport	An object for listing the clashes between atoms of a system
CClusterManager	An object to track the clusters into which a set of data points can be sorted
CCmapAccessories	Unguarded struct to hold refined quantities associated with CMAP objects
CCondensate	Condense the data format, and possibly offer a reduced representation of coordinates, along with work units detailing which systems should be imported by each block on a given GPU
CCondensateBorders	A read-only abstract for the system demarcations in the object. This information is sometimes critical, and needed on the CPU host even as the general abstract is needed on the GPU device
CCondensateReader	Read-only abstract for the Condensate class. In most cases, the read-only abstract will be preferred as modifications to coordinates should happen in the original synthesis object with its fixed precision arrays
CCondensateWriter	Writeable abstract for the Condensate class, wherein coordinates (only) can be modified as a consequence of certain analyses
CConformerControls	Class to encapsulate the data that can be extracted from the &conformer namelist
CConstraintKit	Information needed to manage constraint groups. This additional abstract is needed due to the way that some collections of rigid bonds all connect to the same atom, and because analytic SETTLE constraints are a thing
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoordinateSeriesReader	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
CCoordinateSeriesWriter	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
CCoupledEdit	A pairing of some process (a ConformationEdit, being a rotation about a bond, flipping groups across an isomeric cis-trans bond, or inversion of a chiral center) with an integer index to indicate its association with some list or group. This struct serves the SynthesisPermutor (see synthesis_permutor.h and the synthesis namespace) as well as the IsomerPlan object (see above). In Hybrid objects, it is transmutable with int2
CDynamicsControls	Object to encapsulate molecular dynamics control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CFilesControls	Distill the results of file identification, producing clean lists of free topologies, free coordinate files, and linked topology / coordinate systems. Record output and trajectory files, if available
CForwardExclusionMask	This exclusion mask relies on the reality that, in most topologies, the bulk of one atom's exclusions will be found within the next 32 atoms listed in the topology. If an atom excludes other atoms beyond this range, a separate index records the position at which this happens and provides either an index into a list of additional atoms or, if possible, the index of one other reference index in the topology followed by a second mask of 32 atoms which indicate exclusions relative to the reference index. To keep the list as compact as possible, the exclusion mask only considers "forward" exclusions, meaning excluded atoms with higher index than the one for which the mask is made. There is no double-counting: if atom 1 excludes atom 5, then atom 5 does not note an exclusion of atom 1
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CImplicitSolventKit	Information needed for Generalized Born (and perhaps other) implicit solvent methods. This information is collected into an object separate from the non-bonded kit because only a subset of calculations will use GB for the solvent conditions
CImplicitSolventWorkspace	A small collection of arrays to manage temporary accumulators for computing Born radii and their derivatives
CIsomerPlan	A shorthand form of a conformational degree of freedom, which could be a rotable bond, cis-trans invertible bond, or chiral center
CISWorkspaceKit	A simple abstract for the implicit solvent workspace. There are not readers and writers as the only useful application involves this workspace being writeable
CMdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
CMoleculeSystem	Object to encapsulate a system, a coupled set of coordinates and a single topology. This can be used to enforce conf.stormm to read certain coordinates in the context of a particular topology, even when other viable topologies might be available
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CNonbondedWorkUnit	Collect a series of tiles for non-bonded computations as well as the required atom imports to carry them out. This will accomplish the task of planning the non-bonded computation, given a single topology or a synthesis of topologies, to optimize the thread utilization on a GPU
CPdb
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
CPsSynthesisBorders	A read-only abstract for the system demarcations in the object. This information is sometimes critical, and needed on the CPU host even as the general abstract is needed on the GPU device
CPsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CPsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CReductionWorkUnit	A work unit to describe the manner in which groups of atoms in each structure of a synthesis come together to contribute to a single result. Reduction work units serve one and only one system apiece. The maximum size of these work units can be specified when they are created, in a manner analogous to valence or non-bonded work units, but is not limited by space in the GPU L1 cache so that, for practical optimizations, gather and scatter operations can be combined into all-reduce operations with a single kernel launch
CRestraintApparatus	A collection of all restraints pertaining to a specific topology for the purposes of one simulation, energy minimization, or even a single molecular mechanics calculation
CRestraintControls	Object to encapsulate and dispense restraint information collected from a single &restraint namelist
CRestraintKit	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
CScoreCard	Track the energy components of a collection of systems in an HPC-capable array. This object uses the familiar trick of defining an enumerator (StateVariables) with a final entry to indicate its total length, so that if more energy components need to be tracked in the future the storage and indexing can automatically adjust with new entries
CSeMaskSynthesisReader	The read-only abstract for a static exclusion mask compilation. This provides access in a similar format to the static exclusion mask reader for a single system
CStaticExclusionMask	A simple pair list for an all-to-all calculation with exclusion masks. The list stores masks for 16 x 16 tiles of atoms indexed according to the atom order in some original topology. Each 16 x 16 tile mask will store the exclusions of 16 sending and 16 receiving atoms in the low 16 bits of an unsigned integer (probably 32-bit, but 16-bit format is also acceptable). The 16 x 16 tile masks are, in turn, arranged in groups of 16 x 16 such that each group of tiles covers the interactions of two consecutive sequences of 256 atoms apiece, for a total of 65,536 unique bits in 32kB (which counts the wasted high bits in each sending atom's mask as well as the reserved nature of the second sixteen bits). Many groups will have no exclusions at all, and these will all index into the first group stored in a master list. In this manner, a system of N atoms can have a complete pairlist constructed with ((N + 255) / 256)^2 super-tiles, with a storage requirement growing as N^2 but with a very small prefactor. With further hierarchical ordering, the pair list could even become O(N log N) in storage requirements. In the present scheme, simple pair lists can be built for very large systems if the exclusions are not spread throughout: a system of 131072 atoms with exclusions only between atoms +/-255 indices from one another would have space requirements of at most 52MB, probably much less. It is far better than the 2GB which would be required to store every exclusion as a unique bit
CStaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
CStaticExclusionMaskSynthesis	An exclusion mask object for a compilation of systems. All systems are represented in full detail, and a series of systems using the same topology will each get their own entries in the supertile map indices array, filtering on down to tile indices and the unique mask data
CStopWatch	Object for managing calls to the C-standard function gettimeofday(), calculating deltas and categorizing time spent according to a developer's wishes. Calls to gettimeofday() are precise to microseconds, and take considerably less time than that. With the option to lookup a section by numerical index, the timing can have no impact whatsoever on any serious computation, and even lookup by section name is relatively fast thanks to the findStringInVector() function. The relative time can be computed in a number of ways, so that the timer can be called less frequently but not accrue all of the time since it last sampled the computation
CSyAtomUpdateKit	Collect the virtual site details and constraint parameters of the topology synthesis into a single abstract. This is designed to work in the context of the valence work units from the same topology synthesis, whether in a standalone function or as an extra step in a workflow that compute valence interactions and then moves particles
CSyNonbondedKit	Collect the critical non-bonded parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis. Compared to the abstracts for a single system's AtomGraph, this merges the ImplicitSolventKit and NonbondedKit. For comparison, the SyValenceKit object merges the information for valence interactions, constraints, and virtual sites abstracts from the single topology's set of abstracts
CSynthesisCacheMap	Encode a map between the systems of a snythesis and those of a SystemCache. The synthesis is expected to replicate the systems present in the cache, perhaps in a different order, perhaps to varying degrees for each system
CSynthesisMapReader	A set of pointers to critical arrays in the map below
CSynthesisPermutor	An object for tracking the states and The object itself stores a series of permutor maps, detailing the atoms that move as a consequence of rotating about some bond or inverting a chiral center. One such map is kept for each unique topology, and the atom indices of a particular system are then obtained by adding the atom offset from the PhaseSpaceSynthesis, Condensate, or AtomGraphSynthesis
CSyPermutorKit	Read-only abstract for the SynthesisPermutor. Access to all of the atom groups, critical measurements, and settings for mutable components is contained herein
CSyRestraintKit	Collect the critical restraint parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CSystemCache	Simple but central struct to store the primitive form of the collection of systems that most STORMM applications will work with. There are topologies, coordinate sets, and a list of indices to indicate how they mix and match. This object exists on the CPU and in host memory only, but the topology and coordinate contents have CUDA-capable memory components
CSyValenceKit	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTickCounter	Make an array of integral settings and tick it forward (or backward). The analogy is a series of wheels A - N, each with n_A, n_B, ... , n_N settings. With each tick, the lowest wheel (position 0 of the array) advances one tick. When each wheel completes one revolution, it triggers an advance of the next wheel. This collapses to a simple base-K counting system for a series of wheels with equal numbers of K settings apiece
CValenceDelegator	Object to track how different valence terms in a topology are delegated. Valence work units may evaluate a valence term without being responsible for moving both atoms, or even for moving any of the atoms at all. Each valence term is only fully delegated once valence work units that evaluate it are responsible for moving all atoms that the valence term contains. In order for a work unit to move any atom, it must evaluate all valence terms that include that atom
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
CValenceWorkUnit	An object to collect the components of a valence work unit (which will also track frozen atoms to implement coordinate updates, velocity updates, and constraints). While the work unit is encoded in the AtomGraphSynthesis object, the assembly is best done by a dedicated object with plenty of its own methods operating on a single topology (AtomGraph). All systems in the AtomGraphSynthesis are designed to function independently of one another–the only difference is that they have consensus tables of most parameters and differen atom indexing. Translating a valence work unit into a list of instructions within an AtomGraphSynthesis is therefore a critical member function of this class
CVirtualSiteKit	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
CVolumePartition	Define one volume of whole-numbered side lengths within a larger unit cell, which itself is part of a synthesis of many systems
CXoshiro256ppGenerator	The "Xoshiro256++" random number generator. While not cryptographically useful, it is a rock-solid random number generator for both floating-point and 64-bit integer results
►Ntesting
CApprox	Class for handling comparisons of floating-point results versus expected values in unit tests. The general form is to take a vector of real numbers and apply the comparison across all entries
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CCheckList	Object for storing a series of test results, with labels
CCommandLineParser	A class for collecting command line information. The class object will function somewhat like a namelist in that it gets loaded with keywords and can return the help messages for its contents upon receiving such a directive, but unlike namelists this one object is designed to be reconfigured for specific programs (even test programs, when it appears nested within the TestEnvironment class)
CCondensate	Condense the data format, and possibly offer a reduced representation of coordinates, along with work units detailing which systems should be imported by each block on a given GPU
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoordinateSeriesWriter	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
Cdouble2
CDynamicsControls	Object to encapsulate molecular dynamics control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CFilesControls	Distill the results of file identification, producing clean lists of free topologies, free coordinate files, and linked topology / coordinate systems. Record output and trajectory files, if available
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CMdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
CNamelistEmulator	Collection of variables to transcribe information contained within a namelist
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CPsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CStopWatch	Object for managing calls to the C-standard function gettimeofday(), calculating deltas and categorizing time spent according to a developer's wishes. Calls to gettimeofday() are precise to microseconds, and take considerably less time than that. With the option to lookup a section by numerical index, the timing can have no impact whatsoever on any serious computation, and even lookup by section name is relatively fast thanks to the findStringInVector() function. The relative time can be computed in a number of ways, so that the timer can be called less frequently but not accrue all of the time since it last sampled the computation
CSystemCache	Simple but central struct to store the primitive form of the collection of systems that most STORMM applications will work with. There are topologies, coordinate sets, and a list of indices to indicate how they mix and match. This object exists on the CPU and in host memory only, but the topology and coordinate contents have CUDA-capable memory components
CTestEnvironment	Object for parsing as well as storing environment and command-line input relevant to unit testing (Test Driven Development) in STORMM. Environment variables will be sought, but command-line inputs addressing the same information will take precedence
CTestSystemManager	Provide the means to read a series of topology and coordinate files, then organize them into corresponding lists of AtomGraph and PhaseSpace objects. The object can also export coordinates in other formats. Error checking is provided to abort the (test) program or issue a warning, and the object can signal whether dependent tests should be run or aborted
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CTextGuard	Structure for specifying the features of a comment in some text file
CXoshiro256ppGenerator	The "Xoshiro256++" random number generator. While not cryptographically useful, it is a rock-solid random number generator for both floating-point and 64-bit integer results
►Ntopology
CAngleTerm	Unguarded struct to store the ingredients of a single bond angle interaction
CApprox	Class for handling comparisons of floating-point results versus expected values in unit tests. The general form is to take a vector of real numbers and apply the comparison across all entries
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphStage	The topology stage is a CPU–bound object composed of Standard Template Library vectors for its data arrays, with each member corresponding to a (probably eponymous) member of the AtomGraph class. This object allows a topology to be built atom by atom, deconstructed, rebuilt, and even exported to a (much less mutable) AtomGraph
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CAttenuatedPair	Unguarded struct to handle 1:4 attenuated interactions that are not explicitly handled by the short-ranged non-bond scaling parameters of some dihedral linking the atoms
CAttenuationParameterSet	Unguarded struct to stage 1:4 exclusion screening terms. This will translate a series of unique dihedral parameter sets, containing 1:4 scaling parameters for every dihedral, into collections of unique 1:4 scaling parameters (screening factors) and a list of indices that each diehdral can follow in order to access their factors from within these parameter collections. Scaling parameters of zero are an obligatory, unique member of these collections. This arrangement sets up for force computation in which each dihedral references four cached atoms, then a set of cached parameters for its cosine form, then a pair of cached screening terms for the 1:4 interactions of its I and L atoms
CBasicValenceTable	Unguarded struct to assemble the basic bond, angle, and dihedral indexing from an Amber or other topology file. All Class I force fields will have, or could have, terms like these. All descriptions follow from the eponymous member variables in an AtomGraph
CBondTerm	Unguarded struct to store the ingredients of a single bond stretching interaction
CCharmmImprTerm	Unguarded struct to store the ingredients of a single CHARMM improper dihedral
CCharmmValenceTable	Unguarded struct to assemble special "CHARMM" force field terms read from an Amber or other topology file. These include Urey-Bradley harmonic angle terms, CHARMM improper harmonic dihedrals, and CMAP terms. All descriptions follow from the eponymous member variables in an AtomGraph
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CCitation	A means for numbering and tracking citations or other documented sources of information
CCmapAccessories	Unguarded struct to hold refined quantities associated with CMAP objects
CCmapSurfaceUnion	A class to merge two sets of CMAP surfaces. While the AtomGraphSynthesis has a means for doing this, it is more advanced and fits in the context of a different data structure. Similar ideas will be applied in the limited case of finding the union of two parameter sets
CCmapTerm	Unguarded struct to store the ingredients of a single CMAP interaction
CComboGraphLJModel	An object to manage the combination of Lennard-Jones parameters from two topologies. This can be used to insert "NBFix" pair-specific (off-rule) parameters where neither topology by itself might contain the requisite information. It can also be used to build parameter tables for a union of the two underlying topologies and produce arrays indices into that table for a new topology
CCondensedExclusions	Unguarded struct to condense the atom exclusion lists read from an Amber topology. This will transform the list of exclusion counts into an capped prefix sum (an exclusive prefix sum in indices 0...N-1, or an inclusive prefix sum in indices 1...N). Any atoms with no actual exclusions will be listed as having zero exclusions, and blank atoms will be removed from the excluded atoms list
CConstraintKit	Information needed to manage constraint groups. This additional abstract is needed due to the way that some collections of rigid bonds all connect to the same atom, and because analytic SETTLE constraints are a thing
CConstraintTable	Unguarded struct to hold the results of a constraint analysis. Constraint groups as well as fast, rigid waters will be selected. All atoms that might participate in constraints will be selected and drawn into groups; whether those groups are applied is a matter for input parameters to decide further on in the program
CDihedralTerm	Unguarded struct to store the ingredients of a single dihedral (proper or improper) torsion interaction. The trefoil improper torsion scheme used by OpenMM is implemented by applying multiple improper dihedrals of the Amber format, where the third atom is taken to be the central atom
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CImplicitSolventKit	Information needed for Generalized Born (and perhaps other) implicit solvent methods. This information is collected into an object separate from the non-bonded kit because only a subset of calculations will use GB for the solvent conditions
CLennardJonesAnalysis	A class to sort and hold details of a topology's Lennard-Jones interactions. The Lennard-Jones table is parsed for a combining rule, tables of sigma and epsilon parameters for self-interactions are kept, and a list of pair-specific sigma and epsilon parameters are stored according to the type indices they modify
CMap1234	Another unguarded class to help in the construction of an AtomGraph's categorized non-bonded exclusion lists
CMdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
CNonbondedKit	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
CPairLJInteraction	A struct to encode two atom types and the Lennard-Jones parameters by which they interact
CParameterUnion	A class for tracking the correspondence of two parameter sets. The parameter sets must be defined as a series of arrays with a 1:1 index mapping among them (i.e. contents of the kth indices of the first, second, and third arrays define the kth parameter set)
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CScreeningFactorTag	A struct to encode the non-bonded atom types in a dihedral and associated electrostatic and van-der Waals 1:4 interactions
CSettleParm	Encapsulate the six derived parameters for SETTLE computations. A vector of these structs will be accumulated into a ConstraintTable for any given topology, enumerating each distinct SETTLE-suitable molecule. In GPU implementations the information will be held by two- and four-tuples
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CUreyBradleyTerm	Unguarded struct to store the ingredients of a single Urey-Bradley interaction
CValenceKit	Information need for bonded calculations. Templating is used to serve either of two levels of precision: single (which, on almost any machine and HPC accelerator card, will be fp32) or double (fp64). Parameters for bonds, the highest frequency terms in any system by a factor of roughly 5, will always be stored in double precision, as will parameters for bond angles, the next highest frequency group of terms. The precision of other parameters varies according to the template parameter
CVirtualSiteKit	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
CVirtualSiteTable	Unguarded struct to collect information about virtual sites in the topology
►Ntrajectory
CApprox	Class for handling comparisons of floating-point results versus expected values in unit tests. The general form is to take a vector of real numbers and apply the comparison across all entries
CAtomGraph	A struct to hold information relating to an Amber topology. This struct's member functions are limited to getters for its private data. Because the primary means of constructing a topology will be complex, i.e. meticulous parsing of a file or expansion of an existing topology based on some new information, the constructors will need to be buried within wrapper functions that perform such procedures. This struct contains all information contained within an Amber prmtop-format file, nothng more, as described on:
CAtomGraphSynthesis	A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays (often padded by the GPU warp size to prevent one system from flowing into another). Work units covering all systems are laid out in additional, contiguous arrays. While individual topologies (AtomGraphs) have Hybrid POINTER-kind objects for details such as charges and atom type indices and all of the POINTER-kind objects targeted a single ARRAY-kind object of the correct memory type, the synthesis, which may have many topologies and a great deal more overall information, stores most of its data in a series of ARRAY-kind objects, one for each member variable
CBarostat	Store the parameters for a simulation barostat. Includes Monte-Carlo and Berendesen barostats with atomic virials
CCacheResource	An object to hold temporary data for a particular work unit (whether bonded or non-bonded), resident in GMEM but private to a particular thread block. This object must be allocated in such a way as to be ready to hold the private workspaces of any thread blocks that will make use of it. The object is arranged to support operations based on PhaseSpaceSynthesis respresentations of systems' coordinates and forces
CCacheResourceKit	Abstract for the CacheResource object, accessible as a C-style struct and suitable for passing to GPU kernels as a kernel argument
CCellGrid	An object to manage the spatial decomposition of a system of particles. The general strategy is to arrange particles in a grid of cells, each at least half the direct-space cutoff in width in all directions. A work unit entails computing all interactions assigned to one of the cells. This is done using a neutral-territory decomposition the lines of the "tower-plate" arrangement, which consists of seventeen cells:
CCellGridReader	Read-only abstract for the CellGrid object. This is unused in typical MD applications, when it is always the case that the cell grid positions and atom content are being updated or forces are being accumulated, but it may be useful when the cell grid is in demand strictly as a directory of which atoms are close to one another for building or detailing some other object. The associated workspace variables are not included in this form of the abstract
CChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
CCondensate	Condense the data format, and possibly offer a reduced representation of coordinates, along with work units detailing which systems should be imported by each block on a given GPU
CCondensateBorders	A read-only abstract for the system demarcations in the object. This information is sometimes critical, and needed on the CPU host even as the general abstract is needed on the GPU device
CCondensateReader	Read-only abstract for the Condensate class. In most cases, the read-only abstract will be preferred as modifications to coordinates should happen in the original synthesis object with its fixed precision arrays
CCondensateWriter	Writeable abstract for the Condensate class, wherein coordinates (only) can be modified as a consequence of certain analyses
CConstraintKit	Information needed to manage constraint groups. This additional abstract is needed due to the way that some collections of rigid bonds all connect to the same atom, and because analytic SETTLE constraints are a thing
CCoordinateFrame	Store the coordinates and box information for a frame, only. This abridged struct can serve when the full PhaseSpace object would allocate too much memory. It also comes with its own POINTER mode, such that it allocates no memory of its own and merely points to another CoordinateFrame object or PhaseSpace object that does have memory allocated
CCoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
CCoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
CCoordinateSeries	Store the coordinates and box information for a series of frames, in one of several levels of precision. Individual frames can be extracted into CoordinateFrame, and PhaseSpace, and PhaseSpaceSynthesis objects, or new frames can be added from CoordinateFrame objects. This object is not the CoordinateFrame equivalent of a PhaseSpaceSynthesis object, however: its purpose is to collect only the coordinates of many frames of a single system at the appropriate level of precision
CCoordinateSeriesReader	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
CCoordinateSeriesWriter	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
CCoordinateSwapPlan	Collect the information needed to swap the coordinates (and, if applicable, the box information) in a highly annotated block of ascii text
CCoreKlManager	A class to guide the implementation of GPU kernels, with selected thread counts per block and block counts per launch grid for a specific GPU based on the workload. This object is constructed in a stepwise manner, with each kind of work unit contributing new launch specifications
CDynamicsControls	Object to encapsulate molecular dynamics control information. Like other namelist encapsualtors, this object can take input file data as part of its construction, or by a series of setters. Validation of each piece of data is handled as it appears either in the contructor or via setters. Getter functions dispense the internal information to any application using STORMM libraries
CGpuDetails	Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ensure that one cache line will obtain all statistics for a single GPU
CHybrid	An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from either the GPU or the CPU. In unified mode, the two data are one insofar as the programmer sees it, and the page migration engine engaged by cudaMallocManaged handles the two physical memory spaces at a very low level. In other modes, composite memory must be uploaded or downloaded explicitly in order to maintain synchrony between host and device memory spaces. This struct mimics a lot of the most noteworthy behavior of std::vector, but with the potential to behave as a pointer as well. In this manner, it is intended to confer the convenience of C++ with the freedom of classic C programming
CMMControlKit	The C-style, always writeable abstract for the MolecularMechanicsControls object. To not be able to modify this object's contents would be nonsensical, as it is intended to to keep counters of the simulation time step as well as force evaluation work units
CMolecularMechanicsControls	A collection of contol data for molecular mechanics simulations, conveying the current step number, progress counters through various work units, the time step, RATTLE tolerance, and other critical parameters to guide calculations. This common struct accommodates both molecular dynamics and molecular mechanics energy minimizations, and can be created from control objects derived from &dynamics or &minimize namelists
CMotionSweeper	Object to manage and stage recentering and momentum removal for a coordinate synthesis. The object does not support asynchronous work unit scheduling but does contain two alternating sets of accumulators so that one set can be initialized when the other is in use
CMotionSweepReader	Read-only abstract of the MotionSweeper class, below, with const pointers to non-modifiable data
CMotionSweepWriter	Abstract of the MotionSweeper class, below, with non-const pointers to modifiable data
CPdb
CPhaseSpace	An object to complement a topology and hold positions, velocities, and forces of all particles in a system. This is not designed to be the most performant representation of the system's structure. Rather, it serves to hold a high-precision representation of a single system and transport it between CPUs and high-performance accelerators
CPhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
CPhaseSpaceSynthesis	A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulations. The time steps are stored in units of femtoseconds. Coordinates are stored as long long integers to utilize the 32-bit int pipeline for difference computations, bypassing fp64 computations wherever possible to get the best throughput on many visualization, AI-oriented, and gaming cards
CPhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
CPolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
CPsSynthesisBorders	A read-only abstract for the system demarcations in the object. This information is sometimes critical, and needed on the CPU host even as the general abstract is needed on the GPU device
CPsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CPsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
CSyAtomUpdateKit	Collect the virtual site details and constraint parameters of the topology synthesis into a single abstract. This is designed to work in the context of the valence work units from the same topology synthesis, whether in a standalone function or as an extra step in a workflow that compute valence interactions and then moves particles
CSyNonbondedKit	Collect the critical non-bonded parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis. Compared to the abstracts for a single system's AtomGraph, this merges the ImplicitSolventKit and NonbondedKit. For comparison, the SyValenceKit object merges the information for valence interactions, constraints, and virtual sites abstracts from the single topology's set of abstracts
CSynthesisCacheMap	Encode a map between the systems of a snythesis and those of a SystemCache. The synthesis is expected to replicate the systems present in the cache, perhaps in a different order, perhaps to varying degrees for each system
CSystemCache	Simple but central struct to store the primitive form of the collection of systems that most STORMM applications will work with. There are topologies, coordinate sets, and a list of indices to indicate how they mix and match. This object exists on the CPU and in host memory only, but the topology and coordinate contents have CUDA-capable memory components
CSyValenceKit	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
CTextFile	Structure for translating a text file into a compact, rapidly parsable vector of characters in CPU RAM. The struct contains two nested struct definitions, for a Reader and a Writer. Private objects of these structs can then be accessed with eponymous data() getter functions, returning the appropriate kind of access depending on the const-ness of the TextFile object itself
CTextFileReader	Abstract for the TextFile object, providing read-only access
CThermostat	Store the parameters for a simulation thermostat. Includes Berendsen, Andersen, and Langevin methods. This class can be assembled like many of the control objects, i.e. MinimizationControls, based on namelists
CThermostatReader	Read-only abstract for the Thermostat object
CThermostatWriter	Partially writeable abstract for the Thermostat object. As with the MMControlKit struct (see the library header mm_controls.h), the step member variable is modifiable so that it can be updated without setting it in the parent object and regenerating the entire abstract
CValidCoordinateTypes	A simple list of all the valid type specifiers for coordinate data. This will be filled at runtime based on the type IDs found (see DataTypes/common_types.h)
CXoshiro256ppGenerator	The "Xoshiro256++" random number generator. While not cryptographically useful, it is a rock-solid random number generator for both floating-point and 64-bit integer results
Cchar2
Cchar3
Cchar4
CCombineIDp	A combination of integer and double data. Like other mixed tuples in this library, this will maintain the x, y, z, and w member variable naming conventions
Cdouble2
Cdouble3
Cdouble4
CEcumenical2	Mimic critical CUDA typecasting intrinsics with simple unions {
CEcumenical4
CEcumenical8
Cfloat2
Cfloat3
Cfloat4
Cint2
Cint3
Cint4
Cint95_t	A mixed tuple for 95-bit integer accumulation. This is the proper way to take double-precision floating point arithmetic into fixed precision format with minimal loss
Clonglong2
Clonglong3
Clonglong4
Cshort2
Cshort3
Cshort4
Cuchar2
Cuchar3
Cuchar4
Cuint2
Cuint3
Cuint4
Culonglong2
Culonglong3
Culonglong4
Cushort2
Cushort3
Cushort4
CValueWithCounter	Templated, combined type for tagging any data type with an associated integer count
CVec2	A template-compatible class for implementing vectorized two-tuples in C++ code, based on a single scalar type
CVec3	A template-compatible class for implementing vectorized three-tuples in C++ code, based on a single scalar type
CVec4	A template-compatible class for implementing vectorized four-tuples in C++ code, based on a single scalar type