Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12]

Cstormm::topology::AngleTerm< T >	Unguarded struct to store the ingredients of a single bond angle interaction
Cstormm::chemistry::Approx	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
Cstormm::stmath::Approx	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
Cstormm::synthesis::Approx	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
Cstormm::testing::Approx	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
Cstormm::topology::Approx	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
Cstormm::trajectory::Approx	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
Cstormm::chemistry::AtomEquivalence	Collect the set of symmetry-related and interchangeable groups for one or more molecules within a topology
Cstormm::structure::AtomEquivalence	Collect the set of symmetry-related and interchangeable groups for one or more molecules within a topology
Cstormm::chemistry::AtomGraph	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:
Cstormm::data_types::AtomGraph	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:
Cstormm::energy::AtomGraph	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:
Cstormm::mm::AtomGraph	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:
Cstormm::modeling::AtomGraph	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:
Cstormm::namelist::AtomGraph	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:
Cstormm::restraints::AtomGraph	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:
Cstormm::review::AtomGraph	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:
Cstormm::structure::AtomGraph	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:
Cstormm::synthesis::AtomGraph	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:
Cstormm::testing::AtomGraph	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:
Cstormm::topology::AtomGraph	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:
Cstormm::trajectory::AtomGraph	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:
Cstormm::topology::AtomGraphStage	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
Cstormm::card::AtomGraphSynthesis	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
Cstormm::energy::AtomGraphSynthesis	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
Cstormm::mm::AtomGraphSynthesis	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
Cstormm::review::AtomGraphSynthesis	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
Cstormm::stmath::AtomGraphSynthesis	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
Cstormm::structure::AtomGraphSynthesis	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
Cstormm::synthesis::AtomGraphSynthesis	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
Cstormm::testing::AtomGraphSynthesis	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
Cstormm::topology::AtomGraphSynthesis	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
Cstormm::trajectory::AtomGraphSynthesis	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
Cstormm::chemistry::AtomMask	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
Cstormm::namelist::AtomMask	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
Cstormm::restraints::AtomMask	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
Cstormm::structure::AtomMask	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
Cstormm::chemistry::AtomRank	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
Cstormm::topology::AttenuatedPair	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
Cstormm::topology::AttenuationParameterSet	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
Cstormm::review::BackgroundMesh< T >	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
Cstormm::structure::BackgroundMesh< T >	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
Cstormm::structure::BackgroundMeshComposition< T >	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
Cstormm::review::BackgroundMeshReader< Tdata >	The templated, writeable abstract of a BackgroundMesh object
Cstormm::structure::BackgroundMeshReader< Tdata >	The templated, writeable abstract of a BackgroundMesh object
Cstormm::structure::BackgroundMeshWriter< Tdata >	The templated, writeable abstract of a BackgroundMesh object
Cstormm::trajectory::Barostat	Store the parameters for a simulation barostat. Includes Monte-Carlo and Berendesen barostats with atomic virials
Cstormm::topology::BasicValenceTable	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
Cstormm::diskutil::BinaryFileContent
Cstormm::diskutil::BinaryFileKey	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
Cstormm::chemistry::BondedNode	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
Cstormm::topology::BondTerm< T >	Unguarded struct to store the ingredients of a single bond stretching interaction
Cstormm::namelist::BoundedRestraint
Cstormm::restraints::BoundedRestraint
Cstormm::energy::Brickwork	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
Cstormm::synthesis::Brickwork	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
Cstormm::energy::CacheResource	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
Cstormm::mm::CacheResource	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
Cstormm::structure::CacheResource	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
Cstormm::trajectory::CacheResource	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
Cstormm::energy::CacheResourceKit< T >	Abstract for the CacheResource object, accessible as a C-style struct and suitable for passing to GPU kernels as a kernel argument
Cstormm::structure::CacheResourceKit< T >	Abstract for the CacheResource object, accessible as a C-style struct and suitable for passing to GPU kernels as a kernel argument
Cstormm::trajectory::CacheResourceKit< T >	Abstract for the CacheResource object, accessible as a C-style struct and suitable for passing to GPU kernels as a kernel argument
Cstormm::energy::CellGrid< T, Tacc, Tcalc, T4 >	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:
Cstormm::mm::CellGrid< T, Tacc, Tcalc, T4 >	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:
Cstormm::trajectory::CellGrid< T, Tacc, Tcalc, T4 >	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:
Cstormm::energy::CellGridReader< T, Tacc, Tcalc, T4 >	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
Cstormm::mm::CellGridReader< T, Tacc, Tcalc, T4 >	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
Cstormm::trajectory::CellGridReader< T, Tacc, Tcalc, T4 >	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
Cstormm::energy::CellGridWriter< T, Tacc, Tcalc, T4 >	Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces
Cstormm::mm::CellGridWriter< T, Tacc, Tcalc, T4 >	Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces
Cstormm::energy::CellOriginsReader
Cstormm::energy::CellOriginsWriter
Cstormm::char2
Cstormm::data_types::char2
Cstormm::char3
Cstormm::data_types::char3
Cstormm::char4
Cstormm::data_types::char4
Cstormm::topology::CharmmImprTerm< T >	Unguarded struct to store the ingredients of a single CHARMM improper dihedral
Cstormm::topology::CharmmValenceTable	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
Cstormm::testing::CheckList	Object for storing a series of test results, with labels
Cstormm::chemistry::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::energy::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::mm::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::restraints::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::review::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::structure::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::synthesis::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::topology::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::trajectory::ChemicalDetailsKit	Information on atoms and residues which may be useful for applying atom masks or identifying specific parts of the sytem
Cstormm::chemistry::ChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
Cstormm::namelist::ChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
Cstormm::restraints::ChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
Cstormm::structure::ChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
Cstormm::synthesis::ChemicalFeatures	An object to store information about chemical motifs: participation in rings, planarity, chirality, aromaticity, conjugation, planarity, and bonds with different rotatability
Cstormm::chemistry::ChemicalFeaturesReader	Abstract of the chemical features object: this is about as complex as an object with a single abstract should get
Cstormm::structure::ChemicalFeaturesReader	Abstract of the chemical features object: this is about as complex as an object with a single abstract should get
Cstormm::parse::Citation	A means for numbering and tracking citations or other documented sources of information
Cstormm::topology::Citation	A means for numbering and tracking citations or other documented sources of information
Cstormm::structure::ClashReport	An object for listing the clashes between atoms of a system
Cstormm::synthesis::ClashReport	An object for listing the clashes between atoms of a system
Cstormm::stmath::ClusterManager< Tdata, Tcalc >	An object to track the clusters into which a set of data points can be sorted
Cstormm::synthesis::ClusterManager< Tdata, Tcalc >	An object to track the clusters into which a set of data points can be sorted
Cstormm::stmath::ClusterManagerKit< Tcalc >	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
Cstormm::synthesis::CmapAccessories	Unguarded struct to hold refined quantities associated with CMAP objects
Cstormm::topology::CmapAccessories	Unguarded struct to hold refined quantities associated with CMAP objects
Cstormm::topology::CmapSurfaceUnion	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
Cstormm::topology::CmapTerm< T >	Unguarded struct to store the ingredients of a single CMAP interaction
Cstormm::CombineIDp	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
Cstormm::data_types::CombineIDp	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
Cstormm::structure::ComboGraphLJModel	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
Cstormm::topology::ComboGraphLJModel	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
Cstormm::namelist::CommandLineParser	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)
Cstormm::testing::CommandLineParser	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)
Cstormm::chemistry::Condensate	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
Cstormm::stmath::Condensate	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
Cstormm::structure::Condensate	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
Cstormm::synthesis::Condensate	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
Cstormm::testing::Condensate	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
Cstormm::trajectory::Condensate	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
Cstormm::synthesis::CondensateBorders	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
Cstormm::trajectory::CondensateBorders	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
Cstormm::chemistry::CondensateReader	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
Cstormm::structure::CondensateReader	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
Cstormm::synthesis::CondensateReader	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
Cstormm::trajectory::CondensateReader	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
Cstormm::structure::CondensateWriter	Writeable abstract for the Condensate class, wherein coordinates (only) can be modified as a consequence of certain analyses
Cstormm::synthesis::CondensateWriter	Writeable abstract for the Condensate class, wherein coordinates (only) can be modified as a consequence of certain analyses
Cstormm::trajectory::CondensateWriter	Writeable abstract for the Condensate class, wherein coordinates (only) can be modified as a consequence of certain analyses
Cstormm::topology::CondensedExclusions	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
Cstormm::namelist::ConformerControls	Class to encapsulate the data that can be extracted from the &conformer namelist
Cstormm::synthesis::ConformerControls	Class to encapsulate the data that can be extracted from the &conformer namelist
Cstormm::stmath::ConjGradSubstrate	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
Cstormm::mm::ConstraintKit< T >	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
Cstormm::structure::ConstraintKit< T >	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
Cstormm::synthesis::ConstraintKit< T >	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
Cstormm::topology::ConstraintKit< T >	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
Cstormm::trajectory::ConstraintKit< T >	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
Cstormm::topology::ConstraintTable	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
Cstormm::energy::ConvolutionKit< T >	Any abstract of the convolution manager is read-only
Cstormm::energy::ConvolutionManager	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:
Cstormm::chemistry::CoordinateFrame	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
Cstormm::diskutil::CoordinateFrame	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
Cstormm::energy::CoordinateFrame	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
Cstormm::mm::CoordinateFrame	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
Cstormm::namelist::CoordinateFrame	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
Cstormm::review::CoordinateFrame	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
Cstormm::stmath::CoordinateFrame	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
Cstormm::structure::CoordinateFrame	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
Cstormm::synthesis::CoordinateFrame	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
Cstormm::testing::CoordinateFrame	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
Cstormm::trajectory::CoordinateFrame	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
Cstormm::chemistry::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::diskutil::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::energy::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::mm::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::namelist::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::restraints::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::review::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::structure::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::synthesis::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::trajectory::CoordinateFrameReader	Collect C-style pointers for the elements of a read-only CoordinateFrame object
Cstormm::energy::CoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
Cstormm::structure::CoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
Cstormm::synthesis::CoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
Cstormm::trajectory::CoordinateFrameWriter	Collect C-style pointers for the elements of a writable CoordinateFrame object
Cstormm::chemistry::CoordinateSeries< T >	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
Cstormm::diskutil::CoordinateSeries< T >	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
Cstormm::energy::CoordinateSeries< T >	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
Cstormm::review::CoordinateSeries< T >	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
Cstormm::stmath::CoordinateSeries< T >	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
Cstormm::structure::CoordinateSeries< T >	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
Cstormm::synthesis::CoordinateSeries< T >	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
Cstormm::testing::CoordinateSeries< T >	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
Cstormm::trajectory::CoordinateSeries< T >	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
Cstormm::chemistry::CoordinateSeriesReader< T >	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
Cstormm::energy::CoordinateSeriesReader< T >	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
Cstormm::review::CoordinateSeriesReader< T >	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
Cstormm::structure::CoordinateSeriesReader< T >	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
Cstormm::synthesis::CoordinateSeriesReader< T >	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
Cstormm::trajectory::CoordinateSeriesReader< T >	Collect C-style pointers and critical constants for a read-only CoordinateSeries object
Cstormm::energy::CoordinateSeriesWriter< T >	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
Cstormm::structure::CoordinateSeriesWriter< T >	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
Cstormm::synthesis::CoordinateSeriesWriter< T >	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
Cstormm::testing::CoordinateSeriesWriter< T >	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
Cstormm::trajectory::CoordinateSeriesWriter< T >	Collect C-style pointers and critical constants for a writeable CoordinateSeries object
Cstormm::trajectory::CoordinateSwapPlan	Collect the information needed to swap the coordinates (and, if applicable, the box information) in a highly annotated block of ascii text
Cstormm::chemistry::CoupledEdit	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
Cstormm::synthesis::CoupledEdit	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
Cstormm::docs::CppScope	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
Cstormm::topology::DihedralTerm< T >	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
Cstormm::data_types::double2
Cstormm::double2
Cstormm::testing::double2
Cstormm::data_types::double3
Cstormm::double3
Cstormm::structure::double3
Cstormm::data_types::double4
Cstormm::double4
Cstormm::mm::DynamicsControls	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
Cstormm::namelist::DynamicsControls	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
Cstormm::synthesis::DynamicsControls	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
Cstormm::testing::DynamicsControls	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
Cstormm::trajectory::DynamicsControls	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
Cstormm::data_types::Ecumenical2	Mimic critical CUDA typecasting intrinsics with simple unions {
Cstormm::Ecumenical2	Mimic critical CUDA typecasting intrinsics with simple unions {
Cstormm::data_types::Ecumenical4
Cstormm::Ecumenical4
Cstormm::data_types::Ecumenical8
Cstormm::Ecumenical8
Cstormm::namelist::FFMorphControls	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
Cstormm::namelist::FilesControls	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
Cstormm::review::FilesControls	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
Cstormm::synthesis::FilesControls	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
Cstormm::testing::FilesControls	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
Cstormm::restraints::FlatBottomPlan	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
Cstormm::data_types::float2
Cstormm::float2
Cstormm::data_types::float3
Cstormm::float3
Cstormm::data_types::float4
Cstormm::float4
Cstormm::modeling::ForceFieldElement	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
Cstormm::namelist::ForceFieldElement	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
Cstormm::energy::ForwardExclusionMask	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
Cstormm::synthesis::ForwardExclusionMask	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
Cstormm::energy::ForwardExclusionMaskReader	The abstract for the forward exclusion mask turns out to be shorter than that for the StaticExclusionMask
Cstormm::stmath::GenericRdSubstrate< T >	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)
Cstormm::card::GpuDetails	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
Cstormm::energy::GpuDetails	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
Cstormm::mm::GpuDetails	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
Cstormm::random::GpuDetails	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
Cstormm::stmath::GpuDetails	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
Cstormm::structure::GpuDetails	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
Cstormm::synthesis::GpuDetails	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
Cstormm::testing::GpuDetails	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
Cstormm::trajectory::GpuDetails	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
Cstormm::stmath::HilbertSFC	Draw a Hilbert space-filling curve
Cstormm::card::HpcConfig	Take an image of the available system hardware. One or more GPUs can be assigned to a thread based on this information
Cstormm::stmath::HpcMatrix< T >	A matrix object that can traverse CPU and GPU memory
Cstormm::card::Hybrid< T >	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
Cstormm::chemistry::Hybrid< T >	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
Cstormm::diskutil::Hybrid< T >	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
Cstormm::energy::Hybrid< T >	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
Cstormm::generalized_born_defaults::Hybrid< T >	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
Cstormm::mm::Hybrid< T >	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
Cstormm::numerics::Hybrid< T >	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
Cstormm::random::Hybrid< T >	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
Cstormm::restraints::Hybrid< T >	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
Cstormm::review::Hybrid< T >	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
Cstormm::stmath::Hybrid< T >	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
Cstormm::structure::Hybrid< T >	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
Cstormm::synthesis::Hybrid< T >	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
Cstormm::topology::Hybrid< T >	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
Cstormm::trajectory::Hybrid< T >	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
Cstormm::card::HybridLabel	A Hybrid object's immutable identifying information, stored as a const member variable within the Hybrid object itself
Cstormm::stmath::HybridLabel	A Hybrid object's immutable identifying information, stored as a const member variable within the Hybrid object itself
Cstormm::energy::ImplicitSolventKit< T >	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
Cstormm::mm::ImplicitSolventKit< T >	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
Cstormm::synthesis::ImplicitSolventKit< T >	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
Cstormm::topology::ImplicitSolventKit< T >	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
Cstormm::energy::ImplicitSolventRecipe< T >
Cstormm::energy::ImplicitSolventWorkspace	A small collection of arrays to manage temporary accumulators for computing Born radii and their derivatives
Cstormm::mm::ImplicitSolventWorkspace	A small collection of arrays to manage temporary accumulators for computing Born radii and their derivatives
Cstormm::synthesis::ImplicitSolventWorkspace	A small collection of arrays to manage temporary accumulators for computing Born radii and their derivatives
Cstormm::chemistry::IndigoAtomCenter	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
Cstormm::chemistry::IndigoFragment	A fragment of a structure detailed with the Indigo scoring function
Cstormm::chemistry::IndigoTable	Table of options and optimization targets for an Indigo formal charge and bond order assignment
Cstormm::card::int2
Cstormm::data_types::int2
Cstormm::int2
Cstormm::data_types::int3
Cstormm::int3
Cstormm::data_types::int4
Cstormm::int4
Cstormm::data_types::int95_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
Cstormm::int95_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
Cstormm::chemistry::IsomerPlan	A shorthand form of a conformational degree of freedom, which could be a rotable bond, cis-trans invertible bond, or chiral center
Cstormm::structure::IsomerPlan	A shorthand form of a conformational degree of freedom, which could be a rotable bond, cis-trans invertible bond, or chiral center
Cstormm::synthesis::IsomerPlan	A shorthand form of a conformational degree of freedom, which could be a rotable bond, cis-trans invertible bond, or chiral center
Cstormm::energy::ISWorkspaceKit< T >	A simple abstract for the implicit solvent workspace. There are not readers and writers as the only useful application involves this workspace being writeable
Cstormm::mm::ISWorkspaceKit< T >	A simple abstract for the implicit solvent workspace. There are not readers and writers as the only useful application involves this workspace being writeable
Cstormm::synthesis::ISWorkspaceKit< T >	A simple abstract for the implicit solvent workspace. There are not readers and writers as the only useful application involves this workspace being writeable
Cstormm::stmath::JfErfc	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."
Cstormm::card::KernelFormat	Encapsulate the operations to store and retrieve information about a kernel's format
►Cstormm::card::KernelManager	Parent class for other kernel managers, incorporating the common dictionary of kernel keys and GPU details
Cstormm::card::CoreKlManager	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
Cstormm::card::MeshKlManager	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
Cstormm::energy::LayeredPotential< T, T4 >	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
Cstormm::energy::LayeredPotentialMetrics	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
Cstormm::card::Ledger	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
Cstormm::card::LedgerEntry	Entries of the memory ledger recording not just a copy of the immutable type data but also allocation sizes and allocation states
Cstormm::topology::LennardJonesAnalysis	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
Cstormm::mm::LineMinimization	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
Cstormm::mm::LinMinReader	Abstract for the line minimization object incorporating write access
Cstormm::mm::LinMinWriter	Abstract for the line minimization object incorporating write access
Cstormm::energy::LocalExclusionMask	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
Cstormm::mm::LocalExclusionMask	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
Cstormm::energy::LocalExclusionMaskReader	A lean, read-only abstract for the LocalExclusionMask class
Cstormm::mm::LocalExclusionMaskReader	A lean, read-only abstract for the LocalExclusionMask class
Cstormm::energy::LogScaleSpline< T4 >	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
Cstormm::stmath::LogScaleSpline< T4 >	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
Cstormm::energy::LogSplineTable< T4 >	Abstract for the logarithmic splined function object, containing the table and critical constants for evaluating it
Cstormm::stmath::LogSplineTable< T4 >	Abstract for the logarithmic splined function object, containing the table and critical constants for evaluating it
Cstormm::data_types::longlong2
Cstormm::longlong2
Cstormm::data_types::longlong3
Cstormm::longlong3
Cstormm::data_types::longlong4
Cstormm::longlong4
Cstormm::topology::Map1234	Another unguarded class to help in the construction of an AtomGraph's categorized non-bonded exclusion lists
Cstormm::chemistry::MaskComponent	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
Cstormm::structure::MdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
Cstormm::synthesis::MdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
Cstormm::testing::MdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
Cstormm::topology::MdlMol	A molecular three-dimensional feature. This special class of MOL object properies has its own data lines
Cstormm::structure::MdlMolAtomList	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)
Cstormm::structure::MdlMolBond	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
Cstormm::structure::MdlMolDataItem	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
Cstormm::namelist::MdlMolDataRequest	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
Cstormm::structure::MdlMolDataRequest	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
Cstormm::structure::MdlMolProperty	A molecular or atomic property read from an MDL .mol or SDF file
Cstormm::structure::MeshBasicsKit	Abstract for the MeshFoundation object to encapsulate pointers to its data on the host or the device
Cstormm::namelist::MeshControls	Encapsulate the data extracted from a &receptor namelist to define a grid-mapped representation of a rigid macromolecular structure
Cstormm::review::MeshFFKit< T >	An object to store the probe's specific non-bonded parameters and softcore function coefficients used in mesh construction or mechanics
Cstormm::structure::MeshFFKit< T >	An object to store the probe's specific non-bonded parameters and softcore function coefficients used in mesh construction or mechanics
Cstormm::structure::MeshForceField< T >	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
Cstormm::review::MeshFoundation	A small object to hold the essential descriptors of the molecule
Cstormm::structure::MeshFoundation	A small object to hold the essential descriptors of the molecule
Cstormm::review::MeshParameters	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
Cstormm::structure::MeshParameters	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
Cstormm::review::MeshParamKit	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
Cstormm::structure::MeshParamKit	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
Cstormm::structure::MeshRulerKit
Cstormm::structure::MeshRulers	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
Cstormm::mm::MinimizeControls	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
Cstormm::namelist::MinimizeControls	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
Cstormm::energy::MMControlKit< T >	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
Cstormm::mm::MMControlKit< T >	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
Cstormm::stmath::MMControlKit< T >	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
Cstormm::trajectory::MMControlKit< T >	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
Cstormm::energy::MolecularMechanicsControls	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
Cstormm::mm::MolecularMechanicsControls	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
Cstormm::stmath::MolecularMechanicsControls	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
Cstormm::trajectory::MolecularMechanicsControls	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
Cstormm::namelist::MoleculeSystem	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
Cstormm::synthesis::MoleculeSystem	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
Cstormm::structure::MolObjSTextGroup	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
Cstormm::mm::MotionSweeper	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
Cstormm::trajectory::MotionSweeper	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
Cstormm::trajectory::MotionSweepReader	Read-only abstract of the MotionSweeper class, below, with const pointers to non-modifiable data
Cstormm::trajectory::MotionSweepWriter	Abstract of the MotionSweeper class, below, with non-const pointers to modifiable data
Cstormm::namelist::NamelistElement	One keyword found in a namelist, ready to store the namelist variable moniker, the type, and the value read from the input file
Cstormm::display::NamelistEmulator	Collection of variables to transcribe information contained within a namelist
Cstormm::namelist::NamelistEmulator	Collection of variables to transcribe information contained within a namelist
Cstormm::testing::NamelistEmulator	Collection of variables to transcribe information contained within a namelist
Cstormm::display::NamelistToken	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
Cstormm::namelist::NamelistToken	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
Cstormm::generalized_born_defaults::NeckGeneralizedBornKit< T >	Abstract for the NeckGeneralizedBornTable object, in single- or double-precision
Cstormm::generalized_born_defaults::NeckGeneralizedBornTable	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
Cstormm::namelist::NiceControls	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
Cstormm::chemistry::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::energy::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::mm::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::namelist::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::restraints::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::review::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::structure::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::synthesis::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::topology::NonbondedKit< T >	Information needed for non-bonded real-space calculations. Templating is used as above, to provide different levels of precision in the real number representation
Cstormm::synthesis::NonbondedWorkUnit	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
Cstormm::energy::NrgLayerKit< T4 >	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
Cstormm::docs::ObjectIdentifier	Stores data on instances of an object (i.e. a function or struct found in a given file
Cstormm::review::OrderedList	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
Cstormm::structure::PairLJInteraction	A struct to encode two atom types and the Lennard-Jones parameters by which they interact
Cstormm::topology::PairLJInteraction	A struct to encode two atom types and the Lennard-Jones parameters by which they interact
Cstormm::topology::ParameterUnion< T >	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)
Cstormm::structure::Pdb
Cstormm::synthesis::Pdb
Cstormm::trajectory::Pdb
Cstormm::chemistry::PhaseSpace	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
Cstormm::diskutil::PhaseSpace	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
Cstormm::energy::PhaseSpace	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
Cstormm::mm::PhaseSpace	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
Cstormm::namelist::PhaseSpace	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
Cstormm::stmath::PhaseSpace	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
Cstormm::structure::PhaseSpace	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
Cstormm::synthesis::PhaseSpace	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
Cstormm::testing::PhaseSpace	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
Cstormm::trajectory::PhaseSpace	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
Cstormm::chemistry::PhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
Cstormm::energy::PhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
Cstormm::mm::PhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
Cstormm::structure::PhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
Cstormm::synthesis::PhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
Cstormm::trajectory::PhaseSpaceReader	Collect constants and pointers to the components of a read-only PhaseSpace object
Cstormm::chemistry::PhaseSpaceSynthesis	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
Cstormm::diskutil::PhaseSpaceSynthesis	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
Cstormm::energy::PhaseSpaceSynthesis	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
Cstormm::mm::PhaseSpaceSynthesis	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
Cstormm::review::PhaseSpaceSynthesis	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
Cstormm::stmath::PhaseSpaceSynthesis	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
Cstormm::structure::PhaseSpaceSynthesis	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
Cstormm::synthesis::PhaseSpaceSynthesis	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
Cstormm::testing::PhaseSpaceSynthesis	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
Cstormm::trajectory::PhaseSpaceSynthesis	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
Cstormm::energy::PhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
Cstormm::mm::PhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
Cstormm::structure::PhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
Cstormm::synthesis::PhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
Cstormm::trajectory::PhaseSpaceWriter	Collect constants and pointers to the components of a modifiable PhaseSpace object
Cstormm::energy::PMIGrid	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
Cstormm::energy::PMIGridAccumulator	A writeable abstract which reinterprets some pointers to enable split fixed-precision accumulation within the PMIGrid object
Cstormm::energy::PMIGridFPReader	A read-only abstract which can interpret the PMIGrid data in split fixed-precision format
Cstormm::energy::PMIGridReader	A read-only abstract for the Particle-Mesh Interaction Grid class
Cstormm::energy::PMIGridWriter	A writeable abstract for the Particle-Mesh Interaction Grid class
Cstormm::card::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::numerics::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::parse::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::random::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::review::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::stmath::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::structure::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::testing::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::topology::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::trajectory::PolyNumeric	Union for storing numbers or other 4-8 byte pieces of information
Cstormm::energy::PPIeKit< T >	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."
Cstormm::energy::PPIKit< T, T4 >	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
Cstormm::energy::PPITable	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
Cstormm::mm::PPPMControls	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
Cstormm::namelist::PPPMControls	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
Cstormm::mm::PrecisionControls	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
Cstormm::namelist::PrecisionControls	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
Cstormm::reporting::ProgressBar
Cstormm::energy::PsSynthesisBorders	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
Cstormm::synthesis::PsSynthesisBorders	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
Cstormm::trajectory::PsSynthesisBorders	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
Cstormm::chemistry::PsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::energy::PsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::mm::PsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::structure::PsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::synthesis::PsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::trajectory::PsSynthesisReader	The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::energy::PsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::mm::PsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::stmath::PsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::structure::PsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::synthesis::PsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::testing::PsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::trajectory::PsSynthesisWriter	The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dynamics in a collection of systems
Cstormm::random::Ran2Generator	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)
Cstormm::stmath::Ran2Generator	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)
Cstormm::namelist::RandomControls	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
Cstormm::random::RandomNumberMill< T >	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
Cstormm::namelist::ReceptorControls	Encapsulate the data extracted from a &receptor namelist to define a grid-mapped representation of a rigid macromolecular structure
Cstormm::mm::ReductionBridge	Allocate space for reduction operations to store temporary accumulations, bridging the gap between gathering and scattering operations
Cstormm::stmath::ReductionBridge	Allocate space for reduction operations to store temporary accumulations, bridging the gap between gathering and scattering operations
Cstormm::mm::ReductionKit	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
Cstormm::stmath::ReductionKit	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
Cstormm::stmath::ReductionWorkUnit	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
Cstormm::synthesis::ReductionWorkUnit	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
Cstormm::namelist::RemdControls	Encapsulating the data extracted from the REMD namelist
Cstormm::namelist::RenderOptions
Cstormm::review::RenderOptions
Cstormm::namelist::ReportControls	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
Cstormm::review::ReportControls	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
Cstormm::structure::ReportControls	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
Cstormm::namelist::ReportTable	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
Cstormm::review::ReportTable	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
Cstormm::energy::RestraintApparatus	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
Cstormm::mm::RestraintApparatus	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
Cstormm::restraints::RestraintApparatus	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
Cstormm::structure::RestraintApparatus	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
Cstormm::synthesis::RestraintApparatus	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
Cstormm::namelist::RestraintControls	Object to encapsulate and dispense restraint information collected from a single &restraint namelist
Cstormm::synthesis::RestraintControls	Object to encapsulate and dispense restraint information collected from a single &restraint namelist
Cstormm::energy::RestraintKit< T, T2, T4 >	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
Cstormm::mm::RestraintKit< T, T2, T4 >	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
Cstormm::restraints::RestraintKit< T, T2, T4 >	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
Cstormm::synthesis::RestraintKit< T, T2, T4 >	Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed things, as reflected in the tedium of this object
Cstormm::structure::RMSDPlan	Collect instructions for one or more systems (intend to work with any coordinate object, including the PhaseSpaceSynthesis)
Cstormm::structure::RMSDPlanReader< T >	Read-only abstract for the RMSDPlan object, containing pointers to various buckets of atom indices
Cstormm::namelist::SceneControls	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
Cstormm::energy::ScoreCard	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
Cstormm::mm::ScoreCard	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
Cstormm::review::ScoreCard	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
Cstormm::structure::ScoreCard	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
Cstormm::synthesis::ScoreCard	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
Cstormm::energy::ScoreCardReader	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
Cstormm::energy::ScoreCardWriter	Writeable abstract for the ScoreCard object, useful for accumulating energies in many kernels
Cstormm::mm::ScoreCardWriter	Writeable abstract for the ScoreCard object, useful for accumulating energies in many kernels
Cstormm::topology::ScreeningFactorTag	A struct to encode the non-bonded atom types in a dihedral and associated electrostatic and van-der Waals 1:4 interactions
Cstormm::review::SectionContents	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
Cstormm::chemistry::SelectionItem	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
Cstormm::energy::SeMaskSynthesisReader	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
Cstormm::synthesis::SeMaskSynthesisReader	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
Cstormm::topology::SettleParm	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
Cstormm::data_types::short2
Cstormm::short2
Cstormm::data_types::short3
Cstormm::short3
Cstormm::data_types::short4
Cstormm::short4
Cstormm::namelist::SolventControls	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
Cstormm::energy::StaticExclusionMask	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
Cstormm::mm::StaticExclusionMask	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
Cstormm::structure::StaticExclusionMask	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
Cstormm::synthesis::StaticExclusionMask	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
Cstormm::energy::StaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
Cstormm::mm::StaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
Cstormm::structure::StaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
Cstormm::synthesis::StaticExclusionMaskReader	The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member function that returns it
Cstormm::energy::StaticExclusionMaskSynthesis	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
Cstormm::mm::StaticExclusionMaskSynthesis	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
Cstormm::synthesis::StaticExclusionMaskSynthesis	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
Cstormm::chemistry::StopWatch	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
Cstormm::mm::StopWatch	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
Cstormm::synthesis::StopWatch	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
Cstormm::testing::StopWatch	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
Cstormm::energy::SyAtomUpdateKit< T, T2, T4 >	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
Cstormm::mm::SyAtomUpdateKit< T, T2, T4 >	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
Cstormm::structure::SyAtomUpdateKit< T, T2, T4 >	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
Cstormm::synthesis::SyAtomUpdateKit< T, T2, T4 >	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
Cstormm::trajectory::SyAtomUpdateKit< T, T2, T4 >	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
Cstormm::energy::SyNonbondedKit< T, T2 >	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
Cstormm::mm::SyNonbondedKit< T, T2 >	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
Cstormm::structure::SyNonbondedKit< T, T2 >	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
Cstormm::synthesis::SyNonbondedKit< T, T2 >	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
Cstormm::trajectory::SyNonbondedKit< T, T2 >	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
Cstormm::mm::SynthesisCacheMap	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
Cstormm::review::SynthesisCacheMap	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
Cstormm::structure::SynthesisCacheMap	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
Cstormm::synthesis::SynthesisCacheMap	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
Cstormm::trajectory::SynthesisCacheMap	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
Cstormm::review::SynthesisMapReader	A set of pointers to critical arrays in the map below
Cstormm::structure::SynthesisMapReader	A set of pointers to critical arrays in the map below
Cstormm::synthesis::SynthesisMapReader	A set of pointers to critical arrays in the map below
Cstormm::synthesis::SynthesisPermutor	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
Cstormm::synthesis::SyPermutorKit< T >	Read-only abstract for the SynthesisPermutor. Access to all of the atom groups, critical measurements, and settings for mutable components is contained herein
Cstormm::energy::SyRestraintKit< T, T2, T4 >	Collect the critical restraint parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::mm::SyRestraintKit< T, T2, T4 >	Collect the critical restraint parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::synthesis::SyRestraintKit< T, T2, T4 >	Collect the critical restraint parameters and masking information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::mm::SystemCache	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
Cstormm::review::SystemCache	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
Cstormm::structure::SystemCache	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
Cstormm::synthesis::SystemCache	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
Cstormm::testing::SystemCache	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
Cstormm::trajectory::SystemCache	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
Cstormm::energy::SyValenceKit< T >	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::mm::SyValenceKit< T >	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::structure::SyValenceKit< T >	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::synthesis::SyValenceKit< T >	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::trajectory::SyValenceKit< T >	Collect the critical valence parameters and indexing information for work unit-based evaluation of the systems in an AtomGraphSynthesis
Cstormm::testing::TestEnvironment	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
Cstormm::testing::TestSystemManager	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
Cstormm::diskutil::TextFile	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
Cstormm::display::TextFile	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
Cstormm::docs::TextFile	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
Cstormm::namelist::TextFile	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
Cstormm::parse::TextFile	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
Cstormm::review::TextFile	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
Cstormm::structure::TextFile	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
Cstormm::synthesis::TextFile	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
Cstormm::testing::TextFile	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
Cstormm::topology::TextFile	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
Cstormm::trajectory::TextFile	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
Cstormm::diskutil::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::docs::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::namelist::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::parse::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::review::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::structure::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::testing::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::topology::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::trajectory::TextFileReader	Abstract for the TextFile object, providing read-only access
Cstormm::chemistry::TextGuard	Structure for specifying the features of a comment in some text file
Cstormm::docs::TextGuard	Structure for specifying the features of a comment in some text file
Cstormm::namelist::TextGuard	Structure for specifying the features of a comment in some text file
Cstormm::parse::TextGuard	Structure for specifying the features of a comment in some text file
Cstormm::testing::TextGuard	Structure for specifying the features of a comment in some text file
Cstormm::energy::Thermostat	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
Cstormm::mm::Thermostat	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
Cstormm::trajectory::Thermostat	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
Cstormm::mm::ThermostatReader< T >	Read-only abstract for the Thermostat object
Cstormm::trajectory::ThermostatReader< T >	Read-only abstract for the Thermostat object
Cstormm::energy::ThermostatWriter< T >	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
Cstormm::mm::ThermostatWriter< T >	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
Cstormm::trajectory::ThermostatWriter< T >	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
Cstormm::review::TickCounter< T >	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
Cstormm::stmath::TickCounter< T >	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
Cstormm::synthesis::TickCounter< T >	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
Cstormm::energy::TileManager	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
Cstormm::energy::TilePlan	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
Cstormm::stmath::TricubicCell< T >	One element of a three-dimensional, space-filling tile representing a three-dimensional function to be interpolated by a tricubic spline
Cstormm::structure::TricubicCell< T >	One element of a three-dimensional, space-filling tile representing a three-dimensional function to be interpolated by a tricubic spline
Cstormm::stmath::TricubicStencil	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
Cstormm::structure::TricubicStencil	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
Cstormm::structure::TriposMol	The Tripos mol2 format, as annotated in the mol2 .pdf document found within this source directory
Cstormm::stmath::TwinPointer< T >	A twin pointer, useful for performing partial-pivoting Gaussian elimination on row-major matrices
Cstormm::data_types::uchar2
Cstormm::uchar2
Cstormm::data_types::uchar3
Cstormm::uchar3
Cstormm::data_types::uchar4
Cstormm::uchar4
Cstormm::data_types::uint2
Cstormm::uint2
Cstormm::data_types::uint3
Cstormm::uint3
Cstormm::data_types::uint4
Cstormm::uint4
Cstormm::data_types::ulonglong2
Cstormm::ulonglong2
Cstormm::data_types::ulonglong3
Cstormm::ulonglong3
Cstormm::data_types::ulonglong4
Cstormm::ulonglong4
Cstormm::topology::UreyBradleyTerm< T >	Unguarded struct to store the ingredients of a single Urey-Bradley interaction
Cstormm::namelist::UserSettings	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
Cstormm::review::UserSettings	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
Cstormm::data_types::ushort2
Cstormm::ushort2
Cstormm::data_types::ushort3
Cstormm::ushort3
Cstormm::data_types::ushort4
Cstormm::ushort4
Cstormm::synthesis::ValenceDelegator	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
Cstormm::chemistry::ValenceKit< T >	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
Cstormm::energy::ValenceKit< T >	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
Cstormm::mm::ValenceKit< T >	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
Cstormm::restraints::ValenceKit< T >	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
Cstormm::review::ValenceKit< T >	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
Cstormm::structure::ValenceKit< T >	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
Cstormm::synthesis::ValenceKit< T >	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
Cstormm::topology::ValenceKit< T >	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
Cstormm::energy::ValenceWorkUnit	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
Cstormm::synthesis::ValenceWorkUnit	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
Cstormm::trajectory::ValidCoordinateTypes	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)
Cstormm::data_types::ValueWithCounter< T >	Templated, combined type for tagging any data type with an associated integer count
Cstormm::stmath::ValueWithCounter< T >	Templated, combined type for tagging any data type with an associated integer count
Cstormm::ValueWithCounter< T >	Templated, combined type for tagging any data type with an associated integer count
Cstormm::data_types::Vec2< T >	A template-compatible class for implementing vectorized two-tuples in C++ code, based on a single scalar type
Cstormm::Vec2< T >	A template-compatible class for implementing vectorized two-tuples in C++ code, based on a single scalar type
Cstormm::data_types::Vec3< T >	A template-compatible class for implementing vectorized three-tuples in C++ code, based on a single scalar type
Cstormm::Vec3< T >	A template-compatible class for implementing vectorized three-tuples in C++ code, based on a single scalar type
Cstormm::data_types::Vec4< T >	A template-compatible class for implementing vectorized four-tuples in C++ code, based on a single scalar type
Cstormm::Vec4< T >	A template-compatible class for implementing vectorized four-tuples in C++ code, based on a single scalar type
Cstormm::energy::VirtualSiteKit< T >	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
Cstormm::mm::VirtualSiteKit< T >	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
Cstormm::structure::VirtualSiteKit< T >	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
Cstormm::synthesis::VirtualSiteKit< T >	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
Cstormm::topology::VirtualSiteKit< T >	Information needed for the placement of virtual sites and transmission of forces on these sites to their frame atoms which have mass
Cstormm::topology::VirtualSiteTable	Unguarded struct to collect information about virtual sites in the topology
Cstormm::synthesis::VolumePartition	Define one volume of whole-numbered side lengths within a larger unit cell, which itself is part of a synthesis of many systems
Cstormm::review::Watcher	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
Cstormm::review::WatcherReader	The read-only abstract for the Watcher class is available to make reports out of a Watcher object passed by const reference
Cstormm::review::WatcherWriter	The writeable abstract for a Watcher class will be provided as a formal argument to various molecular simulations functions that record checks for it
Cstormm::random::Xoroshiro128pGenerator	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
Cstormm::random::Xoshiro256ppGenerator	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
Cstormm::stmath::Xoshiro256ppGenerator	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
Cstormm::synthesis::Xoshiro256ppGenerator	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
Cstormm::testing::Xoshiro256ppGenerator	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
Cstormm::trajectory::Xoshiro256ppGenerator	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