Class List

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

[detail level 123]

gmx	Generic GROMACS namespace
compat	Compatibility aliases for standard library features
not_null	Restricts a pointer or smart pointer to only hold non-null values
detail
PaddingTraits	Traits classes for handling padding for types used with PaddedVector
extents_analyse< R, E0, StaticExtents...>	Enable querying extent of specific rank by splitting a static extents off the variadic template arguments
extents_analyse< R, dynamic_extent, StaticExtents...>	Enable querying extent of specific rank by splitting a dynamic extent off the variadic template arguments
extents_analyse< 0 >	Specialisation for rank 0 extents analysis. Ends recursive rank analysis
internal
SimdTraits	Simd traits
test	Testing utilities namespace
AnalysisDataTestInputPointSet	Represents a single set of points in AnalysisDataTestInputFrame structure
AnalysisDataTestInputFrame	Represents a single frame in AnalysisDataTestInput structure
AnalysisDataTestInput	Represents static input data for AbstractAnalysisData tests
AnalysisDataTestFixture	Test fixture for AbstractAnalysisData testing
ModuleSelection	Helper class for tests that need an initialized selection
ModuleTest	Test fixture to test matching file types for modules
SetAtomsSupportedFiles	Helper to test supported file names
SetAtomsUnSupportedFiles	Helper to test supported file names
AnyOutputSupportedFiles	Helper to test supported file names
NoOptionalOutput	Helper to test support for disabling all output options
OutputSelectorDeathTest	Helper to test that invalid selection is rejected
SetVelocitySupportedFiles	Helper to test supported file names
SetVelocityUnSupportedFiles	Helper to test supported file names
SetForceSupportedFiles	Helper to test supported file names
SetForceUnSupportedFiles	Helper to test supported file names
SetPrecisionSupportedFiles	Helper to test supported file names
SetPrecisionUnSupportedFiles	Helper to test supported file names
FlagTest	Test fixture to test user inputs
AllocatorTest	Templated test fixture
CommandLine	Helper class for tests that need to construct command lines
CommandLineTestHelper	Helper class for tests that construct command lines that need to reference existing files
CommandLineTestBase	Test fixture for tests that call a single command-line program with input/output files
ConfMatch	Match the contents as an gro file
IFileMatcher	Represents a file matcher, matching file contents against reference (or other) data
IFileMatcherSettings	Represents a factory for creating a file matcher
TextFileMatch	Use a ITextBlockMatcher for matching the contents
NoContentsMatch	Do not check the contents of the file
InteractiveTestHelper	Helper class for testing interactive sessions
LoggerTestHelper	Helper class for tests to check output written to a logger
TestReferenceData	Handles creation of and comparison to test reference data
TestReferenceChecker	Handles comparison to test reference data
StdioTestHelper	Helper class for tests where code reads directly from stdin
StringTestBase	Test fixture for tests that check string formatting
FloatingPointDifference	Computes and represents a floating-point difference value
FloatingPointTolerance	Specifies a floating-point comparison tolerance and checks whether a difference is within the tolerance
TestException	Exception class for reporting errors in tests
TestFileManager	Helper for tests that need input and output files
TestFileInputRedirector	In-memory implementation for IFileInputRedirector for tests
TestFileOutputRedirector	In-memory implementation of IFileOutputRedirector for tests
TestOptionsProvider	Provides additional options for the test executable
ITextBlockMatcher	Represents a text matcher, matching text stream contents against reference data
ITextBlockMatcherSettings	Represents a factory for creating a text matcher
ExactTextMatch	Use an exact text match (the contents should be exactly equal)
NoTextMatch	Do not match the text (the contents are ignored)
FilteringExactTextMatch	Use an exact text match after scrubbing lines of the text that match the supplied regular expressions
TprAndFileManager	Helper to bundle generated TPR and the file manager to clean it up
XvgMatch	Match the contents as an xvg file
AnalysisDataModuleManager	Encapsulates handling of data modules attached to AbstractAnalysisData
AnalysisDataStorageFrame	Allows assigning values for a data frame in AnalysisDataStorage
AnalysisDataStorage	Helper class that implements storage of data
ArrayRef	STL-like interface to a C array of T (or part of a std container of T)
AnalysisDataParallelOptions	Parallelization options for analysis data objects
Awh	Coupling of the accelerated weight histogram method (AWH) with the system
DensityFittingModuleInfo	Information about the density fitting module
CommandLineHelpContext	Context information for writing out command-line help
GlobalCommandLineHelpContext	Helper for passing CommandLineHelpContext into parse_common_args()
CommandLineHelpWriter	Writes help information for Options
CommandLineModuleSettings	Settings to pass information between a module and the general runner
ICommandLineModule	Module that can be run from command line using CommandLineModuleManager
CommandLineModuleManager	Implements a wrapper command-line interface for multiple modules
CommandLineModuleGroup	Handle to add content to a group added with CommandLineModuleManager::addModuleGroup()
ICommandLineOptionsModuleSettings	Settings to pass information between a CommandLineOptionsModule and generic code that runs it
ICommandLineOptionsModule	Module that can be run from a command line and uses gmx::Options for argument processing
CommandLineParser	Implements command-line parsing for Options objects
IExecutableEnvironment	Allows customization of the way various directories are found by CommandLineProgramContext
CommandLineProgramContext	Program context implementation for command line programs
TrajectoryFileOpener	Low level method to take care of only file opening and closing
TrajectoryFrameWriter	Writes coordinate frames to a sink, e.g. a trajectory file
ProcessFrameConversion	ProcessFrameConversion class for handling the running of several analysis steps
IFrameConverter	IFrameConverter interface for manipulating coordinate information
IOutputAdapter	OutputAdapter class for handling trajectory file flag setting and processing
OutputAdapterContainer	Storage for output adapters that modify the state of a t_trxframe object
OutputSelector	OutputSelector class controls setting which coordinates are actually written
SetAtoms	SetAtoms class controls availability of atoms data
SetBox	Allows changing box information when writing a coordinate file
SetForces	SetForces class allows changing writing of forces to file
SetPrecision	SetPrecision class allows changing file writing precision
SetStartTime	SetStartTime class allows changing trajectory time information
SetTimeStep	SetTimeStep class allows changing trajectory time information
SetVelocities	SetVelocities class allows changing writing of velocities to file
OutputRequirementOptionDirector	Container for the user input values that will be used by the builder to determine which OutputAdapters should/could/will be registered to the coordinate file writer
OutputRequirements	Finalized version of requirements after processing
DomainDecompositionBuilder	Builds a domain decomposition management object
FixedCapacityVector	Vector that behaves likes std::vector but has fixed capacity
HashedMap	Unordered key to value mapping
GpuHaloExchange	Manages GPU Halo Exchange object
LocalAtomSet	A local atom set collects local, global and collective indices of the home atoms on a rank. The indices of the home atoms are automatically updated during domain decomposition, thus gmx::LocalAtomSet::localIndex enables iteration over local atoms properties like coordinates or forces. TODO: add a LocalAtomSet iterator
LocalAtomSetManager	Hands out handles to local atom set indices and triggers index recalculation for all sets upon domain decomposition if run in parallel
LocalTopologyChecker	Has responsibility for checking that the local topology distributed across domains describes a total number of bonded interactions that matches the system topology
DomdecOptions	Structure containing all (command line) options for the domain decomposition
EnergyAnalysisFrame	Class describing an energy frame, that is the all the data stored for one energy term at one time step in an energy file
EnergyTerm	Class describing the whole time series of an energy term
EnergyNameUnit	Convenience structure for keeping energy name and unit together
IEnergyAnalysis	Interface class overloaded by the separate energy modules
SeparatePmeRanksPermitted	Class for managing usage of separate PME-only ranks
PmeForceSenderGpu	Manages sending forces from PME-only ranks to their PP ranks
PmePpCommGpu	Manages communication related to GPU buffers between this PME rank and its PP rank
MDModulesCheckpointReadingDataOnMain	Provides the MDModules with the checkpointed data on the main rank
MDModulesCheckpointReadingBroadcast	Provides the MDModules with the communication record to broadcast
MDModulesWriteCheckpointData	Writing the MDModules data to a checkpoint file
MrcDensityMapOfFloatReader	Read an mrc/ccp4 file that contains float values
MrcDensityMapOfFloatFromFileReader	Read an mrc density map from a given file
MrcDensityMapOfFloatWriter	Write an mrc/ccp4 file that contains float values
MrcDataStatistics	Statistics about mrc data arrays
MrcDensitySkewData	Skew matrix and translation. As named in "EMDB Map Distribution Format Description Version 1.01 (c) emdatabank.org 2014"
CrystallographicLabels	Crystallographic labels for mrc data
MrcDensityMapHeader	A container for the data in mrc density map file formats
ArrayRefWithPadding	Interface to a C array of T (or part of a std container of T), that includes padding that is suitable for the kinds of SIMD operations GROMACS uses
ListOfLists	A list of lists, optimized for performance
ClfftInitializer	Handle clFFT library init and tear down in RAII style also with mutual exclusion
DeviceStreamManager	Device stream and context manager
HostAllocationPolicy	Policy class for configuring gmx::Allocator, to manage allocations of memory that may be needed for e.g. GPU transfers
OpenClTraits	Stub for OpenCL type traits
OpenClTraitsBase	Implements common trait infrastructure for OpenCL types
OpenClTraits< cl_context >	Implements traits for cl_context
OpenClTraits< cl_command_queue >	Implements traits for cl_command_queue
OpenClTraits< cl_program >	Implements traits for cl_program
OpenClTraits< cl_kernel >	Implements traits for cl_kernel
ClHandle	Wrapper of OpenCL type cl_type to implement RAII
CpuInfo	Detect CPU capabilities and basic logical processor info
LogicalProcessor	Entry with basic information for a single processing unit
HardwareTopology	Information about packages, cores, processing units, numa, caches
Cache	Information about a single cache level
Core	Information about a single core in a package
Device	Information about a single PCI device
LogicalProcessor	Information about package, core and processing unit for a logical processor
Machine	Hardware topology information about the entire machine
Numa	Information about all numa nodes
NumaNode	Information about each numa node in system
Package	Information about a single package in the system
ProcessingUnit	Information about a single processing unit (in a core)
EnumerationArray	Wrapper for a C-style array with size and indexing defined by an enum. Useful for declaring arrays of enum names for debug or other printing. An ArrayRef<DataType> may be constructed from an object of this type
TranslateAndScale	Transform coordinates in three dimensions by first translating, then scaling them
AffineTransformation	Affine transformation of three-dimensional coordinates
DensitySimilarityMeasure	Measure similarity and gradient between densities
DensityFittingForce	Manages evaluation of density-fitting forces for particles that were spread with a kernel
ExponentialMovingAverageState	Store the state of exponential moving averages
ExponentialMovingAverage	Evaluate the exponential moving average with bias correction
GaussianSpreadKernelParameters	Parameters for density spreading kernels
PositionAndAmplitude	Parameters that describe the kernel position and amplitude
Shape	Shape parameters for Gaussian spreading kernels describe the kernel shape
GaussTransform3D	Sums Gaussian values at three dimensional lattice coordinates. The Gaussian is defined as
MultiDimArray	Multidimensional array that manages its own memory
PaddedVector	PaddedVector is a container of elements in contiguous storage that allocates extra memory for safe SIMD-style loads for operations used in GROMACS
CheckpointHandler	Class handling the checkpoint signal
Constraints	Handles constraints
AtomPair	A pair of atoms indexes
MDAtoms	Contains a C-style t_mdatoms while managing some of its memory with C++ vectors with allocators
ResetHandler	Class handling the reset of counters
SettleData	Data for executing SETTLE constraining
shakedata	Working data for the SHAKE algorithm
SimulationSignal	POD-style object used by mdrun ranks to set and receive signals within and between simulations
SimulationSignaller	Object used by mdrun ranks to signal to each other at this step
StopHandler	Class handling the stop signal
StopConditionSignal	Class setting the stop signal based on gmx_get_stop_condition()
StopConditionTime	Class setting the stop signal based on maximal run time
StopHandlerBuilder	Class preparing the creation of a StopHandler
Update	Contains data for update phase
UpdateGroups	Owns the update grouping and related data
UpdateGroupsCog	Class for managing and computing centers of geometry of update groups
VirtualSitesHandler	Class that handles construction of vsites and spreading of vsite forces
WholeMoleculeTransform	This class manages a coordinate buffer with molecules not split over periodic boundary conditions for use in force calculations which require whole molecules
LegacyMdrunOptions	This class provides the same command-line option functionality to both CLI and API sessions
MDModules	Manages the collection of all modules used for mdrun
MembedHolder	Membed SimulatorBuilder parameter type
Mdrunner	Runner object for supporting setup and execution of mdrun
MdrunnerBuilder	Build a gmx::Mdrunner
SimulationContext	Simulation environment and configuration
SimulatorConfig	Simulation configuation settings
SimulatorStateData	Data for a specific simulation state
SimulatorEnv	Collection of environmental information for a simulation
Profiling	Collection of profiling information
ConstraintsParam	Collection of constraint parameters
LegacyInput	Collection of legacy input information
InteractiveMD	SimulatorBuilder parameter type for InteractiveMD
IonSwapping	Parameter type for IonSwapping SimulatorBuilder component
TopologyData	Collection of handles to topology information
BoxDeformationHandle	Handle to information about the box
SimulatorBuilder	Class preparing the creation of Simulator objects
MDModulesNotifier	Organizes notifications about an event of interest to modules
BuildMDModulesNotifier< CurrentCallParameter, CallParameter...>	Template specialization to assemble MDModulesNotifier
MDModulesAtomsRedistributedSignal	Notification that atoms may have been redistributed
MDModulesEnergyOutputToDensityFittingRequestChecker	Check if module outputs energy to a specific field
MDModulesEnergyOutputToQMMMRequestChecker	Check if QMMM module outputs energy to a specific field
EnergyCalculationFrequencyErrors	Collect errors for the energy calculation frequency
SimulationTimeStep	Provides the simulation time step in ps
CoordinatesAndBoxPreprocessed	Provides coordinates and simulation box
MdRunInputFilename	Mdrun input filename
EdrOutputFilename	Energy trajectory output filename from Mdrun
QMInputFileName	Notification for QM program input filename provided by user as command-line argument for grompp
EnsembleTemperature	Provides the constant ensemble temperature
MDModulesNotifiers	Group of notifers to organize that MDModules can receive callbacks they subscribe to
accessor_basic	The most basic memory access model for mdspan
extents	Multidimensional extents with static and dynamic dimensions
layout_right	Right-aligned array layout indexer. Carries the mapping class performing the translation from multidimensional index to one-dimensional number
mapping	Mapping from multidimensional indices within extents to 1D index
basic_mdspan	Multidimensional array indexing and memory access with flexible mapping and access model
CheckpointData	}
IsSerializableEnum	{
ReadCheckpointDataHolder	Holder for read checkpoint data
WriteCheckpointDataHolder	Holder for write checkpoint data
ForceBuffersView	A view of the force buffer
ForceBuffers	Object that holds the force buffers
ForceWithShiftForces	Container for force and virial for algorithms that compute shift forces for virial calculation
ForceWithVirial	Container for force and virial for algorithms that provide their own virial tensor contribution
ForceOutputs	Force and virial output buffers for use in force computation
ForceProviderInput	Helper struct that bundles data for passing it over to the force providers
ForceProviderOutput	Helper struct bundling the output data of a force provider
IForceProvider	Interface for a component that provides forces during MD
ForceProviders	Evaluates forces from a collection of gmx::IForceProvider
IMDModule	Extension module for GROMACS simulations
IMDOutputProvider	Interface for handling additional output files during a simulation
IMdpOptionProvider	Interface for handling mdp/tpr input to a mdrun module
MtsLevel	Setting for a single level for multiple time step integration
GromppMtsOpts	Struct for passing the MTS mdp options to setupMtsLevels()
ObservablesReducerBuilder	Builder for ObservablesReducer
ObservablesReducer	Manage reduction of observables for registered subscribers
StepWorkload	Describes work done on this domain by the current rank that may change per-step
DomainLifetimeWorkload	Describes work done on this domain on every step of its lifetime, but which might change after the next domain partitioning
SimulationWorkload	Manage what computation is required during the simulation
ModularSimulator	The modular simulator
ElementNotFoundError	Exception class signalling that a requested element was not found
MissingElementConnectionError	Exception class signalling that elements were not connected properly
SimulationAlgorithmSetupError	Exception class signalling that the ModularSimulatorAlgorithm was set up in an incompatible way
CheckpointError	Exception class signalling an error in reading or writing modular checkpoints
BenchmarkSystem	Description of the system used for benchmarking
Range	Defines a range of integer numbers and accompanying operations
iterator	An iterator that loops over a range of integers
CoulombCalculator	Base Coulomb calculator class, only specializations are used
CoulombCalculator< KernelCoulombType::RF >	Specialized calculator for RF
CoulombCalculator< KernelCoulombType::EwaldAnalytical >	Specialized calculator for Ewald using an analytic approximation
CoulombCalculator< KernelCoulombType::EwaldTabulated >	Specialized calculator for Ewald using tabulated functions
DiagonalMasker	Base Coulomb calculator class, only specializations are used
DiagonalMasker< nR, kernelLayout, KernelLayoutClusterRatio::JSizeEqualsISize >	Specialized masker for JSizeEqualsISize
DiagonalMasker< nR, kernelLayout, KernelLayoutClusterRatio::JSizeIsDoubleISize >	Specialized masker for JSizeIsDoubleISize
DiagonalMasker< nR, kernelLayout, KernelLayoutClusterRatio::JSizeIsHalfISize >	Specialized masker for JSizeIsHalfISize
LennardJonesCalculator	Base LJ calculator class, only specializations are used
LennardJonesCalculator< false, InteractionModifiers::PotShift >	Specialized calculator for LJ with potential shift and no energy calculation
LennardJonesCalculator< true, InteractionModifiers::PotShift >	Specialized calculator for LJ with potential shift and energy calculation
LennardJonesCalculator< calculateEnergies, InteractionModifiers::ForceSwitch >	Specialized calculator for LJ with force switch
LennardJonesCalculator< calculateEnergies, InteractionModifiers::PotSwitch >	Specialized calculator for LJ with potential switch
TextTableFormatter	Formats rows of a table for text output
HelpManager	Helper for providing interactive online help
AbstractSimpleHelpTopic	Abstract base class for help topics that have simple text and no subtopics
AbstractCompositeHelpTopic	Abstract base class for help topics that have simple text and subtopics
SimpleHelpTopic	Template for simple implementation of AbstractSimpleHelpTopic
CompositeHelpTopic	Template for simple implementation of AbstractCompositeHelpTopic
HelpLinks	Hyperlink data for writing out help
HelpWriterContext	Context information for writing out help
IHelpTopic	Provides a single online help topic
AbstractOptionStorage	Abstract base class for converting, validating, and storing option values
AbstractOptionSection	Base class for specifying option section properties
AbstractOptionSectionHandle	Base class for handles to option sections
OptionsBehaviorCollection	Container for IOptionsBehavior objects
OptionManagerContainer	Container to keep managers added with Options::addManager() and pass them to options
OptionsAssigner	Decorator class for assigning values to Options
OptionSection	Declares a simple option section
OptionSectionHandle	Allows adding options to an OptionSection
OptionStorageTemplate	Templated base class for constructing option value storage classes
OptionStorageTemplateSimple	Simplified option storage template for options that have one-to-one value conversion
OptionsVisitor	Pure interface for visiting options in a Options object
OptionsTypeVisitor	Abstract base class for visiting options of a particular type
OptionsIterator	Decorator class for visiting options in a Options object
OptionsModifyingVisitor	Pure interface for visiting options in a Options object, allowing modifications
OptionsModifyingTypeVisitor	Abstract base class for visiting options of a particular type, allowing modifications
OptionsModifyingIterator	Decorator class for visiting options in a Options object, allowing changes
RepeatingOptionSectionHandle	Allows adding options to an RepeatingOptionSection
RepeatingOptionSection	Declares an option section that creates a structure for each instance
OptionValueConverterSimple	Helper for converting from Any to a given type
PullCoordExpressionParser	Class with a mathematical expression and parser
ExponentialDistribution	Exponential distribution
param_type	Exponential distribution parameters
GammaDistribution	Gamma distribution
param_type	Gamma distribution parameters
NormalDistribution	Normal distribution
param_type	Normal distribution parameters
TabulatedNormalDistribution	Tabulated normal random distribution
param_type	Normal distribution parameter class (mean and stddev)
ThreeFry2x64General	General implementation class for ThreeFry counter-based random engines
ThreeFry2x64	ThreeFry2x64 random engine with 20 iteractions
ThreeFry2x64Fast	ThreeFry2x64 random engine with 13 iteractions
UniformIntDistribution	Uniform integer distribution
param_type	Uniform int distribution parameters
UniformRealDistribution	Uniform real distribution
param_type	Uniform real distribution parameters
RestraintManager	Manage the Restraint potentials available for Molecular Dynamics
RestraintMDModule	MDModule wrapper for Restraint implementations
Site	Abstraction for a restraint interaction site
SelectionFileOption	Specifies a special option that provides selections from a file
SelectionFileOptionInfo	Wrapper class for accessing and modifying selection file option information
Simd4Double	SIMD4 double type
Simd4DBool	SIMD4 variable type to use for logical comparisons on doubles
Simd4Float	SIMD4 float type
Simd4FBool	SIMD4 variable type to use for logical comparisons on floats
SimdDouble	Double SIMD variable. Available if GMX_SIMD_HAVE_DOUBLE is 1
SimdDInt32	Integer SIMD variable type to use for conversions to/from double
SimdDBool	Boolean type for double SIMD data
SimdDIBool	Boolean type for integer datatypes corresponding to double SIMD
SimdFloat	Float SIMD variable. Available if GMX_SIMD_HAVE_FLOAT is 1
SimdFInt32	Integer SIMD variable type to use for conversions to/from float
SimdFBool	Boolean type for float SIMD data
SimdFIBool	Boolean type for integer datatypes corresponding to float SIMD
SimdFloatTag	Tag type to select to load SimdFloat with simdLoad(U)
SimdDoubleTag	Tag type to select to load SimdDouble with simdLoad(U)
SimdFInt32Tag	Tag type to select to load SimdFInt32 with simdLoad(U)
SimdDInt32Tag	Tag type to select to load SimdDInt32 with simdLoad(U)
AlignedArray< float, N >	Identical to std::array with GMX_SIMD_FLOAT_WIDTH alignment. Should not be deleted through base pointer (destructor is non-virtual)
AlignedArray< double, N >	Identical to std::array with GMX_SIMD_DOUBLE_WIDTH alignment. Should not be deleted through base pointer (destructor is non-virtual)
SimdSetZeroProxy	Proxy object to enable setZero() for SIMD and real types
CubicSplineTable	Cubic spline interpolation table
QuadraticSplineTable	Quadratic spline interpolation table
AnalyticalSplineTableInput	Specification for analytical table function (name, function, derivative)
NumericalSplineTableInput	Specification for vector table function (name, function, derivative, spacing)
DevelopmentFeatureFlags	Structure that holds boolean flags corresponding to the development features present enabled through environment variables
GpuTaskMapping	Specifies the GPU deviceID_ available for task_ to use
GpuTaskAssignmentsBuilder	Builder for the GpuTaskAssignments for all ranks on this node
GpuTaskAssignments	Contains the GPU task assignment for all ranks on this physical node
ConvertTprInfo	Declares gmx convert-tpr
ExclusionBlock	Describes exclusions for a single atom
UnionFinder	Union-find data structure for keeping track of disjoint sets
MappedUnionFinder	Extension of UnionFind that supports non-consecutive integer indices as items
AlignedAllocationPolicy	Policy class for configuring gmx::Allocator, to manage allocations of aligned memory for SIMD code
PageAlignedAllocationPolicy	Policy class for configuring gmx::Allocator, to manage allocations of page-aligned memory that can be locked for asynchronous transfer to GPU devices
Allocator	Policy-based memory allocator
Any	Represents a dynamically typed value of an arbitrary type - deprecated
BinaryInformationSettings	Settings for printBinaryInformation()
BoolType	A clone of a bool as a workaround on the template specialization of std::vector<bool> that is incompatible with ArrayRef
DataFileOptions	Search parameters for DataFileFinder
DataFileInfo	Information about a data file found by DataFileFinder::enumerateFiles()
DataFileFinder	Searches data files from a set of paths
DefaultInitializationAllocator	Allocator adaptor that interposes construct() calls to convert value initialization into default initialization
DirectoryEnumerator	Lists files in a directory
IFileInputRedirector	Allows overriding file existence checks from code that supports it
IFileOutputRedirector	Allows capturing stdout and file output from code that supports it
StandardInputStream	Text input stream implementation for reading from stdin
TextInputFile	Text input stream implementation for reading from a file
TextOutputFile	Text output stream implementation for writing to a file
ISerializer	Interface for types that convert standard data types into a form suitable for storage or transfer
KeyValueTreePath	Identifies an entry in a key-value tree
KeyValueTreeBuilder	Root builder for creating trees that have an object at the root
KeyValueTreeValueBuilder	Builder for KeyValueTreeValue objects
KeyValueTreeUniformArrayBuilder	Builder for KeyValueTreeArray objects where all elements are of type T
KeyValueTreeObjectArrayBuilder	Builder for KeyValueTreeArray objects where all elements are KeyValueTreeObject objects
KeyValueTreeObjectBuilder	Builder for KeyValueTreeObject objects
IKeyValueTreeTransformRules	Interface to declare rules for transforming key-value trees
KeyValueTreeTransformRulesScoped	Helper object returned from IKeyValueTreeTransformRules::scopedTransform()
KeyValueTreeTransformRuleBuilder	Provides methods to specify one transformation rule
AfterFrom	Properties that can be specified after from()
ToObject	Properties that can be specified after from().toObject()
ToValue	Properties that can be specified after from().to()
ILogTarget	Target where log output can be written
LogEntryWriter	Helper class for creating log entries with GMX_LOG
LogLevelHelper	Represents a single logging level
MDLogger	Declares a logging interface
LoggerBuilder	Initializes loggers
LoggerOwner	Manages memory for a logger built with LoggerBuilder
MessageStringCollector	Helper class for collecting message strings, optionally with context
MessageStringContext	Convenience class for creating a message context
PhysicalNodeCommunicator	Holds a communicator for the physical node of this rank
StringCompare	Compare object for std::string STL containers and algorithms that supports run-time decision on how to compare
StringOutputStream	Text output stream implementation for writing to an in-memory string
StringInputStream	Helper class to convert static string data to a stream
StringToEnumValueConverter	A class to convert a string to an enum value of type EnumType
TextReader	Reads text from a TextInputStream
TextInputStream	Interface for reading text
TextOutputStream	Interface for writing text
TextWriter	Writes text into a TextOutputStream
isIntegralConstant	Is true if type is a std::integral_constant
no_delete	Deleter for std::shared_ptr that does nothing
NonbondedBenchmarkInfo	Declares gmx nonbonded-bench
BasicVector	C++ class for 3D vectors
AbstractAnalysisData	Abstract base class for all objects that provide data
AnalysisData	Parallelizable data container for raw data
AnalysisDataHandle	Handle for inserting data into AnalysisData
AbstractAnalysisArrayData	Abstract base class for data objects that present in-memory data
AnalysisArrayData	Simple in-memory data array
AnalysisDataValue	Value type for representing a single value in analysis data objects
AnalysisDataFrameHeader	Value type for storing frame-level information for analysis data
AnalysisDataPointSetRef	Value type wrapper for non-mutable access to a set of data column values
AnalysisDataFrameRef	Value type wrapper for non-mutable access to a data frame
IAnalysisDataModule	Interface for a module that gets notified whenever data is added
AnalysisDataModuleSerial	Convenience base class for serial analysis data modules
AnalysisDataModuleParallel	Convenience base class for parallel analysis data modules
AnalysisDataAverageModule	Data module for independently averaging each column in input data
AnalysisDataFrameAverageModule	Data module for averaging of columns for each frame
AnalysisDataDisplacementModule	Data module for calculating displacements
AnalysisHistogramSettingsInitializer	Provides "named parameter" idiom for constructing histograms
AnalysisHistogramSettings	Contains parameters that specify histogram bin locations
AbstractAverageHistogram	Base class for representing histograms averaged over frames
AnalysisDataSimpleHistogramModule	Data module for per-frame histograms
AnalysisDataWeightedHistogramModule	Data module for per-frame weighted histograms
AnalysisDataBinAverageModule	Data module for bin averages
AnalysisDataLifetimeModule	Data module for computing lifetime histograms for columns in input data
AnalysisDataPlotSettings	Common settings for data plots
AbstractPlotModule	Abstract data module for writing data into a file
AnalysisDataPlotModule	Plotting module for straightforward plotting of data
AnalysisDataVectorPlotModule	Plotting module specifically for data consisting of vectors
StaticLog2	Evaluate log2(n) for integer n statically at compile time
StaticLog2< 1 >	Specialization of StaticLog2<n> for n==1
StaticLog2< 0 >	Specialization of StaticLog2<n> for n==0
AbstractOption	Abstract base class for specifying option properties
OptionTemplate	Templated base class for constructing concrete option settings classes
OptionInfo	Gives information and allows modifications to an option after creation
BooleanOption	Specifies an option that provides boolean values
IntegerOption	Specifies an option that provides integer values
Int64Option	Specifies an option that provides 64-bit integer values
DoubleOption	Specifies an option that provides floating-point (double) values
FloatOption	Specifies an option that provides floating-point (float) values
StringOption	Specifies an option that provides string values
EnumOption	Specifies an option that accepts an EnumerationArray of string values and writes the selected index into an enum variable
LegacyEnumOption	Specifies an option that accepts enumerated string values and writes the selected index into an enum variable
BooleanOptionInfo	Wrapper class for accessing boolean option information
IntegerOptionInfo	Wrapper class for accessing integer option information
Int64OptionInfo	Wrapper class for accessing 64-bit integer option information
DoubleOptionInfo	Wrapper class for accessing floating-point option information
FloatOptionInfo	Wrapper class for accessing floating-point option information
StringOptionInfo	Wrapper class for accessing string option information
EnumOptionInfo	Wrapper class for accessing enum option information
FileNameOption	Specifies an option that provides file names
FileNameOptionInfo	Wrapper class for accessing file name option information
FileNameOptionManager	Handles interaction of file name options with global options
IOptionsBehavior	Interface to provide extension points for options parsing
IOptionsContainer	Interface for adding input options
IOptionsContainerWithSections	Interface for adding input options with sections
IOptionManager	Base class for option managers
Options	Collection of options
TimeUnitManager	Provides common functionality for time unit conversions
TimeUnitBehavior	Options behavior to add a time unit option
PotentialPointData	Structure to hold the results of IRestraintPotential::evaluate()
IRestraintPotential	Interface for Restraint potentials
AnalysisNeighborhoodPositions	Input positions for neighborhood searching
AnalysisNeighborhood	Neighborhood searching for analysis tools
AnalysisNeighborhoodPair	Value type to represent a pair of positions found in neighborhood searching
AnalysisNeighborhoodSearch	Initialized neighborhood search with a fixed set of reference positions
AnalysisNeighborhoodPairSearch	Initialized neighborhood pair search with a fixed set of positions
Selection	Provides access to a single selection
SelectionPosition	Provides access to information about a single selected position
SelectionCollection	Collection of selections
SelectionTopologyProperties	Describes topology properties required for selection evaluation
SelectionOption	Specifies an option that provides selection(s)
SelectionOptionInfo	Wrapper class for accessing and modifying selection option information
ITopologyProvider	Provides topology information to SelectionOptionBehavior
SelectionOptionBehavior	Options behavior to allow using SelectionOptions
SelectionOptionManager	Handles interaction of selection options with other options and user input
RangePartitioning	Division of a range of indices into consecutive blocks
TrajectoryAnalysisModuleData	Base class for thread-local data storage during trajectory analysis
TrajectoryAnalysisModule	Base class for trajectory analysis modules
TrajectoryAnalysisSettings	Trajectory analysis module configuration object
TrajectoryAnalysisCommandLineRunner	Runner for command-line trajectory analysis tools
TopologyInformation	Topology information available to a trajectory analysis module
EnumerationIterator	Allows iterating sequential enumerators
EnumerationWrapper	Allows constructing iterators for looping over sequential enumerators
ExceptionInfo	Stores additional context information for exceptions
ExceptionInitializer	Provides information for Gromacs exception constructors
GromacsException	Base class for all exception objects in Gromacs
FileIOError	Exception class for file I/O errors
UserInputError	Exception class for user input errors
InvalidInputError	Exception class for situations where user input cannot be parsed/understood
InconsistentInputError	Exception class for situations where user input is inconsistent
ToleranceError	Exception class when a specified tolerance cannot be achieved
SimulationInstabilityError	Exception class for simulation instabilities
InternalError	Exception class for internal errors
APIError	Exception class for incorrect use of an API
RangeError	Exception class for out-of-range values or indices
NotImplementedError	Exception class for use of an unimplemented feature
ParallelConsistencyError	Exception class for use when ensuring that MPI ranks to throw in a coordinated fashion
ModularSimulatorError	Exception class for modular simulator
FlagsTemplate	Template class for typesafe handling of combination of flags
InstallationPrefixInfo	Provides information about installation prefix (see IProgramContext::installationPrefix())
IProgramContext	Provides context information about the program that is calling the library
StringFormatter	Function object that wraps a call to formatString() that expects a single conversion argument, for use with algorithms
IdentityFormatter	Function object to implement the same interface as StringFormatter to use with strings that should not be formatted further
EqualCaseInsensitive	Function object for comparisons with equalCaseInsensitive
TextLineWrapperSettings	Stores settings for line wrapping
TextLineWrapper	Wraps lines to a predefined length
Nbnxm	Namespace for non-bonded kernels
EnergyFunctionProperties	Set of boolean constants mimicking preprocessor macros
AmdPackedFloat3	Special packed Float3 flavor to help compiler optimizations on AMD CDNA2 devices
AtomIterator	Object that allows looping over all atoms in an mtop
AtomProperties	Holds all the atom property information loaded
AtomProxy	Proxy object returned from AtomIterator
AtomRange	Range over all atoms of topology
AtomsAdjacencyListElement	Helper type for discovering coupled constraints
BalanceRegion	Object that describes a DLB balancing region
BondedInteraction	Information about single bonded interaction
BondedInteractionList	Accumulation of different bonded types for preprocessing
CheckpointHeaderContents	Header explaining the context of a checkpoint file
DDBalanceRegionHandler	Manager for starting and stopping the dynamic load balancing region
DeviceInformation	Platform-dependent device information
DeviceStream	Declaration of platform-agnostic device stream/queue
df_history_t	Free-energy sampling history struct
ekinstate_t	Struct used for checkpointing only
EwaldBoxZScaler	Class to handle box scaling for Ewald and PME
FEPStateValue	Template wrapper struct for particle FEP state values
ForceHelperBuffers	Helper force buffers for ForceOutputs
ForeignLambdaTerms	Accumulates free-energy foreign lambda energies and dH/dlamba
gmx_ana_index_t	Stores a single index group
gmx_ana_indexmap_t	Data structure for calculating index group mappings
gmx_ana_pos_t	Stores a set of positions together with their origins
gmx_cache_protect_t	Cache-line protection buffer
gmx_domdec_constraints_t	Struct used during constraint setup with domain decomposition
gmx_enerdata_t	Struct for accumulating all potential energy terms and some kinetic energy terms
gmx_ffparams_t	Struct that holds all force field parameters for the simulated system
gmx_ga2la_t	Global to local atom mapping
Entry	Structure for the local atom info
gmx_localtop_t	The fully written out topology for a domain over its lifetime
gmx_molblock_t	Block of molecules of the same type, used in gmx_mtop_t
gmx_moltype_t	Molecules type data: atoms, interactions and exclusions
gmx_multisim_t	Coordinate multi-simulation resources for mdrun
gmx_nodecomm_t	Settings and communicators for two-step communication: intra + inter-node
gmx_sparsematrix	Sparse matrix storage format
GpuRegionTimerImpl	The OpenCL implementation of the GPU code region timing. With OpenCL, one has to use cl_event handle for each API call that has to be timed, and accumulate the timing afterwards. As we would like to avoid overhead on API calls, we only query and accumulate cl_event timing at the end of time steps, not after the API calls. Thus, this implementation does not reuse a single cl_event for multiple calls, but instead maintains an array of cl_events to be used within any single code region. The array size is fixed at a small but sufficiently large value for the number of cl_events that might contribute to a timer region, currently 10
GpuRegionTimerWrapper	This is a GPU region timing wrapper class. It allows for host-side tracking of the accumulated execution timespans in GPU code (measuring kernel or transfers duration). It also partially tracks the correctness of the timer state transitions, as far as current implementation allows (see TODO in getLastRangeTime() for a disabled check). Internally it uses GpuRegionTimerImpl for measuring regions
history_t	History information for NMR distance and orientation restraints
IListIterator	Object that allows looping over all atoms in an mtop
IListProxy	Proxy object returned from IListIterator
IListRange	Range over all interaction lists of topology
IndexGroup	An index group consisting or a name and list of atom indices
InteractionListHandle	Type for returning a list of InteractionList references
InteractionOfType	Describes an interaction of a given type, plus its parameters
InteractionsOfType	A set of interactions of a given type (found in the enumeration in ifunc.h), complete with atom indices and force field function parameters
JClusterList	Simple j-cluster list
ListedForces	Class for calculating listed interactions, uses OpenMP parallelization
LocalSettleData	Local settle data
MoleculeBlockIndices	Indices for a gmx_molblock_t, derived from other gmx_mtop_t contents
MoleculeInformation	Holds the molecule information during preprocessing
MoleculePatch	Block to modify individual residues
MoleculePatchDatabase	A set of modifications to apply to atoms
NbnxmKernel	Class name for NBNXM kernel
nbnxn_cj_packed_t	Packed j-cluster list element
nbnxn_cj_t	This is the actual cluster-pair list j-entry
nbnxn_cycle_t	Local cycle count struct for profiling
nbnxn_excl_t	Struct for storing the atom-pair interaction bits for a cluster pair in a GPU pairlist
nbnxn_im_ei_t	Interaction data for a j-group for one warp
nbnxn_sci	Grouped pair-list i-unit
NbnxnPairlistCpu	Cluster pairlist type for use on CPUs
NbnxnPairlistCpuWork	Working data for the actual i-supercell during pair search
IClusterData	Struct for storing coordinates and bounding box for an i-entry during search
nonbonded_verlet_t	Top-level non-bonded data structure for the Verlet-type cut-off scheme
NumPmeDomains	Struct for passing around the number of PME domains
ObservablesHistory	Observables history, for writing/reading to/from checkpoint file
PackedJClusterList	Packed j-cluster list
PairlistSets	Contains sets of pairlists
PairSearch	Main pair-search struct, contains the grid(s), not the pair-list(s)
PairsearchWork	Thread-local work struct, contains working data for Grid
PartialDeserializedTprFile	Contains the partly deserialized contents of a TPR file
PbcAiuc	Compact and ordered version of the PBC matrix
PdbAtomEntry	Contains information for a single particle in a PDB file
PmeGpuProgram	Stores PME data derived from the GPU context or devices
PpRanks	Contains information about the PP ranks that partner this PME rank
PreprocessingAtomTypes	Storage of all atom types used during preprocessing of a simulation input
PreprocessingBondAtomType	Storage for all bonded atomtypes during simulation preprocessing
PreprocessResidue	Information about preprocessing residues
ReplicaExchangeParameters	The parameters for the replica exchange algorithm
SettleWaterTopology	Composite data for settle initialization
SimulationGroups	Contains the simulation atom groups
SimulationInputHandle	Owning handle to a SimulationInput object
SimulationParticle	Single particle in a simulation
StringTable	A class to store strings for lookup
StringTableBuilder	Builds a memory efficient storage for strings of characters
StringTableEntry	Helper class to access members in StringTable
SystemMomenta	System momenta used with with the box deform option
SystemMomentum	The momentum and mass of the whole system
t_filenm	File name option definition for C code
t_mapping	Maps an XPM element to an RGB color and a string description
t_matrix	A matrix of integers, plus supporting values, such as used in XPM output
t_mdatoms	Declares mdatom data structure
t_oriresdata	Orientation restraining stuff
t_pargs	Command-line argument definition for C code
t_pbc	Structure containing info on periodic boundary conditions
t_state	The microstate of the system
t_symbuf	Legacy symbol table entry as linked list
t_xpmelmt	Models an XPM element
TpxFileHeader	First part of the TPR file structure containing information about the general aspect of the system
wallcc_t	Counters for an individual wallcycle timing region
WarningHandler	General warning handling object
WaterMolecule	Indices of atoms in a water molecule