Description

Generic GROMACS namespace.

Declares the integrators for energy minimization and NMA.

Convenience macro to help us avoid ifdefs each time we use sysconf.

Author: David van der Spoel david.nosp@m..van.nosp@m.dersp.nosp@m.oel@.nosp@m.icm.u.nosp@m.u.se

Classes
class	ArrayRef
	STL-like interface to a C array of T (or part of a std container of T). More...

class	CommandLineHelpWriter
	Writes help information for Options. More...

class	CommandLineModuleSettings
	Settings to pass information between a module and the general runner. More...

class	ICommandLineModule
	Module that can be run from command line using CommandLineModuleManager. More...

class	ICommandLineOptionsModuleSettings
	Settings to pass information between a CommandLineOptionsModule and generic code that runs it. More...

class	ICommandLineOptionsModule
	Module that can be run from a command line and uses gmx::Options for argument processing. More...

class	CommandLineParser
	Implements command-line parsing for Options objects. More...

class	TrajectoryFileOpener
	Low level method to take care of only file opening and closing. More...

class	TrajectoryFrameWriter
	Writes coordinate frames to a sink, e.g. a trajectory file. More...

class	ProcessFrameConversion
	ProcessFrameConversion class for handling the running of several analysis steps. More...

class	IFrameConverter
	IFrameConverter interface for manipulating coordinate information. More...

class	IOutputAdapter
	OutputAdapter class for handling trajectory file flag setting and processing. More...

class	OutputSelector
	OutputSelector class controls setting which coordinates are actually written. More...

class	SetAtoms
	SetAtoms class controls availability of atoms data. More...

class	SetBox
	Allows changing box information when writing a coordinate file. More...

class	SetForces
	SetForces class allows changing writing of forces to file. More...

class	SetPrecision
	SetPrecision class allows changing file writing precision. More...

class	SetStartTime
	SetStartTime class allows changing trajectory time information. More...

class	SetTimeStep
	SetTimeStep class allows changing trajectory time information. More...

class	SetVelocities
	SetVelocities class allows changing writing of velocities to file. More...

class	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. More...

struct	OutputRequirements
	Finalized version of requirements after processing. More...

class	FixedCapacityVector
	Vector that behaves likes std::vector but has fixed capacity. More...

class	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. More...

class	ListOfLists
	A list of lists, optimized for performance. More...

class	PaddedVector
	PaddedVector is a container of elements in contiguous storage that allocates extra memory for safe SIMD-style loads for operations used in GROMACS. More...

struct	AtomPair
	A pair of atoms indexes. More...

class	SimulationSignal
	POD-style object used by mdrun ranks to set and receive signals within and between simulations. More...

class	SimulationSignaller
	Object used by mdrun ranks to signal to each other at this step. More...

class	MembedHolder
	Membed SimulatorBuilder parameter type. More...

struct	SimulatorConfig
	Simulation configuation settings. More...

struct	SimulatorStateData
	Data for a specific simulation state. More...

class	SimulatorEnv
	Collection of environmental information for a simulation. More...

class	Profiling
	Collection of profiling information. More...

class	ConstraintsParam
	Collection of constraint parameters. More...

class	LegacyInput
	Collection of legacy input information. More...

class	InteractiveMD
	SimulatorBuilder parameter type for InteractiveMD. More...

class	IonSwapping
	Parameter type for IonSwapping SimulatorBuilder component. More...

class	TopologyData
	Collection of handles to topology information. More...

class	BoxDeformationHandle
	Handle to information about the box. More...

class	CheckpointData
	} More...

struct	IsSerializableEnum
	{ More...

struct	MtsLevel
	Setting for a single level for multiple time step integration. More...

struct	GromppMtsOpts
	Struct for passing the MTS mdp options to setupMtsLevels() More...

class	ElementNotFoundError
	Exception class signalling that a requested element was not found. More...

class	MissingElementConnectionError
	Exception class signalling that elements were not connected properly. More...

class	SimulationAlgorithmSetupError
	Exception class signalling that the ModularSimulatorAlgorithm was set up in an incompatible way. More...

class	CheckpointError
	Exception class signalling an error in reading or writing modular checkpoints. More...

struct	BenchmarkSystem
	Description of the system used for benchmarking. More...

class	Range
	Defines a range of integer numbers and accompanying operations. More...

class	CoulombCalculator
	Base Coulomb calculator class, only specializations are used. More...

class	CoulombCalculator< KernelCoulombType::RF >
	Specialized calculator for RF. More...

class	CoulombCalculator< KernelCoulombType::EwaldAnalytical >
	Specialized calculator for Ewald using an analytic approximation. More...

class	CoulombCalculator< KernelCoulombType::EwaldTabulated >
	Specialized calculator for Ewald using tabulated functions. More...

class	DiagonalMasker
	Base Coulomb calculator class, only specializations are used. More...

class	DiagonalMasker< nR, kernelLayout, KernelLayoutClusterRatio::JSizeEqualsISize >
	Specialized masker for JSizeEqualsISize. More...

class	DiagonalMasker< nR, kernelLayout, KernelLayoutClusterRatio::JSizeIsDoubleISize >
	Specialized masker for JSizeIsDoubleISize. More...

class	DiagonalMasker< nR, kernelLayout, KernelLayoutClusterRatio::JSizeIsHalfISize >
	Specialized masker for JSizeIsHalfISize. More...

class	LennardJonesCalculator
	Base LJ calculator class, only specializations are used. More...

class	LennardJonesCalculator< false, InteractionModifiers::PotShift >
	Specialized calculator for LJ with potential shift and no energy calculation. More...

class	LennardJonesCalculator< true, InteractionModifiers::PotShift >
	Specialized calculator for LJ with potential shift and energy calculation. More...

class	LennardJonesCalculator< calculateEnergies, InteractionModifiers::ForceSwitch >
	Specialized calculator for LJ with force switch. More...

class	LennardJonesCalculator< calculateEnergies, InteractionModifiers::PotSwitch >
	Specialized calculator for LJ with potential switch. More...

class	AbstractOptionSection
	Base class for specifying option section properties. More...

class	AbstractOptionSectionHandle
	Base class for handles to option sections. More...

class	OptionSection
	Declares a simple option section. More...

class	OptionSectionHandle
	Allows adding options to an OptionSection. More...

class	RepeatingOptionSectionHandle
	Allows adding options to an RepeatingOptionSection. More...

class	RepeatingOptionSection
	Declares an option section that creates a structure for each instance. More...

class	PullCoordExpressionParser
	Class with a mathematical expression and parser. More...

class	ExponentialDistribution
	Exponential distribution. More...

class	GammaDistribution
	Gamma distribution. More...

class	NormalDistribution
	Normal distribution. More...

class	TabulatedNormalDistribution
	Tabulated normal random distribution. More...

class	ThreeFry2x64General
	General implementation class for ThreeFry counter-based random engines. More...

class	ThreeFry2x64
	ThreeFry2x64 random engine with 20 iteractions. More...

class	ThreeFry2x64Fast
	ThreeFry2x64 random engine with 13 iteractions. More...

class	UniformIntDistribution
	Uniform integer distribution. More...

class	UniformRealDistribution
	Uniform real distribution. More...

class	ConvertTprInfo
	Declares gmx convert-tpr. More...

struct	BoolType
	A clone of a bool as a workaround on the template specialization of std::vector<bool> that is incompatible with ArrayRef. More...

class	DataFileOptions
	Search parameters for DataFileFinder. More...

struct	DataFileInfo
	Information about a data file found by DataFileFinder::enumerateFiles(). More...

class	DataFileFinder
	Searches data files from a set of paths. More...

class	StringToEnumValueConverter
	A class to convert a string to an enum value of type `EnumType`. More...

class	NonbondedBenchmarkInfo
	Declares gmx nonbonded-bench. More...

class	BasicVector
	C++ class for 3D vectors. More...

class	AbstractAnalysisData
	Abstract base class for all objects that provide data. More...

class	AnalysisData
	Parallelizable data container for raw data. More...

class	AnalysisDataHandle
	Handle for inserting data into AnalysisData. More...

class	AbstractAnalysisArrayData
	Abstract base class for data objects that present in-memory data. More...

class	AnalysisArrayData
	Simple in-memory data array. More...

class	AnalysisDataValue
	Value type for representing a single value in analysis data objects. More...

class	AnalysisDataFrameHeader
	Value type for storing frame-level information for analysis data. More...

class	AnalysisDataPointSetRef
	Value type wrapper for non-mutable access to a set of data column values. More...

class	AnalysisDataFrameRef
	Value type wrapper for non-mutable access to a data frame. More...

class	IAnalysisDataModule
	Interface for a module that gets notified whenever data is added. More...

class	AnalysisDataModuleSerial
	Convenience base class for serial analysis data modules. More...

class	AnalysisDataModuleParallel
	Convenience base class for parallel analysis data modules. More...

class	AnalysisDataAverageModule
	Data module for independently averaging each column in input data. More...

class	AnalysisDataFrameAverageModule
	Data module for averaging of columns for each frame. More...

class	AnalysisDataDisplacementModule
	Data module for calculating displacements. More...

class	AnalysisHistogramSettingsInitializer
	Provides "named parameter" idiom for constructing histograms. More...

class	AnalysisHistogramSettings
	Contains parameters that specify histogram bin locations. More...

class	AbstractAverageHistogram
	Base class for representing histograms averaged over frames. More...

class	AnalysisDataSimpleHistogramModule
	Data module for per-frame histograms. More...

class	AnalysisDataWeightedHistogramModule
	Data module for per-frame weighted histograms. More...

class	AnalysisDataBinAverageModule
	Data module for bin averages. More...

class	AnalysisDataLifetimeModule
	Data module for computing lifetime histograms for columns in input data. More...

class	AnalysisDataPlotSettings
	Common settings for data plots. More...

class	AbstractPlotModule
	Abstract data module for writing data into a file. More...

class	AnalysisDataPlotModule
	Plotting module for straightforward plotting of data. More...

class	AnalysisDataVectorPlotModule
	Plotting module specifically for data consisting of vectors. More...

struct	StaticLog2
	Evaluate log2(n) for integer n statically at compile time. More...

struct	StaticLog2< 1 >
	Specialization of StaticLog2<n> for n==1. More...

struct	StaticLog2< 0 >
	Specialization of StaticLog2<n> for n==0. More...

class	AbstractOption
	Abstract base class for specifying option properties. More...

class	OptionTemplate
	Templated base class for constructing concrete option settings classes. More...

class	OptionInfo
	Gives information and allows modifications to an option after creation. More...

class	BooleanOption
	Specifies an option that provides boolean values. More...

class	IntegerOption
	Specifies an option that provides integer values. More...

class	Int64Option
	Specifies an option that provides 64-bit integer values. More...

class	DoubleOption
	Specifies an option that provides floating-point (double) values. More...

class	FloatOption
	Specifies an option that provides floating-point (float) values. More...

class	StringOption
	Specifies an option that provides string values. More...

class	EnumOption
	Specifies an option that accepts an EnumerationArray of string values and writes the selected index into an `enum` variable. More...

class	LegacyEnumOption
	Specifies an option that accepts enumerated string values and writes the selected index into an `enum` variable. More...

class	BooleanOptionInfo
	Wrapper class for accessing boolean option information. More...

class	IntegerOptionInfo
	Wrapper class for accessing integer option information. More...

class	Int64OptionInfo
	Wrapper class for accessing 64-bit integer option information. More...

class	DoubleOptionInfo
	Wrapper class for accessing floating-point option information. More...

class	FloatOptionInfo
	Wrapper class for accessing floating-point option information. More...

class	StringOptionInfo
	Wrapper class for accessing string option information. More...

class	EnumOptionInfo
	Wrapper class for accessing enum option information. More...

class	FileNameOption
	Specifies an option that provides file names. More...

class	FileNameOptionInfo
	Wrapper class for accessing file name option information. More...

class	FileNameOptionManager
	Handles interaction of file name options with global options. More...

class	IOptionsBehavior
	Interface to provide extension points for options parsing. More...

class	IOptionsContainer
	Interface for adding input options. More...

class	IOptionsContainerWithSections
	Interface for adding input options with sections. More...

class	IOptionManager
	Base class for option managers. More...

class	Options
	Collection of options. More...

class	TimeUnitManager
	Provides common functionality for time unit conversions. More...

class	TimeUnitBehavior
	Options behavior to add a time unit option. More...

class	PotentialPointData
	Structure to hold the results of IRestraintPotential::evaluate(). More...

class	IRestraintPotential
	Interface for Restraint potentials. More...

class	AnalysisNeighborhoodPositions
	Input positions for neighborhood searching. More...

class	AnalysisNeighborhood
	Neighborhood searching for analysis tools. More...

class	AnalysisNeighborhoodPair
	Value type to represent a pair of positions found in neighborhood searching. More...

class	AnalysisNeighborhoodSearch
	Initialized neighborhood search with a fixed set of reference positions. More...

class	AnalysisNeighborhoodPairSearch
	Initialized neighborhood pair search with a fixed set of positions. More...

class	Selection
	Provides access to a single selection. More...

class	SelectionPosition
	Provides access to information about a single selected position. More...

class	SelectionCollection
	Collection of selections. More...

struct	SelectionTopologyProperties
	Describes topology properties required for selection evaluation. More...

class	SelectionOption
	Specifies an option that provides selection(s). More...

class	SelectionOptionInfo
	Wrapper class for accessing and modifying selection option information. More...

class	ITopologyProvider
	Provides topology information to SelectionOptionBehavior. More...

class	SelectionOptionBehavior
	Options behavior to allow using SelectionOptions. More...

class	SelectionOptionManager
	Handles interaction of selection options with other options and user input. More...

class	RangePartitioning
	Division of a range of indices into consecutive blocks. More...

class	TrajectoryAnalysisModuleData
	Base class for thread-local data storage during trajectory analysis. More...

class	TrajectoryAnalysisModule
	Base class for trajectory analysis modules. More...

class	TrajectoryAnalysisSettings
	Trajectory analysis module configuration object. More...

class	TrajectoryAnalysisCommandLineRunner
	Runner for command-line trajectory analysis tools. More...

class	ExceptionInfo
	Stores additional context information for exceptions. More...

class	ExceptionInitializer
	Provides information for Gromacs exception constructors. More...

class	GromacsException
	Base class for all exception objects in Gromacs. More...

class	FileIOError
	Exception class for file I/O errors. More...

class	UserInputError
	Exception class for user input errors. More...

class	InvalidInputError
	Exception class for situations where user input cannot be parsed/understood. More...

class	InconsistentInputError
	Exception class for situations where user input is inconsistent. More...

class	ToleranceError
	Exception class when a specified tolerance cannot be achieved. More...

class	SimulationInstabilityError
	Exception class for simulation instabilities. More...

class	InternalError
	Exception class for internal errors. More...

class	APIError
	Exception class for incorrect use of an API. More...

class	RangeError
	Exception class for out-of-range values or indices. More...

class	NotImplementedError
	Exception class for use of an unimplemented feature. More...

class	ParallelConsistencyError
	Exception class for use when ensuring that MPI ranks to throw in a coordinated fashion. More...

class	ModularSimulatorError
	Exception class for modular simulator. More...

class	FlagsTemplate
	Template class for typesafe handling of combination of flags. More...

struct	InstallationPrefixInfo
	Provides information about installation prefix (see IProgramContext::installationPrefix()). More...

class	IProgramContext
	Provides context information about the program that is calling the library. More...

class	StringFormatter
	Function object that wraps a call to formatString() that expects a single conversion argument, for use with algorithms. More...

class	IdentityFormatter
	Function object to implement the same interface as `StringFormatter` to use with strings that should not be formatted further. More...

class	EqualCaseInsensitive
	Function object for comparisons with `equalCaseInsensitive`. More...

class	TextLineWrapperSettings
	Stores settings for line wrapping. More...

class	TextLineWrapper
	Wraps lines to a predefined length. More...

Typedefs
typedef double	awh_dvec [c_biasMaxNumDim]
	A real vector in AWH coordinate space.

typedef int	awh_ivec [c_biasMaxNumDim]
	An integer vector in AWH coordinate space.

typedef int	force_env_t
	Type for CP2K force environment handle.

typedef std::unique_ptr < ICommandLineModule >	CommandLineModulePointer
	Smart pointer type for managing a ICommandLineModule.

typedef std::map< std::string, CommandLineModulePointer >	CommandLineModuleMap
	Container type for mapping module names to module objects.

typedef std::unique_ptr < CommandLineModuleGroupData >	CommandLineModuleGroupDataPointer
	Smart pointer type for managing a CommandLineModuleGroup.

typedef std::vector < CommandLineModuleGroupDataPointer >	CommandLineModuleGroupList
	Container type for keeping a list of module groups.

typedef std::unique_ptr < ICommandLineOptionsModule >	ICommandLineOptionsModulePointer
	Smart pointer to manage an ICommandLineOptionsModule.

typedef std::unique_ptr < IExecutableEnvironment >	ExecutableEnvironmentPointer
	Shorthand for a smart pointer to IExecutableEnvironment.

using	TrajectoryFrameWriterPointer = std::unique_ptr< TrajectoryFrameWriter >
	Smart pointer to manage the TrajectoryFrameWriter object.

using	ProcessFrameConversionPointer = std::unique_ptr< ProcessFrameConversion >
	Smart pointer to manage the analyse object.

using	FrameConverterPointer = std::unique_ptr< IFrameConverter >
	Typedef to have direct access to the individual FrameConverter modules.

using	OutputAdapterPointer = std::unique_ptr< IOutputAdapter >
	Smart pointer to manage the frame adapter object.

using	OutputSelectorPointer = std::unique_ptr< OutputSelector >
	Smart pointer to manage the object.

using	SetAtomsPointer = std::unique_ptr< SetAtoms >
	Smart pointer to manage the object.

using	SetBoxPointer = std::unique_ptr< SetBox >
	Smart pointer to manage the object.

using	SetForcesPointer = std::unique_ptr< SetForces >
	Smart pointer to manage the object.

using	SetPrecisionPointer = std::unique_ptr< SetPrecision >
	Smart pointer to manage the outputselector object.

using	SetStartTimePointer = std::unique_ptr< SetStartTime >
	Smart pointer to manage the object.

using	SetTimeStepPointer = std::unique_ptr< SetTimeStep >
	Smart pointer to manage the object.

using	SetVelocitiesPointer = std::unique_ptr< SetVelocities >
	Smart pointer to manage the object.

using	EnergyAnalysisFrameIterator = std::vector< EnergyAnalysisFrame >::const_iterator
	Typedef for looping over EnergyFrame.

using	IEnergyAnalysisPointer = std::unique_ptr< IEnergyAnalysis >
	Pointer to the EnergyAnalysisModule classes.

typedef struct gmx::CacheLineAlignedFlag	CacheLineAlignedFlag

template<class T >
using	HostAllocator = Allocator< T, HostAllocationPolicy >
	Memory allocator that uses HostAllocationPolicy. More...

template<class T >
using	HostVector = std::vector< T, HostAllocator< T >>
	Convenience alias for std::vector that uses HostAllocator.

template<class T >
using	PaddedHostVector = PaddedVector< T, HostAllocator< T >>
	Convenience alias for PaddedVector that uses HostAllocator.

using	mode = sycl::access_mode

template<class ElementType >
using	BasicMatrix3x3 = MultiDimArray< std::array< ElementType, 3 *3 >, extents< 3, 3 >>
	Three-by-three matrix of ElementType. More...

using	Matrix3x3 = BasicMatrix3x3< real >
	Three-by-three real number matrix. More...

using	Matrix3x3Span = Matrix3x3::view_type
	Convenience alias for a matrix view.

using	Matrix3x3ConstSpan = Matrix3x3::const_view_type
	Convenience alias for a const matrix view.

typedef std::array < SimulationSignal, eglsNR >	SimulationSignals
	Convenience typedef for the group of signals used.

using	VirialHandling = VirtualSitesHandler::VirialHandling
	VirialHandling is often used outside VirtualSitesHandler class members.

typedef std::array < std::vector< int > , c_ftypeVsiteEnd-c_ftypeVsiteStart >	VsitePbc
	Type for storing PBC atom information for all vsite types in the system.

using	SimulatorFunctionType ) = void(
	Function type for simulator code.

using	LogFilePtr = std::unique_ptr< t_fileio, functor_wrapper< t_fileio, closeLogFile >>
	Simple guard pointer See unique_cptr for details.

using	dynamicExtents2D = extents< dynamic_extent, dynamic_extent >
	Convenience type for often-used two dimensional extents.

using	dynamicExtents3D = extents< dynamic_extent, dynamic_extent, dynamic_extent >
	Convenience type for often-used three dimensional extents.

template<class T , ptrdiff_t... Indices>
using	mdspan = basic_mdspan< T, extents< Indices...>, layout_right, accessor_basic< T >>
	basic_mdspan with wrapped indices, basic_accessor policiy and right-aligned memory layout.

using	ReadCheckpointData = CheckpointData< CheckpointDataOperation::Read >
	Convenience shortcut for reading checkpoint data.

using	WriteCheckpointData = CheckpointData< CheckpointDataOperation::Write >
	Convenience shortcut for writing checkpoint data.

using	Step = int64_t
	Step number.

typedef std::function< void()>	CheckBondedInteractionsCallback
	The function type allowing to request a check of the number of bonded interactions.

using	EnergyContribution = std::function< real(Step, Time)>
	Function type for elements contributing energy.

using	Time = double
	Simulation time.

typedef std::function< void()>	SimulatorRunFunction
	The function type that can be scheduled to be run during the simulator run.

typedef std::function< void(SimulatorRunFunction)>	RegisterRunFunction
	The function type that allows to register run functions.

typedef std::function< void(Step, Time, const RegisterRunFunction &)>	SchedulingFunction
	The function type scheduling run functions for a step / time using a RegisterRunFunction reference.

typedef std::function< void(Step, Time)>	SignallerCallback
	The function type that can be registered to signallers for callback.

typedef std::function< void(gmx_mdoutf *, Step, Time, bool, bool)>	ITrajectoryWriterCallback
	Function type for trajectory writing clients.

typedef std::function< void(Step)>	PropagatorCallback
	Generic callback to the propagator.

typedef std::function< void()>	DomDecCallback
	Callback used by the DomDecHelper object to inform clients about system re-partitioning.

using	ReferenceTemperatureCallback = std::function< void(ArrayRef< const real >, ReferenceTemperatureChangeAlgorithm algorithm)>
	Callback updating the reference temperature.

typedef SimdReal	SimdBitMask
	Define SimdBitMask as a real SIMD register.

typedef std::unique_ptr < IHelpTopic >	HelpTopicPointer
	Smart pointer type to manage a IHelpTopic object.

typedef std::shared_ptr < IOptionsBehavior >	OptionsBehaviorPointer
	Smart pointer for behaviors stored in OptionsBehaviorCollection.

typedef std::random_device	RandomDevice
	Random device. More...

typedef ThreeFry2x64Fast	DefaultRandomEngine
	Default fast and accurate random engine in Gromacs. More...

typedef std::list < SelectionParserValue >	SelectionParserValueList
	Container for a list of SelectionParserValue objects.

typedef std::unique_ptr < SelectionParserValueList >	SelectionParserValueListPointer
	Smart pointer type for managing a SelectionParserValueList.

typedef std::list < SelectionParserParameter >	SelectionParserParameterList
	Container for a list of SelectionParserParameter objects.

typedef std::unique_ptr < SelectionParserParameterList >	SelectionParserParameterListPointer
	Smart pointer type for managing a SelectionParserParameterList.

typedef std::unique_ptr < internal::SelectionData >	SelectionDataPointer
	Smart pointer for managing an internal selection data object.

typedef std::vector < SelectionDataPointer >	SelectionDataList
	Container for storing a list of selections internally.

typedef std::shared_ptr < SelectionTreeElement >	SelectionTreeElementPointer
	Smart pointer type for selection tree element pointers.

using	GpuTasksOnRanks = std::vector< std::vector< GpuTask >>
	Container of compute tasks suitable to run on a GPU e.g. on each rank of a node.

using	GpuTaskAssignment = std::vector< GpuTaskMapping >
	Container of GPU tasks on a rank, specifying the task type and GPU device ID, e.g. potentially ready for consumption by the modules on that rank.

template<class T >
using	AlignedAllocator = Allocator< T, AlignedAllocationPolicy >
	Aligned memory allocator. More...

template<class T >
using	PageAlignedAllocator = Allocator< T, PageAlignedAllocationPolicy >
	PageAligned memory allocator. More...

using	MPI_Comm_ptr = gmx::unique_cptr< MPI_Comm, MPI_Comm_free_wrapper >
	Make a smart pointer for MPI communicators.

typedef std::shared_ptr < TextInputStream >	TextInputStreamPointer
	Shorthand for a smart pointer to a TextInputStream.

typedef std::shared_ptr < TextOutputStream >	TextOutputStreamPointer
	Shorthand for a smart pointer to a TextOutputStream.

typedef std::shared_ptr < IAnalysisDataModule >	AnalysisDataModulePointer
	Smart pointer for managing a generic analysis data module.

typedef ArrayRef< const AnalysisDataValue >	AnalysisDataValuesRef
	Shorthand for reference to an array of data values.

typedef std::shared_ptr < AnalysisDataAverageModule >	AnalysisDataAverageModulePointer
	Smart pointer to manage an AnalysisDataAverageModule object.

typedef std::shared_ptr < AnalysisDataFrameAverageModule >	AnalysisDataFrameAverageModulePointer
	Smart pointer to manage an AnalysisDataFrameAverageModule object.

typedef std::shared_ptr < AnalysisDataDisplacementModule >	AnalysisDataDisplacementModulePointer
	Smart pointer to manage an AnalysisDataDisplacementModule object.

typedef std::unique_ptr < AbstractAverageHistogram >	AverageHistogramPointer
	Smart pointer to manage an AbstractAverageHistogram object.

typedef std::shared_ptr < AnalysisDataSimpleHistogramModule >	AnalysisDataSimpleHistogramModulePointer
	Smart pointer to manage an AnalysisDataSimpleHistogramModule object.

typedef std::shared_ptr < AnalysisDataWeightedHistogramModule >	AnalysisDataWeightedHistogramModulePointer
	Smart pointer to manage an AnalysisDataWeightedHistogramModule object.

typedef std::shared_ptr < AnalysisDataBinAverageModule >	AnalysisDataBinAverageModulePointer
	Smart pointer to manage an AnalysisDataBinAverageModule object.

typedef std::shared_ptr < AnalysisDataLifetimeModule >	AnalysisDataLifetimeModulePointer
	Smart pointer to manage an AnalysisDataLifetimeModule object.

typedef std::shared_ptr < AnalysisDataPlotModule >	AnalysisDataPlotModulePointer
	Smart pointer to manage an AnalysisDataPlotModule object.

typedef std::shared_ptr < AnalysisDataVectorPlotModule >	AnalysisDataVectorPlotModulePointer
	Smart pointer to manage an AnalysisDataVectorPlotModule object.

typedef BasicVector< real >	RVec
	Shorthand for C++ `rvec`-equivalent type.

typedef BasicVector< double >	DVec
	Shorthand for C++ `dvec`-equivalent type.

typedef BasicVector< int >	IVec
	Shorthand for C++ `ivec`-equivalent type.

typedef FloatOption	RealOption
	Typedef for either DoubleOption or FloatOption, depending on precision. More...

typedef FloatOptionInfo	RealOptionInfo
	Typedef for either DoubleOptionInfo or FloatOptionInfo, depending on precision. More...

using	Vector = ::gmx::RVec
	Provide a vector type name with a more stable interface than RVec and a more stable implementation than vec3<>. More...

typedef std::vector< Selection >	SelectionList
	Container of selections used in public selection interfaces.

using	BoxMatrix = std::array< std::array< real, DIM >, DIM >
	A 3x3 matrix data type useful for simulation boxes. More...

typedef std::unique_ptr < TrajectoryAnalysisModuleData >	TrajectoryAnalysisModuleDataPointer
	Smart pointer to manage a TrajectoryAnalysisModuleData object.

typedef std::unique_ptr < TrajectoryAnalysisModule >	TrajectoryAnalysisModulePointer
	Smart pointer to manage a TrajectoryAnalysisModule.

using	Index = std::ptrdiff_t
	Integer type for indexing into arrays or vectors. More...

typedef ExceptionInfo< struct ExceptionInfoErrno_, int >	ExceptionInfoErrno
	Stores `errno` value that triggered the exception.

typedef ExceptionInfo< struct ExceptionInfoApiFunc_, const char * >	ExceptionInfoApiFunction
	Stores the function name that returned the `errno` in ExceptionInfoErrno.

typedef ExceptionInfo< struct ExceptionInfoLocation_, ThrowLocation >	ExceptionInfoLocation
	Stores the location where the exception was thrown.

using	FilePtr = std::unique_ptr< FILE, functor_wrapper< FILE, fclose_wrapper >>
	Simple guard pointer which calls fclose. See unique_cptr for details.

template<typename T , void D = sfree_wrapper>
using	unique_cptr = std::unique_ptr< T, functor_wrapper< T, D >>
	unique_ptr which takes function pointer (has to return void) as template argument

typedef unique_cptr< void >	sfree_guard
	Simple guard which calls sfree. See unique_cptr for details.


using	ClContext = ClHandle< cl_context >
	Convenience declarations.

using	ClCommandQueue = ClHandle< cl_command_queue >

using	ClProgram = ClHandle< cl_program >

using	ClKernel = ClHandle< cl_kernel >

Enumerations
enum	AwhOutputEntryType { AwhOutputEntryType::MetaData, AwhOutputEntryType::CoordValue, AwhOutputEntryType::Pmf, AwhOutputEntryType::Bias, AwhOutputEntryType::Visits, AwhOutputEntryType::Weights, AwhOutputEntryType::Target, AwhOutputEntryType::SharedForceCorrelationVolume, AwhOutputEntryType::SharedFrictionTensor }
	Enum with the AWH variables to write. More...

enum	AwhOutputMetaData { AwhOutputMetaData::NumBlock, AwhOutputMetaData::TargetError, AwhOutputMetaData::ScaledSampleWeight, AwhOutputMetaData::Count }
	Enum with the types of metadata to write. More...

enum	Normalization { Normalization::None, Normalization::Coordinate, Normalization::FreeEnergy, Normalization::Distribution }
	Enum with different ways of normalizing the output. More...

enum	DensityFittingAmplitudeMethod : int { DensityFittingAmplitudeMethod::Unity, DensityFittingAmplitudeMethod::Mass, DensityFittingAmplitudeMethod::Charge, Count }
	The methods that determine how amplitudes are spread on a grid in density guided simulations. More...

enum	QMMMQMMethod { QMMMQMMethod::PBE, QMMMQMMethod::BLYP, QMMMQMMethod::INPUT, Count }
	Enumerator for supported QM methods Also could be INPUT which means external input file provided with the name determined by QMMMParameters::qminputfilename_. More...

enum	CoordinateFileFlags : unsigned long { CoordinateFileFlags::Base = 1 << 0, CoordinateFileFlags::RequireForceOutput = 1 << 1, CoordinateFileFlags::RequireVelocityOutput = 1 << 2, CoordinateFileFlags::RequireAtomConnections = 1 << 3, CoordinateFileFlags::RequireAtomInformation = 1 << 4, CoordinateFileFlags::RequireChangedOutputPrecision = 1 << 5, CoordinateFileFlags::RequireNewFrameStartTime = 1 << 6, CoordinateFileFlags::RequireNewFrameTimeStep = 1 << 7, CoordinateFileFlags::RequireNewBox = 1 << 8, CoordinateFileFlags::RequireCoordinateSelection = 1 << 9, CoordinateFileFlags::Count }
	The enums here define the flags specifying the requirements of different outputadapter modules. More...

enum	ChangeSettingType : int { PreservedIfPresent, Always, Never, Count }
	Enum class for setting basic flags in a t_trxframe.

enum	ChangeAtomsType { PreservedIfPresent, AlwaysFromStructure, Never, Always, Count }
	Enum class for t_atoms settings.

enum	ChangeFrameInfoType { PreservedIfPresent, Always, Count }
	Enum class for setting fields new or not.

enum	ChangeFrameTimeType { PreservedIfPresent, StartTime, TimeStep, Both, Count }
	Enum class for setting frame time from user input.

enum	FrameConverterFlags : unsigned long { FrameConverterFlags::NoGuarantee = 1 << 0, FrameConverterFlags::MoleculesAreWhole = 1 << 1, FrameConverterFlags::NoPBCJumps = 1 << 2, FrameConverterFlags::MoleculeCOMInBox = 1 << 3, FrameConverterFlags::ResidueCOMInBox = 1 << 4, FrameConverterFlags::AtomsInBox = 1 << 5, FrameConverterFlags::UnitCellIsRectangular = 1 << 6, FrameConverterFlags::UnitCellIsTriclinic = 1 << 7, FrameConverterFlags::UnitCellIsCompact = 1 << 8, FrameConverterFlags::SystemIsCenteredInBox = 1 << 9, FrameConverterFlags::FitToReferenceRotTrans = 1 << 10, FrameConverterFlags::FitToReferenceRotTransXY = 1 << 11, FrameConverterFlags::FitToReferenceTranslation = 1 << 12, FrameConverterFlags::FitToReferenceTranslationXY = 1 << 13, FrameConverterFlags::FitToReferenceProgressive = 1 << 14, FrameConverterFlags::NewSystemCenter = 1 << 15, FrameConverterFlags::Count }
	The enums here define the guarantees provided by frameconverters concerning the modifications they provide. More...

enum	HaloType { Coordinates, Forces }
	Whether the halo exchange is of coordinates or forces.

enum	DdRankOrder { DdRankOrder::select, DdRankOrder::interleave, DdRankOrder::pp_pme, DdRankOrder::cartesian, DdRankOrder::Count }
	The options for the domain decomposition MPI task ordering. More...

enum	DlbOption { DlbOption::select, DlbOption::turnOnWhenUseful, DlbOption::no, DlbOption::yes, DlbOption::Count }
	The options for the dynamic load balancing. More...

enum	DDBondedChecking : bool { DDBondedChecking::ExcludeZeroLimit = false, DDBondedChecking::All = true }
	Options for checking bonded interactions. More...

enum	DirectionX : int { Up = 0, Down, Center, Count }
	Direction of neighbouring rank in X-dimension relative to current rank. Used in GPU implementation of PME halo exchange.

enum	DirectionY : int { Left = 0, Right, Center, Count }
	Direction of neighbouring rank in Y-dimension relative to current rank. Used in GPU implementation of PME halo exchange.

enum	FftBackend { FftBackend::Cufft, FftBackend::OclVkfft, FftBackend::Ocl, FftBackend::CuFFTMp, FftBackend::HeFFTe_CUDA, FftBackend::HeFFTe_Sycl_OneMkl, FftBackend::HeFFTe_Sycl_Rocfft, FftBackend::HeFFTe_Sycl_cuFFT, FftBackend::SyclMkl, FftBackend::SyclRocfft, FftBackend::SyclVkfft, FftBackend::SyclBbfft, FftBackend::Sycl, Count }

enum	SpaceGroup : int32_t { SpaceGroup::P1 = 1 }
	Space group in three dimensions. More...

enum	MrcDataMode : int32_t { MrcDataMode::uInt8 = 0, MrcDataMode::int16 = 1, MrcDataMode::float32 = 2, MrcDataMode::complexInt32 = 3, MrcDataMode::complexFloat64 = 4 }
	The type of density data stored in an mrc file. As named in "EMDB Map Distribution Format Description Version 1.01 (c) emdatabank.org 2014" Modes 0-4 are defined by the standard. NOTE only mode 2 is currently implemented and used. More...

enum	DeviceStreamType : int { DeviceStreamType::NonBondedLocal, DeviceStreamType::NonBondedNonLocal, DeviceStreamType::Pme, DeviceStreamType::PmePpTransfer, DeviceStreamType::UpdateAndConstraints, DeviceStreamType::Count }
	Class enum to describe the different logical streams used for GPU work. More...

enum	PinningPolicy : int { CannotBePinned, PinnedIfSupported }
	Helper enum for pinning policy of the allocation of HostAllocationPolicy. More...

enum	Architecture { Architecture::Unknown, Architecture::X86, Architecture::Arm, Architecture::PowerPC, Architecture::RiscV32, Architecture::RiscV64 }
	Enum for GROMACS CPU hardware detection support. More...

enum	IMDMessageType : int { IMDMessageType::Disconnect, IMDMessageType::Energies, IMDMessageType::FCoords, IMDMessageType::Go, IMDMessageType::Handshake, IMDMessageType::Kill, IMDMessageType::Mdcomm, IMDMessageType::Pause, IMDMessageType::TRate, IMDMessageType::IOerror, IMDMessageType::Count }
	Enum for types of IMD messages. More...

enum	DensitySimilarityMeasureMethod : int { DensitySimilarityMeasureMethod::innerProduct, DensitySimilarityMeasureMethod::relativeEntropy, DensitySimilarityMeasureMethod::crossCorrelation, Count }
	The methods that determine how two densities are compared to one another. More...

enum	CheckpointSignal { noSignal = 0, doCheckpoint = 1 }
	Checkpoint signals. More...

enum	ConstraintVariable : int { Positions, Velocities, Derivative, Deriv_FlexCon, Force, ForceDispl }
	Describes supported flavours of constrained updates.

enum	FlexibleConstraintTreatment { FlexibleConstraintTreatment::Include, FlexibleConstraintTreatment::Exclude }
	Tells make_at2con how to treat flexible constraints. More...

enum	NumTempScaleValues { NumTempScaleValues::None = 0, NumTempScaleValues::Single = 1, NumTempScaleValues::Multiple = 2, NumTempScaleValues::Count = 3 }
	Sets the number of different temperature coupling values. More...

enum	GraphState : int { GraphState::Invalid, GraphState::Recording, GraphState::Recorded, GraphState::Instantiated, GraphState::Count }
	State of graph. More...

enum	ResetSignal { noSignal = 0, doResetCounters = 1 }
	Reset signals. More...

enum	StopSignal : int { noSignal = 0, stopAtNextNSStep = 1, stopImmediately = -1 }
	Stop signals. More...

enum	IncompatibilityReasons { FlexibleConstraint, IncompatibleVsite, VsiteConstructingAtomsSplit, ConstrainedAtomOrder, NoCentralConstraintAtom, Count }
	Reasons why the system can be incompatible with update groups.

enum	VSiteCalculatePosition { Yes, No }
	Whether we're calculating the virtual site position.

enum	VSiteCalculateVelocity { Yes, No }
	Whether we're calculating the virtual site velocity.

enum	PbcMode { PbcMode::all, PbcMode::none }
	PBC modes for vsite construction and spreading. More...

enum	VSiteOperation { VSiteOperation::Positions, VSiteOperation::Velocities, VSiteOperation::PositionsAndVelocities, VSiteOperation::Count }
	Whether we calculate vsite positions, velocities, or both. More...

enum	VirtualSiteVirialHandling : int { VirtualSiteVirialHandling::None, VirtualSiteVirialHandling::Pbc, VirtualSiteVirialHandling::NonLinear }
	Tells how to handle virial contributions due to virtual sites. More...

enum	StartingBehavior : int { StartingBehavior::RestartWithAppending, StartingBehavior::RestartWithoutAppending, StartingBehavior::NewSimulation, StartingBehavior::Count }
	Enumeration for describing how mdrun is (re)starting. More...

enum	: std::ptrdiff_t { dynamic_extent = -1 }
	Define constant that signals dynamic extent.

enum	AwhTargetType : int { Constant, Cutoff, Boltzmann, LocalBoltzmann, Count, Default = Constant }
	Target distribution enum.

enum	AwhHistogramGrowthType : int { ExponentialLinear, Linear, Count, Default = ExponentialLinear }
	Weight histogram growth enum.

enum	AwhPotentialType : int { Convolved, Umbrella, Count, Default = Convolved }
	AWH potential type enum.

enum	AwhCoordinateProviderType : int { Pull, FreeEnergyLambda, Count, Default = Pull }
	AWH bias reaction coordinate provider.

enum	CheckpointDataOperation { Read, Write, Count }

enum	AtomLocality : int { AtomLocality::Local = 0, AtomLocality::NonLocal = 1, AtomLocality::All = 2, AtomLocality::Count = 3 }
	Atom locality indicator: local, non-local, all. More...

enum	InteractionLocality : int { InteractionLocality::Local = 0, InteractionLocality::NonLocal = 1, InteractionLocality::Count = 2 }
	Interaction locality indicator: local, non-local, all. More...

enum	AppendingBehavior { AppendingBehavior::Auto, AppendingBehavior::Appending, AppendingBehavior::NoAppending }
	Enumeration for mdrun appending behavior. More...

enum	MtsForceGroups : int { MtsForceGroups::LongrangeNonbonded, MtsForceGroups::Nonbonded, MtsForceGroups::Pair, MtsForceGroups::Dihedral, MtsForceGroups::Angle, MtsForceGroups::Pull, MtsForceGroups::Awh, MtsForceGroups::Count }
	Force group available for selection for multiple time step integration. More...

enum	ReductionRequirement : int { ReductionRequirement::Soon, ReductionRequirement::Eventually }
	Control whether reduction is required soon. More...

enum	ObservablesReducerStatus : int { ObservablesReducerStatus::ReadyToReduce, ObservablesReducerStatus::AlreadyReducedThisStep }
	Report whether the reduction has happened this step. More...

enum	ComputeGlobalsAlgorithm { LeapFrog, VelocityVerlet }
	The different global reduction schemes we know about.

enum	EnergySignallerEvent { EnergyCalculationStep, VirialCalculationStep, FreeEnergyCalculationStep }
	The energy events signalled by the EnergySignaller.

enum	TrajectoryEvent { StateWritingStep, EnergyWritingStep }
	The trajectory writing events.

enum	ModularSimulatorBuilderState { AcceptingClientRegistrations, NotAcceptingClientRegistrations }
	Enum allowing builders to store whether they can accept client registrations.

enum	ReportPreviousStepConservedEnergy { Yes, No, Count }
	Enum describing whether an element is reporting conserved energy from the previous step.

enum	ScheduleOnInitStep { ScheduleOnInitStep::Yes, ScheduleOnInitStep::No, ScheduleOnInitStep::Count }
	Whether the element does schedule on the initial step. More...

enum	NhcUsage { NhcUsage::System, NhcUsage::Barostat, NhcUsage::Count }
	The usages of Nose-Hoover chains. More...

enum	ScaleVelocities { PreStepOnly, PreStepAndPostStep }
	Which velocities the thermostat scales.

enum	IntegrationStage { IntegrationStage::PositionsOnly, IntegrationStage::VelocitiesOnly, IntegrationStage::LeapFrog, IntegrationStage::VelocityVerletPositionsAndVelocities, IntegrationStage::ScaleVelocities, IntegrationStage::ScalePositions, IntegrationStage::Count }
	The different integration types we know about. More...

enum	NumPositionScalingValues { NumPositionScalingValues::None, NumPositionScalingValues::Single, NumPositionScalingValues::Multiple, NumPositionScalingValues::Count }
	Sets the number of different position scaling values. More...

enum	NumVelocityScalingValues { NumVelocityScalingValues::None, NumVelocityScalingValues::Single, NumVelocityScalingValues::Multiple, Count }
	Sets the number of different velocity scaling values. More...

enum	ParrinelloRahmanVelocityScaling { ParrinelloRahmanVelocityScaling::No, ParrinelloRahmanVelocityScaling::Diagonal, ParrinelloRahmanVelocityScaling::Anisotropic, Count }
	Describes the properties of the Parrinello-Rahman pressure scaling matrix. More...

enum	ReferenceTemperatureChangeAlgorithm

enum	EnergySignallerVirialMode { EnergySignallerVirialMode::Off, EnergySignallerVirialMode::OnStep, EnergySignallerVirialMode::OnStepAndNext, EnergySignallerVirialMode::Count }
	When we calculate virial. More...

enum	UseFullStepKE { Yes, No, Count }
	Enum describing whether the thermostat is using full or half step kinetic energy.

enum	KernelCoulombType { KernelCoulombType::RF, KernelCoulombType::EwaldAnalytical, KernelCoulombType::EwaldTabulated }
	List of type of Nbnxm kernel coulomb type implementations. More...

enum	ILJInteractions { ILJInteractions::All, ILJInteractions::Half, ILJInteractions::None }
	The fraction of i-particles for which LJ interactions need to be computed. More...

enum	COMShiftType : int { Residue, Molecule, Count }
	How COM shifting should be applied.

enum	CenteringType : int { Triclinic, Rectangular, Zero, Count }
	Helper enum class to define centering types.

enum	UnitCellType : int { Triclinic, Rectangular, Compact, Count }
	Helper enum class to define Unit cell representation types.

enum	RandomDomain { RandomDomain::Other = 0x00000000, RandomDomain::MaxwellVelocities = 0x00001000, RandomDomain::TestParticleInsertion = 0x00002000, RandomDomain::UpdateCoordinates = 0x00003000, RandomDomain::UpdateConstraints = 0x00004000, RandomDomain::Thermostat = 0x00005000, RandomDomain::Barostat = 0x00006000, RandomDomain::ReplicaExchange = 0x00007000, RandomDomain::ExpandedEnsemble = 0x00008000, RandomDomain::AwhBiasing = 0x00009000 }
	Enumerated values for fixed part of random seed (domain) More...

enum	TaskTarget : int { Auto, Cpu, Gpu }
	Record where a compute task is targetted.

enum	EmulateGpuNonbonded : bool { EmulateGpuNonbonded::No, EmulateGpuNonbonded::Yes }
	Help pass GPU-emulation parameters with type safety. More...

enum	GpuTask : int { GpuTask::Nonbonded, GpuTask::Pme, GpuTask::Count }
	Types of compute tasks that can be run on a GPU. More...

enum	Isotope { H, D, He, Li, Be, B, C, N, O, F, Ne, Na, Mg, Al, Si, P, S, Cl, Ar, K, Ca, Sc, Ti, V, Cr, Mn, Fe, Co, Ni, Cu, Zn, Ga, Ge, As, Se, Br, Kr, Rb, Sr, Y, Zr, Nb, Mo, Tc, Ru, Rh, Pd, Ag, Cd, In, Sn, Sb, Te, I, Xe, Cs, Ba, La, Ce, Pr, Nd, Pm, Sm, Eu, Gd, Tb, Dy, Ho, Er, Tm, Yb, Lu, Hf, Ta, W, Re, Os, Ir, Pt, Au, Hg, Tl, Pb, Bi, Po, At, Rn, Fr, Ra, Ac, Th, Pa, U, Np, Pu, Am, Cm, Bk, Cf, Es, Fm, Md, No, Lr, Rf, Db, Sg, Bh, Hs, Mt, Count }
	isotopes

enum	ErrorCode { eeOK, eeOutOfMemory, eeFileNotFound, eeFileIO, eeInvalidInput, eeInconsistentInput, eeTolerance, eeInstability, eeNotImplemented, eeInvalidValue, eeInvalidCall, eeInternalError, eeAPIError, eeRange, eeParallelConsistency, eeModularSimulator, eeUnknownError }
	Possible error return codes from Gromacs functions. More...

enum	EndianSwapBehavior : int { EndianSwapBehavior::DoNotSwap, EndianSwapBehavior::Swap, EndianSwapBehavior::SwapIfHostIsBigEndian, EndianSwapBehavior::SwapIfHostIsLittleEndian, EndianSwapBehavior::Count }
	Specify endian swapping behavoir. More...

enum	GpuAwareMpiStatus : int { GpuAwareMpiStatus::NotSupported = 0, GpuAwareMpiStatus::Forced, GpuAwareMpiStatus::Supported }
	Enum describing GPU-aware support in underlying MPI library. More...

enum	StripStrings : int { StripStrings::No, StripStrings::Yes }
	Enum class for whether StringToEnumValueConverter will strip strings of leading and trailing whitespace before comparison. More...

enum	TimeUnit : int { Femtoseconds, Picoseconds, Nanoseconds, Microseconds, Milliseconds, Seconds, Count, Default = Picoseconds }
	Time values for TimeUnitManager and legacy oenv module.

enum	OptionFileType : int { Topology, RunInput, Trajectory, Energy, PDB, AtomIndex, Plot, GenericData, Csv, QMInput, Count }
	Purpose of file(s) provided through an option.

Functions
static bool	anyDimUsesProvider (const AwhBiasParams &awhBiasParams, const AwhCoordinateProviderType awhCoordProvider)
	Checks whether any dimension uses the given coordinate provider type. More...

static bool	anyDimUsesProvider (const AwhParams &awhParams, const AwhCoordinateProviderType awhCoordProvider)
	Checks whether any dimension uses the given coordinate provider type. More...

static bool	anyBiasIsScaledByMetric (const AwhParams &awhParams)
	Checks whether any bias scales the target distribution based on the AWH friction metric. More...

std::unique_ptr< Awh >	prepareAwhModule (FILE fplog, const t_inputrec &inputRecord, t_state stateGlobal, const t_commrec commRecord, const gmx_multisim_t multiSimRecord, bool startingFromCheckpoint, bool usingShellParticles, const std::string &biasInitFilename, pull_t *pull_work)
	Makes an Awh and prepares to use it if the user input requests that. More...

static int64_t	countSamples (ArrayRef< const PointState > pointState)
	Count the total number of samples / sample weight over all grid points. More...

static void	ensureStateAndRunConsistency (const BiasParams &params, const BiasState &state)
	Check if the state (loaded from checkpoint) and the run are consistent. More...

double	getDeviationFromPointAlongGridAxis (const BiasGrid &grid, int dimIndex, int pointIndex, double value)
	Get the deviation along one dimension from the given value to a point in the grid. More...

double	getDeviationFromPointAlongGridAxis (const BiasGrid &grid, int dimIndex, int pointIndex1, int pointIndex2)
	Get the deviation from one point to another along one dimension in the grid. More...

bool	pointsAlongLambdaAxis (const BiasGrid &grid, int pointIndex1, int pointIndex2)
	Checks whether two points are along a free energy lambda state axis. More...

bool	pointsHaveDifferentLambda (const BiasGrid &grid, int pointIndex1, int pointIndex2)
	Checks whether two points are different in the free energy lambda state dimension (if any). More...

void	linearArrayIndexToMultiDim (int indexLinear, int ndim, const awh_ivec numPointsDim, awh_ivec indexMulti)
	Convert a linear array index to a multidimensional one. More...

void	linearGridindexToMultiDim (const BiasGrid &grid, int indexLinear, awh_ivec indexMulti)
	Convert a linear grid point index to a multidimensional one. More...

int	multiDimArrayIndexToLinear (const awh_ivec indexMulti, int numDim, const awh_ivec numPointsDim)
	Convert multidimensional array index to a linear one. More...

int	multiDimGridIndexToLinear (const BiasGrid &grid, const awh_ivec indexMulti)
	Convert a multidimensional grid point index to a linear one. More...

bool	advancePointInSubgrid (const BiasGrid &grid, const awh_ivec subgridOrigin, const awh_ivec subgridNpoints, int *gridPointIndex)
	Find the next grid point in the sub-part of the grid given a starting point. More...

static int	pointDistanceAlongAxis (const GridAxis &axis, double x, double x0)
	Returns the point distance between from value x to value x0 along the given axis. More...

static bool	valueIsInGrid (const awh_dvec value, ArrayRef< const GridAxis > axis)
	Query if a value is in range of the grid. More...

static int	getNearestIndexInGrid (const awh_dvec value, ArrayRef< const GridAxis > axis)
	Map a value to the nearest point in the grid. More...

void	mapGridToDataGrid (std::vector< int > *gridpointToDatapoint, const MultiDimArray< std::vector< double >, dynamicExtents2D > &data, int numDataPoints, const std::string &dataFilename, const BiasGrid &grid, const std::string &correctFormatMessage)
	Maps each point in the grid to a point in the data grid. More...

template<typename T >
void	sumOverSimulations (ArrayRef< T > data, MPI_Comm multiSimComm, const bool broadcastWithinSimulation, const t_commrec &commRecord)
	Sum an array over all simulations on main ranks or all ranks of each simulation. More...

bool	haveBiasSharingWithinSimulation (const AwhParams &awhParams)
	Returns if any bias is sharing within a simulation. More...

void	biasesAreCompatibleForSharingBetweenSimulations (const AwhParams &awhParams, ArrayRef< const size_t > pointSize, const BiasSharing &biasSharing)
	Checks whether biases are compatible for sharing between simulations, throws when not. More...

static void	normalizeFreeEnergyAndPmfSum (std::vector< PointState > *pointState)
	Normalizes the free energy and PMF sum. More...

static int	countTrailingZeroRows (const MultiDimArray< std::vector< double >, dynamicExtents2D > &data, int numRows, int numColumns)
	Count trailing data rows containing only zeros. More...

static void	readUserPmfAndTargetDistribution (ArrayRef< const DimParams > dimParams, const BiasGrid &grid, const std::string &filename, int numBias, int biasIndex, std::vector< PointState > *pointState)
	Initializes the PMF and target with data read from an input table. More...

static void	normalizeBlock (AwhEnergyBlock *block, const Bias &bias)
	Normalizes block data for output. More...

void	initCorrelationGridHistory (CorrelationGridHistory *correlationGridHistory, int numCorrelationTensors, int tensorSize, int blockDataListSize)
	Initialize correlation grid history, sets all sizes. More...

CorrelationGridHistory	initCorrelationGridHistoryFromState (const CorrelationGrid &corrGrid)
	Allocate a correlation grid history with the same structure as the given correlation grid. More...

void	updateCorrelationGridHistory (CorrelationGridHistory *corrGridHist, const CorrelationGrid &corrGrid)
	Update the correlation grid history for checkpointing. More...

void	restoreCorrelationGridStateFromHistory (const CorrelationGridHistory &corrGridHist, CorrelationGrid *corrGrid)
	Restores the correlation grid state from the correlation grid history. More...

double	getSqrtDeterminant (gmx::ArrayRef< const double > correlationIntegral)
	Returns the volume element of the correlation metric. More...

const char *	enumValueToString (AwhTargetType enumValue)
	String for target distribution.

const char *	enumValueToString (AwhHistogramGrowthType enumValue)
	String for weight histogram growth.

const char *	enumValueToString (AwhPotentialType enumValue)
	String for AWH potential type.

const char *	enumValueToString (AwhCoordinateProviderType enumValue)
	String for AWH bias reaction coordinate provider.

static double	get_pull_coord_period (const t_pull_coord &pullCoordParams, const t_pbc &pbc, const real intervalLength)
	Gets the period of a pull coordinate. More...

static bool	intervalIsInPeriodicInterval (double origin, double end, double period)
	Checks if the given interval is defined in the correct periodic interval. More...

static bool	valueIsInInterval (double origin, double end, double period, double value)
	Checks if a value is within an interval. More...

static void	checkInputConsistencyInterval (const AwhParams &awhParams, WarningHandler *wi)
	Check if the starting configuration is consistent with the given interval. More...

static void	setStateDependentAwhPullDimParams (AwhDimParams dimParams, const int biasIndex, const int dimIndex, const pull_params_t &pull_params, pull_t pull_work, const t_pbc &pbc, const tensor &compressibility, WarningHandler *wi)
	Sets AWH parameters, for one AWH pull dimension. More...

void	setStateDependentAwhParams (AwhParams awhParams, const pull_params_t &pull_params, pull_t pull_work, const matrix box, PbcType pbcType, const tensor &compressibility, const t_inputrec &inputrec, real initLambda, const gmx_mtop_t &mtop, WarningHandler *wi)
	Sets AWH parameters that need state parameters such as the box vectors. More...

void	checkAwhParams (const AwhParams &awhParams, const t_inputrec &inputrec, WarningHandler *wi)
	Check the AWH parameters. More...

bool	awhHasFepLambdaDimension (const AwhParams &awhParams)
	Returns true when AWH has a bias with a free energy lambda state dimension.

bool	operator== (const DensityFittingParameters &lhs, const DensityFittingParameters &rhs)
	Check if two structs holding density fitting parameters are equal. More...

bool	operator!= (const DensityFittingParameters &lhs, const DensityFittingParameters &rhs)
	Check if two structs holding density fitting parameters are not equal. More...

std::unique_ptr< IMDModule >	createElectricFieldModule ()
	Creates a module for an external electric field. More...

RVec	computeQMBoxVec (const RVec &a, const RVec &b, const RVec &c, real h, real minNorm, real maxNorm)
	Transforms vector a such as distance from it to the plane defined by vectors b and c will be h minimum length will be milL and maximum length maxL. More...

CommandLineProgramContext &	initForCommandLine (int argc, char **argv)
	Initializes the GROMACS library for command-line use. More...

void	finalizeForCommandLine ()
	Deinitializes the GROMACS library after initForCommandLine(). More...

int	processExceptionAtExitForCommandLine (const std::exception &ex)
	Handles an exception and deinitializes after initForCommandLine. More...

int	runCommandLineModule (int argc, char argv[], ICommandLineModule module)
	Implements a main() method that runs a single module. More...

int	runCommandLineModule (int argc, char argv[], const char name, const char *description, std::function< std::unique_ptr< ICommandLineOptionsModule >()> factory)
	Implements a main() method that runs a single module. More...

static int	getFileType (const std::string &filename)
	Get the internal file type from the `filename`. More...

static unsigned long	getSupportedOutputAdapters (int filetype)
	Get the flag representing the requirements for a given file output. More...

static OutputAdapterContainer	addOutputAdapters (const OutputRequirements &requirements, AtomsDataPtr atoms, const Selection &sel, unsigned long abilities)
	Creates a new container object with the user requested IOutputAdapter derived methods attached to it. More...

std::unique_ptr < TrajectoryFrameWriter >	createTrajectoryFrameWriter (const gmx_mtop_t *top, const Selection &sel, const std::string &filename, AtomsDataPtr atoms, OutputRequirements requirements)
	Factory function for TrajectoryFrameWriter. More...

static void	deepCopy_t_trxframe (const t_trxframe &input, t_trxframe copy, RVec xvec, RVec vvec, RVec fvec, int *indexvec)
	Create a deep copy of a t_trxframe `input` into `copy`. More...

static t_trxstatus *	openTNG (const std::string &name, const Selection &sel, const gmx_mtop_t *mtop)
	Method to open TNG file. More...

unsigned long	convertFlag (CoordinateFileFlags flag)
	Conversion of flag to its corresponding unsigned long value.

unsigned long	convertFlag (FrameConverterFlags flag)
	Conversion of flag to its corresponding unsigned long value.

static void	adjustAtomInformation (t_atoms atoms, t_atoms selectionAtoms, const Selection &sel)
	Modify atoms information in coordinate frame to fit output selection. More...

template<bool usePbc>
static auto	packSendBufKernel (Float3 __restrict__ gm_dataPacked, const Float3 __restrict__ gm_data, const int *__restrict__ gm_map, int mapSize, Float3 coordinateShift)

template<bool accumulate>
static auto	unpackRecvBufKernel (Float3 __restrict__ gm_data, const Float3 __restrict__ gm_dataPacked, const int *__restrict__ gm_map, int mapSize)
	unpack non-local force data buffer on the GPU using pre-populated "map" containing index information. More...

template<bool usePbc, class... Args>
static void	launchPackSendBufKernel (const DeviceStream &deviceStream, int xSendSize, Args &&...args)

template<bool accumulateForces, class... Args>
static void	launchUnpackRecvBufKernel (const DeviceStream &deviceStream, int fRecvSize, Args &&...args)

static void	flagInteractionsForType (const int ftype, const InteractionList &il, const reverse_ilist_t &ril, const Range< int > &atomRange, const int numAtomsPerMolecule, ArrayRef< const int > globalAtomIndices, ArrayRef< int > isAssigned)
	Checks whether interactions have been assigned for one function type. More...

static std::string	printMissingInteractionsMolblock (const t_commrec cr, const gmx_reverse_top_t &rt, const char moltypename, const reverse_ilist_t &ril, const Range< int > &atomRange, const int numAtomsPerMolecule, const int numMolecules, const InteractionDefinitions &idef)
	Help print error output when interactions are missing in a molblock. More...

static void	printMissingInteractionsAtoms (const MDLogger &mdlog, const t_commrec *cr, const gmx_mtop_t &mtop, const InteractionDefinitions &idef)
	Help print error output when interactions are missing.

static void	dd_print_missing_interactions (const MDLogger &mdlog, const t_commrec *cr, const int numBondedInteractionsOverAllDomains, const int expectedNumGlobalBondedInteractions, const gmx_mtop_t &top_global, const gmx_localtop_t &top_local, ArrayRef< const RVec > x, const matrix box)
	Print error output when interactions are missing.

static int	computeExpectedNumGlobalBondedInteractions (const gmx_mtop_t &mtop, const DDBondedChecking ddBondedChecking, const bool useUpdateGroups)
	Compute the total bonded interaction count. More...

void	mdAlgorithmsSetupAtomData (const t_commrec cr, const t_inputrec &inputrec, const gmx_mtop_t &top_global, gmx_localtop_t top, t_forcerec fr, ForceBuffers force, MDAtoms mdAtoms, Constraints constr, VirtualSitesHandler vsite, gmx_shellfc_t shellfc)
	Sets atom data for several MD algorithms. More...

void	make_local_shells (const t_commrec cr, const t_mdatoms &md, gmx_shellfc_t shfc)
	Gets the local shell with domain decomposition. More...

bool	check_grid_jump (int64_t step, const gmx_domdec_t dd, real cutoff, const gmx_ddbox_t ddbox, bool bFatal)
	Check whether the DD grid has moved too far for correctness.

void	print_dd_statistics (const t_commrec cr, const t_inputrec &inputrec, FILE fplog)
	Print statistics for domain decomposition communication.

void	dd_partition_system (FILE fplog, const gmx::MDLogger &mdlog, int64_t step, const t_commrec cr, bool bMainState, t_state state_global, const gmx_mtop_t &top_global, const t_inputrec &inputrec, const MDModulesNotifiers &mdModulesNotifiers, gmx::ImdSession imdSession, pull_t pull_work, t_state state_local, gmx::ForceBuffers f, gmx::MDAtoms mdAtoms, gmx_localtop_t top_local, t_forcerec fr, gmx::VirtualSitesHandler vsite, gmx::Constraints constr, t_nrnb nrnb, gmx_wallcycle wcycle, bool bVerbose)
	TODO Remove fplog when group scheme and charge groups are gone. More...

static void	handleCufftError (cufftResult_t status, const char *msg)

static void	handleClfftError (clfftStatus status, const char *msg)
	Throws the exception on clFFT error.

	makePlan ("complex-to-real", rocfft_transform_type_real_inverse, PlanSetupData{rocfft_array_type_hermitian_interleaved, makeComplexStrides(complexGridSizePadded), computeTotalSize(complexGridSizePadded)}, PlanSetupData{rocfft_array_type_real, makeRealStrides(realGridSizePadded), computeTotalSize(realGridSizePadded)}, std::vector< size_t >{size_t(realGridSize[ZZ]), size_t(realGridSize[YY]), size_t(realGridSize[XX])}, pmeStream)

realGrid_ *	realGrid ()),{GMX_RELEASE_ASSERT(performOutOfPlaceFFT,"Only out-of-place FFT is implemented in hipSYCL"

	GMX_RELEASE_ASSERT (allocateRealGrid==false,"Grids need to be pre-allocated")

	GMX_RELEASE_ASSERT (gridSizesInXForEachRank.size()==1 &&gridSizesInYForEachRank.size()==1,"FFT decomposition not implemented with the SYCL rocFFT backend")

template<typename NativeQueue >
static void	launchVkFft (const DeviceBuffer< float > &realGrid, const DeviceBuffer< float > &complexGrid, NativeQueue queue, gmx_fft_direction fftDirection, VkFFTApplication application, VkFFTLaunchParams launchParams)

template<typename ValueType >
void	readKvtCheckpointValue (compat::not_null< ValueType * > value, const std::string &name, const std::string &identifier, const KeyValueTreeObject &kvt)
	Read to a key-value-tree value used for checkpointing. More...

template void	readKvtCheckpointValue (compat::not_null< std::int64_t * > value, const std::string &name, const std::string &identifier, const KeyValueTreeObject &kvt)
	Read to a key-value-tree value used for checkpointing. More...

template void	readKvtCheckpointValue (compat::not_null< real * > value, const std::string &name, const std::string &identifier, const KeyValueTreeObject &kvt)
	Read to a key-value-tree value used for checkpointing. More...

template<typename ValueType >
void	writeKvtCheckpointValue (const ValueType &value, const std::string &name, const std::string &identifier, KeyValueTreeObjectBuilder kvtBuilder)
	Write to a key-value-tree used for checkpointing. More...

template void	writeKvtCheckpointValue (const std::int64_t &value, const std::string &name, const std::string &identifier, KeyValueTreeObjectBuilder kvtBuilder)
	Write to a key-value-tree used for checkpointing. More...

template void	writeKvtCheckpointValue (const real &value, const std::string &name, const std::string &identifier, KeyValueTreeObjectBuilder kvtBuilder)
	Write to a key-value-tree used for checkpointing. More...

size_t	numberOfExpectedDataItems (const MrcDensityMapHeader &header)
	Return the number of density data items that are expected to follow this header. More...

TranslateAndScale	getCoordinateTransformationToLattice (const MrcDensityMapHeader &header)
	Extract the transformation into lattice coordinates. More...

dynamicExtents3D	getDynamicExtents3D (const MrcDensityMapHeader &header)
	Extract the extents of the density data. More...

bool	mrcHeaderIsSane (const MrcDensityMapHeader &header)
	Checks if the values in the header are sane. More...

void	serializeMrcDensityMapHeader (ISerializer *serializer, const MrcDensityMapHeader &mrcHeader)
	Serializes an MrcDensityMapHeader from a given serializer. More...

MrcDensityMapHeader	deserializeMrcDensityMapHeader (ISerializer *serializer)
	Deserializes an MrcDensityMapHeader from a given serializer. More...

static real	smallestAtomMass (const gmx_mtop_t &mtop)

void	repartitionAtomMasses (gmx_mtop_t mtop, bool useFep, real massFactor, WarningHandler wi)
	Scales the smallest masses in the system by up to `massFactor`. More...

template<typename T >
static Float3 *	asGenericFloat3Pointer (T *in)
	Reinterpret-cast any pointer `in` to `Float3`, checking the type compatibility.

template<typename T >
static const Float3 *	asGenericFloat3Pointer (const T *in)
	Reinterpret-cast any const pointer `in` to `Float3`, checking the type compatibility.

template<typename C >
static Float3 *	asGenericFloat3Pointer (C &in)
	Reinterpret-cast any container `in` to `Float3`, checking the type compatibility.

template<typename C >
static const Float3 *	asGenericFloat3Pointer (const C &in)
	Reinterpret-cast any const container `in` to `Float3`, checking the type compatibility.

template<class T1 , class T2 >
bool	operator== (const Allocator< T1, HostAllocationPolicy > &a, const Allocator< T2, HostAllocationPolicy > &b)
	Return true if two allocators are identical. More...

template<typename PinnableVector >
void	changePinningPolicy (PinnableVector *v, PinningPolicy pinningPolicy)
	Helper function for changing the pinning policy of a pinnable vector. More...

void	doDeviceTransfers (const DeviceContext &deviceContext, const DeviceInformation &deviceInfo, ArrayRef< const char > input, ArrayRef< char > output)
	Helper function for GPU test code to be platform agnostic. More...

bool	cpuIsX86Nehalem (const CpuInfo &cpuInfo)
	Return true if the CPU is an Intel x86 Nehalem. More...

bool	cpuIsAmdZen1 (const CpuInfo &cpuInfo)
	Return true if the CPU is a first generation AMD Zen (produced by AMD or Hygon) More...

static DeviceDetectionResult	detectAllDeviceInformation (const PhysicalNodeCommunicator &physicalNodeComm)
	Detect GPUs when that makes sense to attempt. More...

static void	gmx_collect_hardware_mpi (const gmx::CpuInfo &cpuInfo, const PhysicalNodeCommunicator &physicalNodeComm, gmx_hw_info_t *hardwareInfo, [[maybe_unused]] MPI_Comm world)
	Reduce the locally collected `hardwareInfo` over MPI ranks.

std::unique_ptr< gmx_hw_info_t >	gmx_detect_hardware (const PhysicalNodeCommunicator &physicalNodeComm, MPI_Comm libraryCommWorld)
	Run detection and make correct and consistent hardware information available on all ranks. More...

void	logHardwareDetectionWarnings (const gmx::MDLogger &mdlog, const gmx_hw_info_t &hardwareInformation)
	Issue warnings to mdlog that were decided during detection. More...

static bool	runningOnCompatibleOSForAmd ()
	Return true if executing on compatible OS for AMD OpenCL. More...

static bool	runningOnCompatibleHWForNvidia (const DeviceInformation &deviceInfo)
	Return true if executing on compatible GPU for NVIDIA OpenCL. More...

static int	fillSupportedSubGroupSizes (const cl_device_id devId, const DeviceVendor deviceVendor, int resultCapacity, int *result)
	Return the list of sub-group sizes supported by the device. More...

static bool	runningOnCompatibleHWForAmd (const DeviceInformation &deviceInfo)
	Return true if executing on compatible GPU for AMD OpenCL. More...

static DeviceStatus	isDeviceFunctional (const DeviceInformation &deviceInfo)
	Checks that device `deviceInfo` is compatible with GROMACS. More...

std::string	makeOpenClInternalErrorString (const char *message, cl_int status)
	Make an error string following an OpenCL API call. More...

static bool	isDeviceFunctional (const DeviceInformation &deviceInfo, std::string *errorMessage)
	Checks that device `deviceInfo` is sane (ie can run a kernel). More...

static DeviceStatus	checkGpu (size_t deviceId, const DeviceInformation &deviceInfo)
	Check whether the `ocl_gpu_device` is suitable for use by mdrun. More...

int	identifyAvx512FmaUnits ()
	Test whether machine has dual AVX512 FMA units. More...

std::unique_ptr< IMDModule >	createInteractiveMolecularDynamicsModule ()
	Creates a module for interactive molecular dynamics.

static const char *	enumValueToString (IMDMessageType enumValue)
	Names of the IMDType for error messages.

static void	fill_header (IMDHeader *header, IMDMessageType type, int32_t length)
	Fills the header with message and the length argument.

static void	swap_header (IMDHeader *header)
	Swaps the endianess of the header.

static int32_t	imd_read_multiple (IMDSocket socket, char datptr, int32_t toread)
	Reads multiple bytes from socket.

static int32_t	imd_write_multiple (IMDSocket socket, const char datptr, int32_t towrite)
	Writes multiple bytes to socket in analogy to imd_read_multiple.

static int	imd_handshake (IMDSocket *socket)
	Handshake with IMD client.

static int	imd_send_energies (IMDSocket socket, const IMDEnergyBlock energies, char *buffer)
	Send energies using the energy block and the send buffer.

static IMDMessageType	imd_recv_header (IMDSocket socket, int32_t length)
	Receive IMD header from socket, sets the length and returns the IMD message.

static bool	imd_recv_mdcomm (IMDSocket socket, int32_t nforces, int32_t forcendx, float *forces)
	Receive force indices and forces. More...

void	write_IMDgroup_to_file (bool bIMD, t_inputrec ir, const t_state state, const gmx_mtop_t &sys, int nfile, const t_filenm fnm[])
	Writes out the group of atoms selected for interactive manipulation. More...

static int	imd_send_rvecs (IMDSocket socket, int nat, rvec x, char *buffer)
	Send positions from rvec. More...

static bool	rvecs_differ (const rvec v1, const rvec v2)
	Returns true if any component of the two rvecs differs.

static void	shift_positions (const matrix box, rvec x[], const ivec is, int nr)
	Copied and modified from groupcoord.c shift_positions_group().

static void	imd_check_integrator_parallel (const t_inputrec ir, const t_commrec cr)
	Check for non-working integrator / parallel options.

std::unique_ptr< ImdSession >	makeImdSession (const t_inputrec ir, const t_commrec cr, gmx_wallcycle wcycle, gmx_enerdata_t enerd, const gmx_multisim_t ms, const gmx_mtop_t &top_global, const MDLogger &mdlog, gmx::ArrayRef< const gmx::RVec > coords, int nfile, const t_filenm fnm[], const gmx_output_env_t oenv, const ImdOptions &options, StartingBehavior startingBehavior)
	Makes and returns an initialized IMD session, which may be inactive. More...

int	imdsock_winsockinit ()
	Define a function to initialize winsock.

static void	print_IMD_error (const char file, int line, char msg)
	Print a nice error message on UNIX systems, using errno.h.

IMDSocket *	imdsock_create ()
	Create an IMD main socket. More...

void	imd_sleep (unsigned int seconds)
	Portability wrapper around sleep function.

int	imdsock_bind (IMDSocket *sock, int port)
	Bind the IMD socket to address and port. More...

int	imd_sock_listen (IMDSocket *sock)
	Set socket to listening state. More...

IMDSocket *	imdsock_accept (IMDSocket *sock)
	Accept incoming connection and redirect to client socket. More...

int	imdsock_getport (IMDSocket sock, int port)
	Get the port number used for IMD connection. More...

int	imd_htonl (int src)
	Portability wrapper around system htonl function.

int	imd_ntohl (int src)
	Portability wrapper around system ntohl function.

int	imdsock_write (IMDSocket sock, const char buffer, int length)
	Write to socket. More...

int	imdsock_read (IMDSocket sock, char buffer, int length)
	Read from socket. More...

void	imdsock_shutdown (IMDSocket *sock)
	Shutdown the socket. More...

int	imdsock_destroy (IMDSocket *sock)
	Close the socket and free the sock struct memory. More...

int	imdsock_tryread (IMDSocket *sock, int timeoutsec, int timeoutusec)
	Try to read from the socket. More...

bool	buildSupportsListedForcesGpu (std::string *error)
	Checks whether the GROMACS build allows to compute bonded interactions on a GPU. More...

bool	inputSupportsListedForcesGpu (const t_inputrec &ir, const gmx_mtop_t &mtop, std::string *error)
	Checks whether the input system allows to compute bonded interactions on a GPU. More...

static bool	someInteractionsCanRunOnGpu (const InteractionLists &ilists)
	Returns whether there are any interactions in ilists suitable for a GPU.

static bool	bondedInteractionsCanRunOnGpu (const gmx_mtop_t &mtop)
	Returns whether there are any bonded interactions in the global topology suitable for a GPU.

static int	chooseSubGroupSizeForDevice (const DeviceInformation &deviceInfo)

static bool	fTypeHasPerturbedEntries (const InteractionDefinitions &idef, int fType)
	Return whether function type `fType` in `idef` has perturbed interactions.

static void	convertIlistToNbnxnOrder (const InteractionList &src, HostInteractionList *dest, int numAtomsPerInteraction, ArrayRef< const int > nbnxnAtomOrder)
	Converts `src` with atom indices in state order to `dest` in nbnxn order.

static int	roundUpToFactor (const int input, const int factor)
	Returns `input` rounded up to the closest multiple of `factor`.

template<bool calcVir, bool calcEner>
auto	bondedKernel (sycl::handler &cgh, const BondedGpuKernelParameters &kernelParams, const DeviceBuffer< t_iatom > gm_iatoms_[numFTypesOnGpu], float __restrict__ gm_vTot, const t_iparams __restrict__ gm_forceParams_, const sycl::float4 __restrict__ gm_xq_, Float3 __restrict__ gm_f_, Float3 *__restrict__ gm_fShift_)

static void	PrintTo (const RVec &value, std::ostream *os)
	Print an RVec to `os`.

static void	PrintTo (const PaddedVector< RVec > &vector, std::ostream *os)
	Print a padded vector of RVec to `os`.

void	normalizeSumPositiveValuesToUnity (ArrayRef< float > data)
	Divide all values of a view by a constant so that the sum of all its positive values is one. More...

void	exponentialMovingAverageStateAsKeyValueTree (KeyValueTreeObjectBuilder builder, const ExponentialMovingAverageState &state)
	Convert the exponential moving average state as key-value-tree object.

ExponentialMovingAverageState	exponentialMovingAverageStateFromKeyValueTree (const KeyValueTreeObject &object)
	Sets the exponential moving average state from a key-value-tree object. More...

unsigned int	log2I (std::uint32_t x)
	Compute floor of logarithm to base 2, 32 bit unsigned argument. More...

unsigned int	log2I (std::uint64_t x)
	Compute floor of logarithm to base 2, 64 bit unsigned argument. More...

unsigned int	log2I (std::int32_t x)
	Compute floor of logarithm to base 2, 32 bit signed argument. More...

unsigned int	log2I (std::int64_t x)
	Compute floor of logarithm to base 2, 64 bit signed argument. More...

std::int64_t	greatestCommonDivisor (std::int64_t p, std::int64_t q)
	Find greatest common divisor of two numbers. More...

double	erfinv (double x)
	Inverse error function, double precision. More...

float	erfinv (float x)
	Inverse error function, single precision. More...

IntegerBox	spreadRangeWithinLattice (const IVec &center, dynamicExtents3D extent, IVec range)
	Construct a box that holds all indices that are not more than a given range remote from center coordinates and still within a given lattice extent. More...

static void	assertMatrixIsBoxMatrix (const Matrix3x3 gmx_used_in_debug &m)
	Assert that the matrix `m` describes a simulation box. More...

static void	assertMatrixIsBoxMatrix (const matrix gmx_used_in_debug m)
	Assert that the matrix `m` describes a simulation box. More...

static void	multiplyVectorByTransposeOfBoxMatrix (const Matrix3x3 &m, const rvec v, rvec result)
	Multiply vector `v` by the transpose of the box matrix `m`, relying on the fact that the upper triangle of the matrix is zero.

static RVec	multiplyVectorByTransposeOfBoxMatrix (const Matrix3x3 &m, const RVec &v)
	Multiply vector `v` by the transpose of the box matrix `m`, relying on the fact that the upper triangle of the matrix is zero.

static Matrix3x3	multiplyBoxMatrices (const Matrix3x3 &a, const Matrix3x3 &b)
	Multiply box matrices, relying on the fact that their upper triangle is zero.

static Matrix3x3	multiplyBoxMatrices (const Matrix3x3 &a, const matrix b)
	Multiply box matrices, relying on the fact that their upper triangle is zero.

static Matrix3x3	invertBoxMatrix (const Matrix3x3 &src)
	Invert a simulation-box matrix. More...

static void	invertBoxMatrix (const matrix src, matrix dest)
	Invert a simulation-box matrix in `src`, return in `dest`. More...

void	invertMatrix (const matrix src, matrix dest)
	Invert a general 3x3 matrix in `src`, return in `dest`. More...

constexpr real	determinant (Matrix3x3ConstSpan matrix)
	Determinant of a 3x3 matrix.

constexpr real	trace (Matrix3x3ConstSpan matrixView)
	Calculates the trace of a 3x3 matrix view.

template<typename ElementType , int N, int M = N>
MultiDimArray< std::array < ElementType, N *M >, extents < N, M > >	diagonalMatrix (const ElementType value)
	Create a diagonal matrix of ElementType with N * M elements. More...

template<typename ElementType , int N, int M = N>
MultiDimArray< std::array < ElementType, N *M >, extents < N, M > >	identityMatrix ()
	Create an identity matrix of ElementType with N * M elements. More...

Matrix3x3	transpose (Matrix3x3ConstSpan matrixView)
	Calculate the transpose of a 3x3 matrix, from its view.

void	matrixVectorMultiply (Matrix3x3ConstSpan matrix, RVec *v)
	Multiply matrix with vector.

static Matrix3x3	createMatrix3x3FromLegacyMatrix (const matrix legacyMatrix)
	Create new matrix type from legacy type.

static void	fillLegacyMatrix (Matrix3x3ConstSpan newMatrix, matrix legacyMatrix)
	Fill legacy matrix from new matrix type.

template<typename ElementType >
BasicVector< ElementType >	multiplyVectorByMatrix (const BasicMatrix3x3< ElementType > &m, const rvec v)
	Return the product of multiplying the vector `v` by the 3x3 matrix `m`.

template<typename ElementType >
BasicMatrix3x3< ElementType >	operator+ (const BasicMatrix3x3< ElementType > &a, const BasicMatrix3x3< ElementType > &b)
	Return the sum of two 3x3 matrices `a` and `b`.

template<typename ElementType >
BasicMatrix3x3< ElementType >	operator* (const BasicMatrix3x3< ElementType > &m, const ElementType s)
	Return the product of multiplying the 3x3 matrix `m` by the scalar `s`.

template<typename ElementType >
BasicMatrix3x3< ElementType >	operator* (const ElementType s, const BasicMatrix3x3< ElementType > &m)
	Return the product of multiplying the 3x3 matrix `m` by the scalar `s`.

template<typename ElementType >
BasicVector< ElementType >	diagonal (const BasicMatrix3x3< ElementType > &m)
	Return a vector that is the diagonal of the 3x3 matrix `m`.

template<class TContainer , class Extents >
constexpr MultiDimArray < TContainer, Extents > ::const_iterator	begin (const MultiDimArray< TContainer, Extents > &multiDimArray)
	Free MultiDimArray begin function addressing its contiguous memory.

template<class TContainer , class Extents >
constexpr MultiDimArray < TContainer, Extents > ::iterator	begin (MultiDimArray< TContainer, Extents > &multiDimArray)
	Free MultiDimArray begin function addressing its contiguous memory.

template<class TContainer , class Extents >
constexpr MultiDimArray < TContainer, Extents > ::const_iterator	end (const MultiDimArray< TContainer, Extents > &multiDimArray)
	Free MultiDimArray end function addressing its contiguous memory.

template<class TContainer , class Extents >
constexpr MultiDimArray < TContainer, Extents > ::iterator	end (MultiDimArray< TContainer, Extents > &multiDimArray)
	Free MultiDimArray end function addressing its contiguous memory.

template<class TContainer , class Extents >
void	swap (MultiDimArray< TContainer, Extents > &a, MultiDimArray< TContainer, Extents > &b) noexcept
	Swap function.

OptimisationResult	nelderMead (const std::function< real(ArrayRef< const real >)> &functionToMinimize, ArrayRef< const real > initialGuess, real minimumRelativeSimplexLength=1e-8, int maxSteps=10'000)
	Derivative-free downhill simplex optimisation. More...

std::unique_ptr< BoxDeformation >	buildBoxDeformation (const Matrix3x3 &initialBox, DDRole ddRole, NumRanks numRanks, MPI_Comm communicator, const t_inputrec &inputrec)
	Factory function for box deformation module. More...

void	setBoxDeformationFlowMatrix (const matrix boxDeformationVelocity, const matrix box, matrix flowMatrix)
	Set a matrix for computing the flow velocity at coordinates. More...

static CheckpointSignal	convertToCheckpointSignal (signed char sig)
	Convert signed char (as used by SimulationSignal) to CheckpointSignal enum. More...

static void	clear_constraint_quantity_nonlocal (const gmx_domdec_t &dd, ArrayRef< RVec > q)
	Clears constraint quantities for atoms in nonlocal region.

void	too_many_constraint_warnings (ConstraintAlgorithm eConstrAlg, int warncount)
	Generate a fatal error because of too many LINCS/SETTLE warnings.

static void	write_constr_pdb (const char fn, const char title, const gmx_mtop_t &mtop, int start, int homenr, const t_commrec *cr, ArrayRef< const RVec > x, const matrix box)
	Writes out coordinates.

static void	dump_confs (FILE log, int64_t step, const gmx_mtop_t &mtop, int start, int homenr, const t_commrec cr, ArrayRef< const RVec > x, ArrayRef< const RVec > xprime, const matrix box)
	Writes out domain contents to help diagnose crashes.

FlexibleConstraintTreatment	flexibleConstraintTreatment (bool haveDynamicsIntegrator)
	Returns the flexible constraint treatment depending on whether the integrator is dynamic.

static ListOfLists< int >	makeAtomsToConstraintsList (int numAtoms, ArrayRef< const InteractionList > ilists, ArrayRef< const t_iparams > iparams, FlexibleConstraintTreatment flexibleConstraintTreatment)
	Returns a block struct to go from atoms to constraints. More...

ListOfLists< int >	make_at2con (int numAtoms, ArrayRef< const InteractionList > ilist, ArrayRef< const t_iparams > iparams, FlexibleConstraintTreatment flexibleConstraintTreatment)
	Returns a ListOfLists object to go from atoms to constraints. More...

ListOfLists< int >	make_at2con (const gmx_moltype_t &moltype, gmx::ArrayRef< const t_iparams > iparams, FlexibleConstraintTreatment flexibleConstraintTreatment)
	Returns a ListOfLists object to go from atoms to constraints. More...

int	countFlexibleConstraints (ArrayRef< const InteractionList > ilist, ArrayRef< const t_iparams > iparams)
	Return the number of flexible constraints in the `ilist` and `iparams`.

static std::vector< int >	make_at2settle (int natoms, const InteractionList &ilist)
	Returns the index of the settle to which each atom belongs.

static std::vector < ListOfLists< int > >	makeAtomToConstraintMappings (const gmx_mtop_t &mtop, FlexibleConstraintTreatment flexibleConstraintTreatment)
	Makes a per-moleculetype container of mappings from atom indices to constraint indices. More...

void	do_constrain_first (FILE log, gmx::Constraints constr, const t_inputrec *inputrec, int numAtoms, int numHomeAtoms, ArrayRefWithPadding< RVec > x, ArrayRefWithPadding< RVec > v, const matrix box, real lambda)
	Constrain the initial coordinates and velocities.

void	constrain_velocities (gmx::Constraints constr, bool do_log, bool do_ene, int64_t step, t_state state, real *dvdlambda, bool computeVirial, tensor constraintsVirial)
	Constrain velocities only. More...

void	constrain_coordinates (gmx::Constraints constr, bool do_log, bool do_ene, int64_t step, t_state state, ArrayRefWithPadding< RVec > xp, real *dvdlambda, bool computeVirial, tensor constraintsVirial)
	Constraint coordinates. More...

static bool	isConstraintFlexible (ArrayRef< const t_iparams > iparams, int iparamsIndex)
	Returns whether constraint with parameter `iparamsIndex` is a flexible constraint.

const int *	constr_iatomptr (gmx::ArrayRef< const int > iatom_constr, gmx::ArrayRef< const int > iatom_constrnc, int con)
	Returns the constraint iatoms for a constraint number con which comes from a list where F_CONSTR and F_CONSTRNC constraints are concatenated.

static void	constr_recur (const ListOfLists< int > &at2con, const InteractionLists &ilist, gmx::ArrayRef< const t_iparams > iparams, gmx_bool bTopB, int at, int depth, int nc, ArrayRef< int > path, real r0, real r1, real r2max, int count)
	Recursing function to help find all adjacent constraints.

static real	constr_r_max_moltype (const gmx_moltype_t molt, gmx::ArrayRef< const t_iparams > iparams, const t_inputrec ir)
	Find the interaction radius needed for constraints for this molecule type.

real	constr_r_max (const MDLogger &mdlog, const gmx_mtop_t mtop, const t_inputrec ir)
	Returns an estimate of the maximum distance between atoms required for LINCS.

real	calculateAcceptanceWeight (LambdaWeightCalculation calculationMode, real lambdaEnergyDifference)
	Calculates the acceptance weight for a lambda state transition. More...

gmx::EnumerationArray < FreeEnergyPerturbationCouplingType, real >	currentLambdas (int64_t step, const t_lambda &fepvals, int currentLambdaState)
	Evaluate the current lambdas. More...

void	launchForceReductionKernel (int numAtoms, int atomStart, bool addRvecForce, bool accumulate, const DeviceBuffer< Float3 > d_nbnxmForceToAdd, const DeviceBuffer< Float3 > d_rvecForceToAdd, DeviceBuffer< Float3 > d_baseForce, DeviceBuffer< int > d_cell, const DeviceStream &deviceStream, DeviceBuffer< uint64_t > d_forcesReadyNvshmemFlags, const uint64_t forcesReadyNvshmemFlagsCounter)
	Backend-specific function to launch GPU Force Reduction kernel. More...

template<bool addRvecForce, bool accumulateForce>
static auto	reduceKernel (const Float3 __restrict__ gm_nbnxmForce, const Float3 __restrict__ gm_rvecForceToAdd, Float3 __restrict__ gm_forceTotal, const int __restrict__ gm_cell, const int atomStart)
	Function returning the force reduction kernel lambda.

template<bool addRvecForce, bool accumulateForce>
static void	launchReductionKernel_ (const int numAtoms, const int atomStart, const DeviceBuffer< Float3 > &d_nbnxmForce, const DeviceBuffer< Float3 > &d_rvecForceToAdd, DeviceBuffer< Float3 > &d_forceTotal, const DeviceBuffer< int > &d_cell, const DeviceStream &deviceStream)
	Force reduction SYCL kernel launch code.

void	launchLeapFrogKernel (int numAtoms, DeviceBuffer< Float3 > d_x, DeviceBuffer< Float3 > d_xp, DeviceBuffer< Float3 > d_v, DeviceBuffer< Float3 > d_f, DeviceBuffer< float > d_inverseMasses, float dt, bool doTemperatureScaling, int numTempScaleValues, DeviceBuffer< unsigned short > d_tempScaleGroups, DeviceBuffer< float > d_lambdas, ParrinelloRahmanVelocityScaling parrinelloRahmanVelocityScaling, Float3 prVelocityScalingMatrixDiagonal, const DeviceStream &deviceStream)
	Backend-specific function to launch GPU Leap Frog kernel. More...

template<NumTempScaleValues numTempScaleValues, ParrinelloRahmanVelocityScaling parrinelloRahmanVelocityScaling>
auto	leapFrogKernel (Float3 __restrict__ gm_x, Float3 __restrict__ gm_xp, Float3 __restrict__ gm_v, const Float3 __restrict__ gm_f, const float __restrict__ gm_inverseMasses, float dt, const float __restrict__ gm_lambdas, const unsigned short *__restrict__ gm_tempScaleGroups, Float3 prVelocityScalingMatrixDiagonal)
	Main kernel for the Leap-Frog integrator. More...

template<NumTempScaleValues numTempScaleValues, ParrinelloRahmanVelocityScaling parrinelloRahmanVelocityScaling, class... Args>
static void	launchLeapFrogKernel (const DeviceStream &deviceStream, int numAtoms, Args &&...args)
	Leap Frog SYCL kernel launch code.

static NumTempScaleValues	getTempScalingType (bool doTemperatureScaling, int numTempScaleValues)
	Convert `doTemperatureScaling` and `numTempScaleValues` to NumTempScaleValues.

template<class... Args>
static void	launchLeapFrogKernel (NumTempScaleValues tempScalingType, ParrinelloRahmanVelocityScaling parrinelloRahmanVelocityScaling, Args &&...args)
	Select templated kernel and launch it.

real	lincs_rmsd (const Lincs *lincsd)
	Return the RMSD of the constraint.

static void	lincs_matrix_expand (const Lincs &lincsd, const Task &li_task, gmx::ArrayRef< const real > blcc, gmx::ArrayRef< real > rhs1, gmx::ArrayRef< real > rhs2, gmx::ArrayRef< real > sol)
	Do a set of nrec LINCS matrix multiplications. More...

static void	lincs_update_atoms_noind (int ncons, gmx::ArrayRef< const AtomPair > atoms, real preFactor, gmx::ArrayRef< const real > fac, gmx::ArrayRef< const gmx::RVec > r, gmx::ArrayRef< const real > invmass, rvec *x)
	Update atomic coordinates when an index is not required.

static void	lincs_update_atoms_ind (gmx::ArrayRef< const int > ind, gmx::ArrayRef< const AtomPair > atoms, real preFactor, gmx::ArrayRef< const real > fac, gmx::ArrayRef< const gmx::RVec > r, gmx::ArrayRef< const real > invmass, rvec *x)
	Update atomic coordinates when an index is required.

static void	lincs_update_atoms (Lincs li, int th, real preFactor, gmx::ArrayRef< const real > fac, gmx::ArrayRef< const gmx::RVec > r, gmx::ArrayRef< const real > invmass, rvec x)
	Update coordinates for atoms.

static void	do_lincsp (ArrayRefWithPadding< const RVec > xPadded, ArrayRefWithPadding< RVec > fPadded, ArrayRef< RVec > fp, t_pbc pbc, Lincs lincsd, int th, ArrayRef< const real > invmass, ConstraintVariable econq, bool bCalcDHDL, bool bCalcVir, tensor rmdf)
	LINCS projection, works on derivatives of the coordinates.

static gmx_unused void	calc_dist_iter (int b0, int b1, gmx::ArrayRef< const AtomPair > atoms, const rvec gmx_restrict xp, const real gmx_restrict bllen, const real gmx_restrict blc, const t_pbc pbc, real wfac, real gmx_restrict rhs, real gmx_restrict sol, bool *bWarn)
	Determine the distances and right-hand side for the next iteration.

static void	do_lincs (ArrayRefWithPadding< const RVec > xPadded, ArrayRefWithPadding< RVec > xpPadded, const matrix box, t_pbc pbc, Lincs lincsd, int th, ArrayRef< const real > invmass, const t_commrec cr, bool bCalcDHDL, real wangle, bool bWarn, real invdt, ArrayRef< RVec > vRef, bool bCalcVir, tensor vir_r_m_dr, gmx_wallcycle *wcycle)
	Implements LINCS constraining.

static void	set_lincs_matrix_task (Lincs li, Task li_task, ArrayRef< const real > invmass, int ncc_triangle, int nCrossTaskTriangles)
	Sets the elements in the LINCS matrix for task task.

static void	set_lincs_matrix (Lincs *li, ArrayRef< const real > invmass, real lambda)
	Sets the elements in the LINCS matrix.

static int	count_triangle_constraints (const InteractionLists &ilist, const ListOfLists< int > &at2con)
	Finds all triangles of atoms that share constraints to a central atom.

static bool	more_than_two_sequential_constraints (const InteractionLists &ilist, const ListOfLists< int > &at2con)
	Finds sequences of sequential constraints.

Lincs *	init_lincs (FILE fplog, const gmx_mtop_t &mtop, int nflexcon_global, ArrayRef< const ListOfLists< int >> atomsToConstraintsPerMolType, bool bPLINCS, int nIter, int nProjOrder, ObservablesReducerBuilder observablesReducerBuilder)
	Initializes and returns the lincs data struct.

void	done_lincs (Lincs *li)
	Destructs the lincs object when it is not nullptr.

static void	lincs_thread_setup (Lincs *li, int natoms)
	Sets up the work division over the threads.

static void	assign_constraint (Lincs *li, int constraint_index, int a1, int a2, real lenA, real lenB, const ListOfLists< int > &at2con)
	Assign a constraint.

static void	check_assign_connected (Lincs *li, gmx::ArrayRef< const int > iatom, const InteractionDefinitions &idef, bool bDynamics, int a1, int a2, const ListOfLists< int > &at2con)
	Check if constraint with topology index constraint_index is connected to other constraints, and if so add those connected constraints to our task.

static void	check_assign_triangle (Lincs *li, gmx::ArrayRef< const int > iatom, const InteractionDefinitions &idef, bool bDynamics, int constraint_index, int a1, int a2, const ListOfLists< int > &at2con)
	Check if constraint with topology index constraint_index is involved in a constraint triangle, and if so add the other two constraints in the triangle to our task.

static void	set_matrix_indices (Lincs *li, const Task &li_task, const ListOfLists< int > &at2con, bool bSortMatrix)
	Sets matrix indices.

void	set_lincs (const InteractionDefinitions &idef, int numAtoms, ArrayRef< const real > invmass, real lambda, bool bDynamics, const t_commrec cr, Lincs li)
	Initialize lincs stuff.

static void	lincs_warning (gmx_domdec_t dd, ArrayRef< const RVec > x, ArrayRef< const RVec > xprime, t_pbc pbc, int ncons, gmx::ArrayRef< const AtomPair > atoms, gmx::ArrayRef< const real > bllen, real wangle, int maxwarn, int *warncount)
	Issues a warning when LINCS constraints cannot be satisfied.

static LincsDeviations	makeLincsDeviations (const Lincs &lincsd, ArrayRef< const RVec > x, const t_pbc *pbc)
	Determine how well the constraints have been satisfied.

bool	constrain_lincs (bool computeRmsd, const t_inputrec &ir, int64_t step, Lincs lincsd, ArrayRef< const real > invmass, const t_commrec cr, const gmx_multisim_t ms, ArrayRefWithPadding< const RVec > x, ArrayRefWithPadding< RVec > xprime, ArrayRef< RVec > min_proj, const matrix box, t_pbc pbc, bool hasMassPerturbed, real lambda, real dvdlambda, real invdt, ArrayRef< RVec > v, bool bCalcVir, tensor vir_r_m_dr, ConstraintVariable econq, t_nrnb nrnb, int maxwarn, int warncount, gmx_wallcycle wcycle)
	Applies LINCS constraints. More...

void	addWithCoupled (ArrayRef< const int > iatoms, const int stride, ArrayRef< const std::vector< AtomsAdjacencyListElement >> atomsAdjacencyList, ArrayRef< int > splitMap, const int c, int *currentMapIndex)
	Add constraint to `splitMap` with all constraints coupled to it. More...

void	launchLincsGpuKernel (LincsGpuKernelParameters *kernelParams, const DeviceBuffer< Float3 > &d_x, DeviceBuffer< Float3 > d_xp, bool updateVelocities, DeviceBuffer< Float3 > d_v, real invdt, bool computeVirial, const DeviceStream &deviceStream)
	Backend-specific function to launch LINCS kernel. More...

template<bool updateVelocities, bool computeVirial, bool haveCoupledConstraints>
auto	lincsKernel (sycl::handler &cgh, const int numConstraintsThreads, const AtomPair __restrict__ gm_constraints, const float __restrict__ gm_constraintsTargetLengths, const int __restrict__ gm_coupledConstraintsCounts, const int __restrict__ gm_coupledConstraintsIndices, const float __restrict__ gm_massFactors, float __restrict__ gm_matrixA, const float __restrict__ gm_inverseMasses, const int numIterations, const int expansionOrder, const Float3 __restrict__ gm_x, Float3 __restrict__ gm_xp, const float invdt, Float3 __restrict__ gm_v, float *__restrict__ gm_virialScaled, PbcAiuc pbcAiuc)
	Main kernel for LINCS constraints. More...

template<bool updateVelocities, bool computeVirial, bool haveCoupledConstraints, class... Args>
static void	launchLincsKernel (const DeviceStream &deviceStream, const int numConstraintsThreads, Args &&...args)

template<class... Args>
static void	launchLincsKernel (bool updateVelocities, bool computeVirial, bool haveCoupledConstraints, Args &&...args)
	Select templated kernel and launch it.

template<typename... Args>
std::unique_ptr< Constraints >	makeConstraints (const gmx_mtop_t &mtop, const t_inputrec &ir, pull_t *pull_work, bool havePullConstraintsWork, bool doEssentialDynamics, Args &&...args)
	Factory function for Constraints. More...

std::unique_ptr< MDAtoms >	makeMDAtoms (FILE *fp, const gmx_mtop_t &mtop, const t_inputrec &ir, bool useGpuForPme)
	Builder function for MdAtomsWrapper. More...

static ResetSignal	convertToResetSignal (signed char sig)
	Convert signed char (as used by SimulationSignal) to ResetSignal enum. More...

static void	initializeProjectionMatrix (const real invmO, const real invmH, const real dOH, const real dHH, matrix inverseCouplingMatrix)
	Initializes a projection matrix. More...

SettleParameters	settleParameters (real mO, real mH, real invmO, real invmH, real dOH, real dHH)
	Computes and returns settle parameters. More...

void	settle_proj (const SettleData &settled, ConstraintVariable econq, int nsettle, const int iatoms[], const t_pbc *pbc,ArrayRef< const RVec > x, ArrayRef< RVec > der, ArrayRef< RVec > derp, int CalcVirAtomEnd, tensor vir_r_m_dder)
	Analytical algorithm to subtract the components of derivatives of coordinates working on settle type constraint.

template<typename T , typename TypeBool , int packSize, typename TypePbc , bool bCorrectVelocity, bool bCalcVirial>
static void	settleTemplate (const SettleData &settled, int settleStart, int settleEnd, const TypePbc pbc, const real x, real xprime, real invdt, real gmx_restrict v, tensor vir_r_m_dr, bool bErrorHasOccurred)
	The actual settle code, templated for real/SimdReal and for optimization.

template<typename T , typename TypeBool , int packSize, typename TypePbc >
static void	settleTemplateWrapper (const SettleData &settled, int nthread, int thread, TypePbc pbc, const real x[], real xprime[], real invdt, real v, bool bCalcVirial, tensor vir_r_m_dr, bool bErrorHasOccurred)
	Wrapper template function that divides the settles over threads and instantiates the core template with instantiated booleans.

void	csettle (const SettleData &settled,int nthread,int thread,const t_pbc pbc,ArrayRefWithPadding< const RVec > x,ArrayRefWithPadding< RVec > xprime,real invdt,ArrayRefWithPadding< RVec > v,bool bCalcVirial,tensor vir_r_m_dr,bool bErrorHasOccurred)
	Constrain coordinates using SETTLE. Can be called on any number of threads.

void	launchSettleGpuKernel (int numSettles, const DeviceBuffer< WaterMolecule > &d_atomIds, const SettleParameters &settleParameters, const DeviceBuffer< Float3 > &d_x, DeviceBuffer< Float3 > d_xp, bool updateVelocities, DeviceBuffer< Float3 > d_v, real invdt, bool computeVirial, DeviceBuffer< float > d_virialScaled, const PbcAiuc &pbcAiuc, const DeviceStream &deviceStream)
	Apply SETTLE. More...

template<bool updateVelocities, bool computeVirial>
auto	settleKernel (sycl::handler &cgh, const int numSettles, const WaterMolecule __restrict__ gm_settles, SettleParameters pars, const Float3 __restrict__ gm_x, Float3 __restrict__ gm_xp, float invdt, Float3 __restrict__ gm_v, float *__restrict__ gm_virialScaled, PbcAiuc pbcAiuc)
	Function returning the SETTLE kernel lambda.

template<bool updateVelocities, bool computeVirial, class... Args>
static void	launchSettleKernel (const DeviceStream &deviceStream, int numSettles, Args &&...args)
	SETTLE SYCL kernel launch code.

template<class... Args>
static void	launchSettleKernel (bool updateVelocities, bool computeVirial, Args &&...args)
	Select templated kernel and launch it.

static int	pcomp (const void p1, const void p2)
	Compares sort blocks.

static void	pr_sortblock (FILE fp, const char title, gmx::ArrayRef< const t_sortblock > sb)
	Prints sortblocks.

static void	resizeLagrangianData (shakedata *shaked, int ncons)
	Reallocates a vector.

void	make_shake_sblock_serial (shakedata shaked, InteractionDefinitions idef, int numAtoms)
	Make SHAKE blocks when not using DD.

void	make_shake_sblock_dd (shakedata *shaked, const InteractionList &ilcon)
	Make SHAKE blocks when using DD.

void	cshake (const int iatom[], int ncon, int nnit, int maxnit, ArrayRef< const real > constraint_distance_squared, ArrayRef< RVec > positions, const t_pbc pbc, ArrayRef< const RVec > initial_displacements, ArrayRef< const real > half_of_reduced_mass, real omega, ArrayRef< const real > invmass, ArrayRef< const real > distance_squared_tolerance, ArrayRef< real > scaled_lagrange_multiplier, int *nerror)
	Inner kernel for SHAKE constraints. More...

static void	crattle (const int iatom[], int ncon, int nnit, int maxnit, ArrayRef< const real > constraint_distance_squared, ArrayRef< RVec > vp, ArrayRef< const RVec > rij, ArrayRef< const real > m2, real omega, ArrayRef< const real > invmass, ArrayRef< const real > distance_squared_tolerance, ArrayRef< real > scaled_lagrange_multiplier, int nerror, real invdt)
	Implements RATTLE (ie. SHAKE for velocity verlet integrators)

static int	vec_shakef (FILE fplog, shakedata shaked, ArrayRef< const real > invmass, int ncon, ArrayRef< const t_iparams > ip, const int iatom, real tol, ArrayRef< const RVec > x, ArrayRef< RVec > prime, const t_pbc pbc, real omega, bool bFEP, real lambda, ArrayRef< real > scaled_lagrange_multiplier, real invdt, ArrayRef< RVec > v, bool bCalcVir, tensor vir_r_m_dr, ConstraintVariable econq)
	Applies SHAKE.

static void	check_cons (FILE log, int nc, ArrayRef< const RVec > x, ArrayRef< const RVec > prime, ArrayRef< const RVec > v, const t_pbc pbc, ArrayRef< const t_iparams > ip, const int *iatom, ArrayRef< const real > invmass, ConstraintVariable econq)
	Check that constraints are satisfied.

static bool	bshakef (FILE log, shakedata shaked, ArrayRef< const real > invmass, const InteractionDefinitions &idef, const t_inputrec &ir, ArrayRef< const RVec > x_s, ArrayRef< RVec > prime, const t_pbc pbc, t_nrnb nrnb, real lambda, real *dvdlambda, real invdt, ArrayRef< RVec > v, bool bCalcVir, tensor vir_r_m_dr, bool bDumpOnError, ConstraintVariable econq)
	Applies SHAKE.

bool	constrain_shake (FILE log,shakedata shaked,gmx::ArrayRef< const real > invmass,const InteractionDefinitions &idef,const t_inputrec &ir,ArrayRef< const RVec > x_s,ArrayRef< RVec > xprime,ArrayRef< RVec > vprime,const t_pbc pbc,t_nrnb nrnb,real lambda,real *dvdlambda,real invdt,ArrayRef< RVec > v,bool bCalcVir,tensor vir_r_m_dr,bool bDumpOnError,ConstraintVariable econq)
	Shake all the atoms blockwise. It is assumed that all the constraints in the idef->shakes field are sorted, to ascending block nr. The sblock array points into the idef->shakes.iatoms field, with block 0 starting at sblock[0] and running to ( < ) sblock[1], block n running from sblock[n] to sblock[n+1]. Array sblock should be large enough. Return TRUE when OK, FALSE when shake-error.

static StopSignal	convertToStopSignal (signed char sig)
	Convert signed char (as used by SimulationSignal) to StopSignal enum. More...

void	launchScaleCoordinatesKernel (int numAtoms, DeviceBuffer< Float3 > d_coordinates, const ScalingMatrix &mu, const DeviceStream &deviceStream)
	Launches positions of velocities scaling kernel. More...

static auto	scaleKernel (Float3 *gm_x, const ScalingMatrix scalingMatrix)
	Function returning the scaling kernel lambda.

static bool	hasFlexibleConstraints (const gmx_moltype_t &moltype, gmx::ArrayRef< const t_iparams > iparams)
	Returns whether `moltype` contains flexible constraints.

static bool	hasIncompatibleVsites (const gmx_moltype_t &moltype, gmx::ArrayRef< const t_iparams > iparams)
	Returns whether moltype has incompatible vsites. More...

static InteractionList	jointConstraintList (const gmx_moltype_t &moltype)
	Returns a merged list with constraints of all types.

static AtomIndexExtremes	vsiteConstructRange (int a, const gmx_moltype_t &moltype)
	Returns the range of constructing atom for vsite with atom index `a`.

static AtomIndexExtremes	constraintAtomRange (int a, const ListOfLists< int > &at2con, const InteractionList &ilistConstraints)
	Returns the range of atoms constrained to atom `a` (including `a` itself)

static std::vector< bool >	buildIsParticleVsite (const gmx_moltype_t &moltype)
	Returns a list that tells whether atoms in `moltype` are vsites.

static std::variant< int, IncompatibilityReasons >	detectGroup (int firstAtom, const gmx_moltype_t &moltype, const ListOfLists< int > &at2con, const InteractionList &ilistConstraints)
	Returns the size of the update group starting at `firstAtom` or an incompatibility reason.

static std::variant < RangePartitioning, IncompatibilityReasons >	makeUpdateGroupingsPerMoleculeType (const gmx_moltype_t &moltype, gmx::ArrayRef< const t_iparams > iparams)
	Returns a list of update groups for `moltype` or an incompatibility reason.

std::variant< std::vector < RangePartitioning > , std::string >	makeUpdateGroupingsPerMoleculeType (const gmx_mtop_t &mtop)
	Returns a vector with update groups for each moleculetype in `mtop` or an error string when the criteria (see below) are not satisfied. More...

static std::unordered_multimap < int, int >	getAngleIndices (const gmx_moltype_t &moltype)
	Returns a map of angles ilist.iatoms indices with the middle atom as key.

template<int numPartnerAtoms>
static real	constraintGroupRadius (const gmx_moltype_t &moltype, gmx::ArrayRef< const t_iparams > iparams, const int centralAtom, const ListOfLists< int > &at2con, const std::unordered_multimap< int, int > &angleIndices, const real constraintLength, const real temperature)
	When possible, computes the maximum radius of constrained atom in an update group. More...

static real	computeMaxUpdateGroupRadius (const gmx_moltype_t &moltype, gmx::ArrayRef< const t_iparams > iparams, const RangePartitioning &updateGrouping, real temperature)
	Returns the maximum update group radius for `moltype`.

real	computeMaxUpdateGroupRadius (const gmx_mtop_t &mtop, ArrayRef< const RangePartitioning > updateGroupingPerMoleculeType, real temperature)
	Returns the maximum update group radius. More...

bool	systemHasConstraintsOrVsites (const gmx_mtop_t &mtop)
	Returns whether mtop contains any constraints and/or vsites. More...

UpdateGroups	makeUpdateGroups (const gmx::MDLogger &mdlog, std::vector< RangePartitioning > &&updateGroupingPerMoleculeType, real maxUpdateGroupRadius, bool doRerun, bool useDomainDecomposition, bool systemHasConstraintsOrVsites, real cutoffMargin)
	Builder for update groups. More...

static int	vsiteIlistNrCount (ArrayRef< const InteractionList > ilist)
	Returns the sum of the vsite ilist sizes over all vsite types. More...

static int	pbc_rvec_sub (const t_pbc *pbc, const rvec xi, const rvec xj, rvec dx)
	Computes the distance between xi and xj, pbc is used when pbc!=nullptr.

static real	inverseNorm (const rvec x)
	Returns the 1/norm(x)

static PbcMode	getPbcMode (const t_pbc *pbcPtr)
	Returns the PBC mode based on the system PBC and vsite properties. More...

template<VSiteCalculatePosition calculatePosition, VSiteCalculateVelocity calculateVelocity>
static void	construct_vsites_thread (ArrayRef< RVec > x, ArrayRef< RVec > v, ArrayRef< const t_iparams > ip, ArrayRef< const InteractionList > ilist, const t_pbc *pbc_null)
	Executes the vsite construction task for a single thread. More...

template<VSiteCalculatePosition calculatePosition, VSiteCalculateVelocity calculateVelocity>
static void	construct_vsites (const ThreadingInfo *threadingInfo, ArrayRef< RVec > x, ArrayRef< RVec > v, ArrayRef< const t_iparams > ip, ArrayRef< const InteractionList > ilist, const DomainInfo &domainInfo, const matrix box)
	Dispatch the vsite construction tasks for all threads. More...

void	constructVirtualSites (ArrayRef< RVec > x, ArrayRef< const t_iparams > ip, ArrayRef< const InteractionList > ilist)
	Create positions of vsite atoms based for the local system. More...

static int	vsite_count (ArrayRef< const InteractionList > ilist, int ftype)
	Returns the number of virtual sites in the interaction list, for VSITEN the number of atoms.

template<VirialHandling virialHandling>
static void	spreadForceForThread (ArrayRef< const RVec > x, ArrayRef< RVec > f, ArrayRef< RVec > fshift, matrix dxdf, ArrayRef< const t_iparams > ip, ArrayRef< const InteractionList > ilist, const t_pbc *pbc_null)
	Executes the force spreading task for a single thread.

static void	spreadForceWrapper (ArrayRef< const RVec > x, ArrayRef< RVec > f, const VirialHandling virialHandling, ArrayRef< RVec > fshift, matrix dxdf, const bool clearDxdf, ArrayRef< const t_iparams > ip, ArrayRef< const InteractionList > ilist, const t_pbc *pbc_null)
	Wrapper function for calling the templated thread-local spread function.

static void	clearTaskForceBufferUsedElements (InterdependentTask *idTask)
	Clears the task force buffer elements that are written by task idTask.

static std::vector< int >	makeAtomToGroupMapping (const gmx::RangePartitioning &grouping)
	Returns the an array with group indices for each atom. More...

int	countNonlinearVsites (const gmx_mtop_t &mtop)
	Return the number of non-linear virtual site constructions in the system.

int	countInterUpdategroupVsites (const gmx_mtop_t &mtop, ArrayRef< const RangePartitioning > updateGroupingsPerMoleculeType)
	Return the number of virtual sites that cross update groups. More...

std::unique_ptr < VirtualSitesHandler >	makeVirtualSitesHandler (const gmx_mtop_t &mtop, const t_commrec *cr, PbcType pbcType, ArrayRef< const RangePartitioning > updateGroupingPerMoleculeType)
	Create the virtual site handler. More...

	iparams_ (mtop.ffparams.iparams)

static void	flagAtom (InterdependentTask *idTask, const int atom, const int numThreads, const int numAtomsPerThread)
	Flag that atom `atom` which is home in another task, if it has not already been added before.

static void	assignVsitesToThread (VsiteThread *tData, int thread, int nthread, int natperthread, gmx::ArrayRef< int > taskIndex, ArrayRef< const InteractionList > ilist, ArrayRef< const t_iparams > ip, ArrayRef< const ParticleType > ptype)
	Here we try to assign all vsites that are in our local range. More...

static void	assignVsitesToSingleTask (VsiteThread *tData, int task, gmx::ArrayRef< const int > taskIndex, ArrayRef< const InteractionList > ilist, ArrayRef< const t_iparams > ip)
	Assign all vsites with taskIndex[]==task to task tData.

void	constructVirtualSitesGlobal (const gmx_mtop_t &mtop, ArrayRef< RVec > x)
	Create positions of vsite atoms for the whole system assuming all molecules are wholex. More...

static bool	is_multisim_option_set (int argc, const char *const argv[])
	Return whether the command-line parameter that will trigger a multi-simulation is set.

static DevelopmentFeatureFlags	manageDevelopmentFeatures (const gmx::MDLogger &mdlog, const bool useGpuForNonbonded, const PmeRunMode pmeRunMode, const int numRanksPerSimulation, const int numPmeRanksPerSimulation, gmx::GpuAwareMpiStatus gpuAwareMpiStatus)
	Manage any development feature flag variables encountered. More...

static void	threadMpiMdrunnerAccessBarrier ()
	Barrier for safe simultaneous thread access to mdrunner data. More...

static void	mdrunner_start_fn (const void *arg)
	The callback used for running on spawned threads. More...

static bool	gpuAccelerationOfNonbondedIsUseful (const MDLogger &mdlog, const t_inputrec &ir, const bool issueWarning, const bool doRerun)
	Return whether GPU acceleration of nonbondeds is supported with the given settings. More...

static gmx::LoggerOwner	buildLogger (FILE *fplog, const bool isSimulationMainRank)
	Initializes the logger for mdrun.

static TaskTarget	findTaskTarget (const char *optionString)
	Make a TaskTarget from an mdrun argument string.

static void	finish_run (FILE fplog, const gmx::MDLogger &mdlog, const t_commrec cr, const t_inputrec &inputrec, t_nrnb nrnb[], gmx_wallcycle wcycle, gmx_walltime_accounting_t walltime_accounting, nonbonded_verlet_t nbv, const gmx_pme_t *pme, gmx_bool bWriteStat)
	Finish run, aggregate data to print performance info.

void	applyLocalState (const SimulationInput &simulationInput, t_fileio logfio, const t_commrec cr, int dd_nc, t_inputrec ir, t_state state, ObservablesHistory observablesHistory, bool reproducibilityRequested, const MDModulesNotifiers &notifiers, gmx::ReadCheckpointDataHolder *modularSimulatorCheckpointData, bool useModularSimulator)
	Initialize local stateful simulation data. More...

SimulationInputHandle	makeSimulationInput (const LegacyMdrunOptions &options)

int	computeFepPeriod (const t_inputrec &inputrec, const ReplicaExchangeParameters &replExParams)
	Compute the period at which FEP calculation is performed. More...

std::tuple< StartingBehavior, LogFilePtr >	handleRestart (bool isSimulationMain, MPI_Comm communicator, const gmx_multisim_t *ms, AppendingBehavior appendingBehavior, int nfile, t_filenm fnm[])
	Handle startup of mdrun, particularly regarding -cpi and -append. More...

static void	prepareLogFile (BinaryInformationSettings settings, FILE *fplog)
	Implements aspects of logfile handling common to opening either for writing or appending.

LogFilePtr	openLogFile (const char *lognm, bool appendFiles)
	Open the log file for writing/appending. More...

void	prepareLogAppending (FILE *fplog)
	Prepare to use the open log file when appending. More...

void	closeLogFile (t_fileio *logfio)
	Close the log file.

template<class BasicMdspan >
constexpr std::enable_if_t < BasicMdspan::is_always_contiguous(), typename BasicMdspan::pointer >	begin (const BasicMdspan &basicMdspan)
	Free begin function addressing memory of a contiguously laid out basic_mdspan. More...

template<class BasicMdspan >
constexpr std::enable_if_t < BasicMdspan::is_always_contiguous(), typename BasicMdspan::pointer >	end (const BasicMdspan &basicMdspan)
	Free end function addressing memory of a contiguously laid out basic_mdspan. More...

template<class BasicMdspan >
constexpr BasicMdspan	addElementwise (const BasicMdspan &span1, const BasicMdspan &span2)
	Elementwise addition.

template<class BasicMdspan >
constexpr BasicMdspan	subtractElementwise (const BasicMdspan &span1, const BasicMdspan &span2)
	Elementwise subtraction - left minus right.

template<class BasicMdspan >
constexpr BasicMdspan	multiplyElementwise (const BasicMdspan &span1, const BasicMdspan &span2)
	Elementwise multiplication.

template<class BasicMdspan >
constexpr BasicMdspan	divideElementwise (const BasicMdspan &span1, const BasicMdspan &span2)
	Elementwise division - left / right.

template<std::ptrdiff_t... LHS, std::ptrdiff_t... RHS>
constexpr bool	operator== (const extents< LHS...> &lhs, const extents< RHS...> &rhs) noexcept
	Comparison operator. More...

template<std::ptrdiff_t... LHS, std::ptrdiff_t... RHS>
constexpr bool	operator!= (const extents< LHS...> &lhs, const extents< RHS...> &rhs) noexcept
	Check for non-equality. More...

template<CheckpointDataOperation operation, typename T >
ArrayRef< std::conditional_t < operation==CheckpointDataOperation::Write\|\|std::is_const < T >::value, const typename T::value_type, typename T::value_type > >	makeCheckpointArrayRef (T &container)

template<CheckpointDataOperation operation, typename T >
ArrayRef< std::conditional_t < operation==CheckpointDataOperation::Write\|\|std::is_const < T >::value, const T, T > >	makeCheckpointArrayRefFromArray (T *begin, size_t size)

template<typename VersionEnum >
VersionEnum	checkpointVersion (const ReadCheckpointData *checkpointData, const std::string &key, const VersionEnum programVersion)
	Read a checkpoint version enum variable. More...

template<typename VersionEnum >
VersionEnum	checkpointVersion (WriteCheckpointData *checkpointData, const std::string &key, const VersionEnum programVersion)
	Write the current code checkpoint version enum variable. More...

	forceMtsCombined_ ({})

	view_ ({},{}, false)

	useForceMtsCombined_ (false)

template<class T >
T &	makeRefFromPointer (T *ptr)
	Take pointer, check if valid, return reference.

static const char *	enumValueToString (AtomLocality enumValue)
	Get the human-friendly name for atom localities. More...

static const char *	enumValueToString (InteractionLocality enumValue)
	Get the human-friendly name for interaction localities. More...

static InteractionLocality	atomToInteractionLocality (const AtomLocality atomLocality)
	Convert atom locality to interaction locality. More...

int	nonbondedMtsFactor (const t_inputrec &ir)
	Returns the interval in steps at which the non-bonded pair forces are calculated. More...

std::vector< MtsLevel >	setupMtsLevels (const GromppMtsOpts &mtsOpts, std::vector< std::string > *errorMessages)
	Sets up and returns the MTS levels and checks requirements of MTS. More...

bool	haveValidMtsSetup (const t_inputrec &ir)
	Returns whether we use MTS and the MTS setup is internally valid. More...

std::vector< std::string >	checkMtsRequirements (const t_inputrec &ir)
	Checks whether the MTS requirements on other algorithms and output frequencies are met. More...

static int	forceGroupMtsLevel (ArrayRef< const MtsLevel > mtsLevels, const MtsForceGroups mtsForceGroup)
	Returns the MTS level at which a force group is to be computed. More...

bool	needStateGpu (SimulationWorkload simulationWorkload)
	If StatePropagatorDataGpu object is needed. More...

	conservedEnergyContribution_ (0)

	previousStepConservedEnergyContribution_ (0)

	conservedEnergyContributionStep_ (-1)

	reportPreviousStepConservedEnergy_ (reportPreviousStepConservedEnergy)

	statePropagatorData_ (statePropagatorData)

	energyData_ (energyData)

	fplog_ (fplog)

	inputrec_ (inputrec)

	mdAtoms_ (mdAtoms)

	nrnb_ (nrnb)

	identifier_ ("FirstOrderPressureCoupling-"+std::string(enumValueToString(pressureCouplingType_)))

template<typename... Ts>
auto	checkUseModularSimulator (Ts &&...args) -> decltype(ModularSimulator::isInputCompatible(std::forward< Ts >(args)...))
	Whether or not to use the ModularSimulator. More...

	numDegreesOfFreedom_ (numDegreesOfFreedom)

	simulationTimeStep_ (simulationTimeStep)

	ensembleTemperature_ (ensembleTemperature)

	mttkPropagatorConnection_ (mttkPropagatorConnection)

	nextEnergyCalculationStep_ (-1)

	mdlog_ (mdlog)

template<NumVelocityScalingValues numStartVelocityScalingValues, ParrinelloRahmanVelocityScaling parrinelloRahmanVelocityScaling, NumVelocityScalingValues numEndVelocityScalingValues>
static void	updateVelocities (int a, real dt, real lambdaStart, real lambdaEnd, const ArrayRef< const RVec > invMassPerDim, rvec gmx_restrict v, const rvec gmx_restrict f, const RVec &diagPR, const Matrix3x3 &matrixPR)
	Update velocities.

static void	updatePositions (int a, real dt, const rvec gmx_restrict x, rvec gmx_restrict xprime, const rvec *gmx_restrict v)
	Update positions.

template<NumVelocityScalingValues numStartVelocityScalingValues>
static void	scaleVelocities (int a, real lambda, rvec *gmx_restrict v)
	Scale velocities.

template<NumPositionScalingValues numPositionScalingValues>
static void	scalePositions (int a, real lambda, rvec *gmx_restrict x)
	Scale positions.

template<ParrinelloRahmanVelocityScaling parrinelloRahmanVelocityScaling>
static bool	canTreatPRScalingMatrixAsDiagonal (const Matrix3x3 &matrixPR)
	Is the PR matrix diagonal?

	scalingStepPR_ (-1)

	wcycle_ (wcycle)

template<IntegrationStage integrationStage>
constexpr bool	hasStartVelocityScaling ()

template<IntegrationStage integrationStage>
constexpr bool	hasEndVelocityScaling ()

template<IntegrationStage integrationStage>
constexpr bool	hasPositionScaling ()

template<IntegrationStage integrationStage>
constexpr bool	hasParrinelloRahmanScaling ()

template<IntegrationStage integrationStage>
static PropagatorConnection	getConnection (Propagator< integrationStage > gmx_unused *propagator, const PropagatorTag &propagatorTag)

template<CheckpointDataOperation operation>
static void	doCheckpointData (CheckpointData< operation > *checkpointData, ArrayRef< double > previousStepCom)

static void	runAllCallbacks (const std::vector< SignallerCallback > &callbacks, Step step, Time time)
	Helper function to call all callbacks in a list.

template<typename Element , typename... Args>
ISimulatorElement *	getElementPointer (LegacySimulatorData legacySimulatorData, ModularSimulatorAlgorithmBuilderHelper builderHelper, StatePropagatorData statePropagatorData, EnergyData energyData, FreeEnergyPerturbationData freeEnergyPerturbationData, GlobalCommunicationHelper globalCommunicationHelper, ObservablesReducer *observablesReducer, Args &&...args)

template<typename Base , typename Element >
static std::enable_if_t < std::is_base_of< Base, Element >::value, Base * >	castOrNull (Element *element)
	Returns a pointer casted to type Base if the Element is derived from Base.

template<typename Base , typename Element >
static std::enable_if_t <!std::is_base_of< Base, Element >::value, Base * >	castOrNull (Element gmx_unused *element)
	Returns a nullptr of type Base if Element is not derived from Base.

	ddpCount_ (0)

	element_ (std::make_unique< Element >(this, fplog, cr, inputrec->nstxout, inputrec->nstvout, inputrec->nstfout, inputrec->nstxout_compressed, canMoleculesBeDistributedOverPBC, writeFinalConfiguration, finalConfigurationFilename, inputrec, globalTop))

	referenceTemperatureHelper_ (std::make_unique< ReferenceTemperatureHelper >(inputrec, this, mdatoms))

	vvResetVelocities_ (false)

	isRegularSimulationEnd_ (false)

	lastStep_ (-1)

	globalState_ (globalState)

static void	updateGlobalState (t_state *globalState, const PaddedHostVector< RVec > &x, const PaddedHostVector< RVec > &v, const tensor box, int ddpCount, int ddpCountCgGl, const std::vector< int > &cgGl)
	Update the legacy global state. More...

bool	timesClose (Time time, Time referenceTime)
	Check whether two times are nearly equal. More...

static void	generateCoordinates (int multiplicationFactor, std::vector< gmx::RVec > *coordinates, matrix box)
	Generates coordinates and a box for the base system scaled by `multiplicationFactor`.

template<KernelLayout kernelLayout, KernelCoulombType coulombType, VdwCutoffCheck vdwCutoffCheck, LJCombinationRule ljCombinationRule, InteractionModifiers vdwModifier, LJEwald ljEwald, EnergyOutput energyOutput>
void	nbnxmKernelSimd (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)
	The actual NBNxM SIMD kernel. More...

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r2xMM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::None > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::System > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::RF, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldTabulated, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::No, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::Geometric, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::LorentzBerthelot, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::ForceSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotSwitch, LJEwald::None, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template void	nbnxmKernelSimd< KernelLayout::r4xM, KernelCoulombType::EwaldAnalytical, VdwCutoffCheck::Yes, LJCombinationRule::None, InteractionModifiers::PotShift, LJEwald::CombGeometric, EnergyOutput::GroupPairs > (const NbnxnPairlistCpu nbl, const nbnxn_atomdata_t nbat, const interaction_const_t ic, const rvec shift_vec, nbnxn_atomdata_output_t *out)

template<int nR, KernelLayout kernelLayout>
std::array< std::array < SimdBool, nR > , kernelLayoutClusterRatio < kernelLayout > )==KernelLayoutClusterRatio::JSizeEqualsISize?1:2 >	generateDiagonalMasks (const nbnxn_atomdata_t::SimdMasks &simdMasks)
	Returns the diagonal filter masks.

template<int nR, bool maskInteractions, std::size_t inputSize, std::size_t interactSize>
void	rInvSixAndRInvTwelve (const std::array< SimdReal, inputSize > &rInvSquaredV, const std::array< SimdBool, interactSize > &interactV, std::array< SimdReal, nR > &rInvSixV, std::array< SimdReal, nR > &rInvTwelveV)
	Computes r^-6 and r^-12, masked when requested.

template<int nR, bool maskInteractions, bool haveCutoffCheck, bool calculateEnergies, std::size_t inputSize, std::size_t interactSize, std::size_t vljvSize>
void	lennardJonesInteractionsSigmaEpsilon (const std::array< SimdReal, inputSize > &rInvV, const std::array< SimdBool, interactSize > &interactV, const SimdBool *const withinCutoffV, const std::array< SimdReal, nR > &sigmaV, const std::array< SimdReal, nR > &epsilonV, const SimdReal dispersionShift, const SimdReal repulsionShift, const SimdReal sixth, const SimdReal twelfth, std::array< SimdReal, nR > &frLJV, std::array< SimdReal, vljvSize > &vLJV)
	Returns F*r and optionally the potential for LJ with (un)shifted potential with sigma/epsilon.

template<int nR, std::size_t inputSize>
void	computeForceSwitchVariables (const std::array< SimdReal, inputSize > &rSquaredV, const std::array< SimdReal, inputSize > &rInvV, SimdReal rSwitch, std::array< SimdReal, nR > &rSwitchedV, std::array< SimdReal, nR > &rSwitchedSquaredV, std::array< SimdReal, nR > &rSwitchedSquaredTimesRV)
	Computes (r - r_switch), (r - r_switch)^2 and (r - r_switch)^2 * r.

SimdReal	addLJForceSwitch (SimdReal force, SimdReal rSwitched, SimdReal rSwitchedSquaredTimesR, SimdReal c2, SimdReal c3)
	Adds the force switch term to `force`.

SimdReal	ljForceSwitchPotential (SimdReal rSwitched, SimdReal rSwitchedSquaredTimesR, SimdReal c0, SimdReal c3, SimdReal c4)
	Returns the LJ force switch function for the potential.

template<int nR, std::size_t inputSize>
void	computePotentialSwitchVariables (const std::array< SimdReal, inputSize > &rSquaredV, const std::array< SimdReal, inputSize > &rInvV, SimdReal rSwitch, std::array< SimdReal, nR > &rSwitchedV, std::array< SimdReal, nR > &rSwitchedSquaredV)
	Computes (r - r_switch) and (r - r_switch)^2.

SimdReal	potentialSwitchFunction (SimdReal rsw, SimdReal rsw2, SimdReal c3, SimdReal c4, SimdReal c5)
	Returns the potential switch function.

SimdReal	potentialSwitchFunctionDerivative (SimdReal rsw, SimdReal rsw2, SimdReal c2, SimdReal c3, SimdReal c4)
	Returns the derivative of the potential switch function.

template<int nR, bool maskInteractions, bool calculateEnergies, std::size_t inputSize, std::size_t interactSize, std::size_t ljepSize, std::size_t vljvSize>
void	addLennardJonesEwaldCorrections (const std::array< SimdReal, inputSize > &rSquaredV, const std::array< SimdReal, inputSize > &rInvSquaredV, const std::array< SimdBool, interactSize > &interactV, const SimdBool *withinCutoffV, const std::array< SimdReal, nR > &c6GridV, const std::array< SimdReal, ljepSize > &ljEwaldParams, SimdReal sixth, std::array< SimdReal, nR > &frLJV, std::array< SimdReal, vljvSize > &vLJV)
	Adds the Ewald long-range correction for r^-6.

template<KernelLayoutClusterRatio clusterRatio>
static int	cjFromCi (const int iCluster)
	Returns the j-cluster index for the given i-cluster index. More...

template<KernelLayout kernelLayout>
std::enable_if_t< kernelLayout==KernelLayout::r4xM, SimdReal >	loadIAtomData (const real *ptr, const int offset, const int iRegister)
	Load a single real for an i-atom into `iRegister`.

template<KernelLayout kernelLayout>
std::enable_if_t< kernelLayout==KernelLayout::r2xMM, SimdReal >	loadIAtomData (const real *ptr, const int offset, const int iRegister)
	Load a pair of consecutive reals for two i-atom into the respective halves of `iRegister`.

template<KernelLayout kernelLayout>
std::enable_if_t< kernelLayout==KernelLayout::r4xM, SimdReal >	loadJAtomData (const real *ptr, const int offset)
	Returns a SIMD register containing GMX_SIMD_REAL_WIDTH reals loaded from ptr + offset.

template<KernelLayout kernelLayout>
std::enable_if_t< kernelLayout==KernelLayout::r2xMM, SimdReal >	loadJAtomData (const real *ptr, const int offset)
	Returns a SIMD register containing a duplicate sequence of GMX_SIMD_REAL_WIDTH/2 reals loaded from ptr + offset.

template<bool loadMasks, KernelLayout kernelLayout>
std::enable_if_t<!loadMasks, std::array< SimdBool, 0 > >	loadSimdPairInteractionMasks (const int excl, SimdBitMask *filterBitMasksV)
	Loads no interaction masks, returns an empty array.

template<bool loadMasks, KernelLayout kernelLayout>
std::enable_if_t< loadMasks &&kernelLayout==KernelLayout::r4xM, std::array< SimdBool, c_nbnxnCpuIClusterSize > >	loadSimdPairInteractionMasks (const int excl, SimdBitMask *filterBitMasksV)
	Loads interaction masks for a cluster pair for 4xM kernel layout.

template<bool loadMasks, KernelLayout kernelLayout>
std::enable_if_t< loadMasks &&kernelLayout==KernelLayout::r2xMM, std::array< SimdBool, c_nbnxnCpuIClusterSize/2 > >	loadSimdPairInteractionMasks (const int excl, SimdBitMask *filterBitMasksV)
	Loads interaction masks for a cluster pair for 2xMM kernel layout.

template<KernelLayout kernelLayout, std::size_t offsetJJSize>
void	accumulateGroupPairEnergies4xM (SimdReal energies, real *groupPairEnergyBuffersPtr, const std::array< int, offsetJJSize > &offsetJJ)
	Adds energies to temporary energy group pair buffers for the 4xM kernel layout.

template<KernelLayout kernelLayout, std::size_t offsetJJSize>
void	accumulateGroupPairEnergies2xMM (SimdReal energies, real groupPairEnergyBuffersPtr0, real groupPairEnergyBuffersPtr1, const std::array< int, offsetJJSize > &offsetJJ)
	Adds energies to temporary energy group pair buffers for the 2xMM kernel layout.

template<int nR>
int	pairCountWithinCutoff (SimdReal rSquaredV[nR], SimdReal cutoffSquared)
	Return the number of atoms pairs that are within the cut-off distance.

bool	boxesAreEqual (const matrix box1, const matrix box2)
	Returns whether two boxes are of equal size and shape (within reasonable tolerance).

bool	boxIsZero (const matrix box)
	Returns whether a box is only initialised to zero or not.

void	shiftAtoms (const RVec &shift, ArrayRef< RVec > x)
	Shift all coordinates. More...

void	placeCoordinatesWithCOMInBox (const PbcType &pbcType, UnitCellType unitCellType, CenteringType centerType, const matrix box, ArrayRef< RVec > x, const gmx_mtop_t &mtop, COMShiftType comShiftType)
	Moves collection of atoms along the center of mass into a box. More...

static int	xyzToShiftIndex (int x, int y, int z)
	Convert grid coordinates to shift index.

static int	ivecToShiftIndex (ivec iv)
	Convert grid coordinates to shift index.

static int	shiftIndexToXDim (int iv)
	Return the shift in the X dimension of grid space corresponding to `iv`.

const char *	centerTypeNames (CenteringType type)
	Get names for the different centering types. More...

const char *	unitCellTypeNames (UnitCellType type)
	Get names for the different unit cell representation types. More...

double	getTransformationPullCoordinateValue (pull_coord_work_t *coord, ArrayRef< const pull_coord_work_t > variableCoords, double t)
	Calculates pull->coord[coord_ind].spatialData.value for a transformation pull coordinate. More...

static double	computeDerivativeForTransformationPullCoord (pull_coord_work_t *coord, const int variablePcrdIndex)
	Calculates and returns the derivative of a transformation pull coordinate from a dependent coordinate. More...

void	distributeTransformationPullCoordForce (pull_coord_work_t *pcrd, gmx::ArrayRef< pull_coord_work_t > variableCoords)
	Distributes the force on a transformation pull coordinates to the involved coordinates of lower rank. More...

static bool	checkIfRandomDeviceIsFunctional ()
	Check if the RDRAND random device functioning correctly. More...

template<typename GeneratorType >
static uint64_t	makeRandomSeedInternal (GeneratorType &gen)
	Get the next pure or pseudo-random number. More...

uint64_t	makeRandomSeed ()
	Return 64 random bits from the random device, suitable as seed. More...

template<class RealType = real, unsigned int Bits, class Rng >
RealType	generateCanonical (Rng &g)
	Generate a floating-point value with specified number of random bits. More...

void	compileSelection (SelectionCollection *coll)

void	swap (SelectionCollection &lhs, SelectionCollection &rhs)

static void gmx_unused	simdPrefetch (void gmx_unused *m)
	Prefetch memory at address m. More...

static void	store (float *m, float a)
	Store contents of float variable to aligned memory m. More...

static void	storeU (float *m, float a)
	Store contents of float variable to unaligned memory m. More...

static float	fma (float a, float b, float c)
	Float Fused-multiply-add. Result is a*b + c. More...

static float	fms (float a, float b, float c)
	Float Fused-multiply-subtract. Result is a*b - c. More...

static float	fnma (float a, float b, float c)
	Float Fused-negated-multiply-add. Result is -a*b + c. More...

static float	fnms (float a, float b, float c)
	Float Fused-negated-multiply-subtract. Result is -a*b - c. More...

static float	maskAdd (float a, float b, float m)
	Add two float variables, masked version. More...

static float	maskzMul (float a, float b, float m)
	Multiply two float variables, masked version. More...

static float	maskzFma (float a, float b, float c, float m)
	Float fused multiply-add, masked version. More...

static float gmx_simdcall	maskzRcp (float x, float m)
	Float 1.0/x, masked version. More...

static float	abs (float a)
	Float Floating-point abs(). More...

static float	max (float a, float b)
	Set each float element to the largest from two variables. More...

static float	min (float a, float b)
	Set each float element to the smallest from two variables. More...

static float	round (float a)
	Float round to nearest integer value (in floating-point format). More...

static float	trunc (float a)
	Truncate float, i.e. round towards zero - common hardware instruction. More...

static float	reduce (float a)
	Return sum of all elements in float variable (i.e., the variable itself). More...

static float	andNot (float a, float b)
	Bitwise andnot for two scalar float variables. More...

static bool	testBits (float a)
	Return true if any bits are set in the float variable. More...

static bool	anyTrue (bool a)
	Returns if the boolean is true. More...

static float	selectByMask (float a, bool mask)
	Select from single precision variable where boolean is true. More...

static float	selectByNotMask (float a, bool mask)
	Select from single precision variable where boolean is false. More...

static float	blend (float a, float b, bool sel)
	Blend float selection. More...

static std::int32_t	cvtR2I (float a)
	Round single precision floating point to integer. More...

static std::int32_t	cvttR2I (float a)
	Truncate single precision floating point to integer. More...

static std::int32_t	cvtI2R (std::int32_t a)
	Return integer. More...

static void	store (double *m, double a)
	Store contents of double variable to aligned memory m. More...

static void	storeU (double *m, double a)
	Store contents of double variable to unaligned memory m. More...

static double	fma (double a, double b, double c)
	double Fused-multiply-add. Result is a*b + c. More...

static double	fms (double a, double b, double c)
	double Fused-multiply-subtract. Result is a*b - c. More...

static double	fnma (double a, double b, double c)
	double Fused-negated-multiply-add. Result is - a*b + c. More...

static double	fnms (double a, double b, double c)
	double Fused-negated-multiply-subtract. Result is -a*b - c. More...

static double	maskAdd (double a, double b, double m)
	Add two double variables, masked version. More...

static double	maskzMul (double a, double b, double m)
	Multiply two double variables, masked version. More...

static double	maskzFma (double a, double b, double c, double m)
	double fused multiply-add, masked version. More...

static double gmx_simdcall	maskzRcp (double x, double m)
	Double 1.0/x, masked version. More...

static double	abs (double a)
	double doubleing-point abs(). More...

static double	max (double a, double b)
	Set each double element to the largest from two variables. More...

static double	min (double a, double b)
	Set each double element to the smallest from two variables. More...

static double	round (double a)
	double round to nearest integer value (in doubleing-point format). More...

static double	trunc (double a)
	Truncate double, i.e. round towards zero - common hardware instruction. More...

static double	reduce (double a)
	Return sum of all elements in double variable (i.e., the variable itself). More...

static double	andNot (double a, double b)
	Bitwise andnot for two scalar double variables. More...

static bool	testBits (double a)
	Return true if any bits are set in the double variable. More...

static double	selectByMask (double a, bool mask)
	Select from double precision variable where boolean is true. More...

static double	selectByNotMask (double a, bool mask)
	Select from double precision variable where boolean is false. More...

static double	blend (double a, double b, bool sel)
	Blend double selection. More...

static std::int32_t	cvtR2I (double a)
	Round single precision doubleing point to integer. More...

static std::int32_t	cvttR2I (double a)
	Truncate single precision doubleing point to integer. More...

static double	cvtF2D (float a)
	Convert float to double (mimicks SIMD conversion) More...

static float	cvtD2F (double a)
	Convert double to float (mimicks SIMD conversion) More...

static void	store (std::int32_t *m, std::int32_t a)
	Store contents of integer variable to aligned memory m. More...

static void	storeU (std::int32_t *m, std::int32_t a)
	Store contents of integer variable to unaligned memory m. More...

static std::int32_t	andNot (std::int32_t a, std::int32_t b)
	Bitwise andnot for two scalar integer variables. More...

static bool	testBits (std::int32_t a)
	Return true if any bits are set in the integer variable. More...

static std::int32_t	selectByMask (std::int32_t a, bool mask)
	Select from integer variable where boolean is true. More...

static std::int32_t	selectByNotMask (std::int32_t a, bool mask)
	Select from integer variable where boolean is false. More...

static std::int32_t	blend (std::int32_t a, std::int32_t b, bool sel)
	Blend integer selection. More...

static bool	cvtB2IB (bool a)
	Just return a boolean (mimicks SIMD real-to-int bool conversions) More...

static bool	cvtIB2B (bool a)
	Just return a boolean (mimicks SIMD int-to-real bool conversions) More...

static float	copysign (float x, float y)
	Composes single value with the magnitude of x and the sign of y. More...

static void	invsqrtPair (float x0, float x1, float out0, float out1)
	Calculate 1/sqrt(x) for two floats. More...

static float	inv (float x)
	Calculate 1/x for float. More...

static float	maskzInvsqrt (float x, bool m)
	Calculate 1/sqrt(x) for masked entry of float. More...

static float	maskzInv (float x, bool m)
	Calculate 1/x for masked entry of float. More...

template<MathOptimization opt = MathOptimization::Safe>
static float	sqrt (float x)
	Float sqrt(x). This is the square root. More...

template<MathOptimization opt = MathOptimization::Safe>
static float	cbrt (float x)
	Float cbrt(x). This is the cubic root. More...

static float	log (float x)
	Float log(x). This is the natural logarithm. More...

template<MathOptimization opt = MathOptimization::Safe>
static float	exp2 (float x)
	Float 2^x. More...

template<MathOptimization opt = MathOptimization::Safe>
static float	exp (float x)
	Float exp(x). More...

static float	erf (float x)
	Float erf(x). More...

static float	erfc (float x)
	Float erfc(x). More...

static void	sincos (float x, float sinval, float cosval)
	Float sin & cos. More...

static float	sin (float x)
	Float sin. More...

static float	cos (float x)
	Float cos. More...

static float	tan (float x)
	Float tan. More...

static float	asin (float x)
	float asin. More...

static float	acos (float x)
	Float acos. More...

static float	atan (float x)
	Float atan. More...

static float	atan2 (float y, float x)
	Float atan2(y,x). More...

static float	pmeForceCorrection (float z2)
	Calculate the force correction due to PME analytically in float. More...

static float	pmePotentialCorrection (float z2)
	Calculate the potential correction due to PME analytically in float. More...

static double	copysign (double x, double y)
	Composes double value with the magnitude of x and the sign of y. More...

static void	invsqrtPair (double x0, double x1, double out0, double out1)
	Calculate 1/sqrt(x) for two doubles. More...

static double	inv (double x)
	Calculate 1/x for double. More...

static double	maskzInvsqrt (double x, bool m)
	Calculate 1/sqrt(x) for masked entry of double. More...

static double	maskzInv (double x, bool m)
	Calculate 1/x for masked entry of double. More...

template<MathOptimization opt = MathOptimization::Safe>
static double	sqrt (double x)
	Double sqrt(x). This is the square root. More...

template<MathOptimization opt = MathOptimization::Safe>
static double	cbrt (double x)
	Double cbrt(x). This is the cubic root. More...

static double	log (double x)
	Double log(x). This is the natural logarithm. More...

template<MathOptimization opt = MathOptimization::Safe>
static double	exp2 (double x)
	Double 2^x. More...

template<MathOptimization opt = MathOptimization::Safe>
static double	exp (double x)
	Double exp(x). More...

static double	erf (double x)
	Double erf(x). More...

static double	erfc (double x)
	Double erfc(x). More...

static void	sincos (double x, double sinval, double cosval)
	Double sin & cos. More...

static double	sin (double x)
	Double sin. More...

static double	cos (double x)
	Double cos. More...

static double	tan (double x)
	Double tan. More...

static double	asin (double x)
	Double asin. More...

static double	acos (double x)
	Double acos. More...

static double	atan (double x)
	Double atan. More...

static double	atan2 (double y, double x)
	Double atan2(y,x). More...

static double	pmeForceCorrection (double z2)
	Calculate the force correction due to PME analytically in double. More...

static double	pmePotentialCorrection (double z2)
	Calculate the potential correction due to PME analytically in double. More...

static double	invsqrtSingleAccuracy (double x)
	Calculate 1/sqrt(x) for double, but with single accuracy. More...

static void	invsqrtPairSingleAccuracy (double x0, double x1, double out0, double out1)
	Calculate 1/sqrt(x) for two doubles, but with single accuracy. More...

static double	invSingleAccuracy (double x)
	Calculate 1/x for double, but with single accuracy. More...

static double	maskzInvsqrtSingleAccuracy (double x, bool m)
	Calculate 1/sqrt(x) for masked entry of double, but with single accuracy. More...

static double	maskzInvSingleAccuracy (double x, bool m)
	Calculate 1/x for masked entry of double, but with single accuracy. More...

static double	sqrtSingleAccuracy (double x)
	Calculate sqrt(x) for double, but with single accuracy. More...

static double	logSingleAccuracy (double x)
	Double log(x), but with single accuracy. This is the natural logarithm. More...

static double	exp2SingleAccuracy (double x)
	Double 2^x, but with single accuracy. More...

static double	expSingleAccuracy (double x)
	Double exp(x), but with single accuracy. More...

static double	erfSingleAccuracy (double x)
	Double erf(x), but with single accuracy. More...

static double	erfcSingleAccuracy (double x)
	Double erfc(x), but with single accuracy. More...

static void	sincosSingleAccuracy (double x, double sinval, double cosval)
	Double sin & cos, but with single accuracy. More...

static double	sinSingleAccuracy (double x)
	Double sin, but with single accuracy. More...

static double	cosSingleAccuracy (double x)
	Double cos, but with single accuracy. More...

static double	tanSingleAccuracy (double x)
	Double tan, but with single accuracy. More...

static double	asinSingleAccuracy (double x)
	Double asin, but with single accuracy. More...

static double	acosSingleAccuracy (double x)
	Double acos, but with single accuracy. More...

static double	atanSingleAccuracy (double x)
	Double atan, but with single accuracy. More...

static double	atan2SingleAccuracy (double y, double x)
	Double atan2(y,x), but with single accuracy. More...

static double	pmeForceCorrectionSingleAccuracy (double z2)
	Force correction due to PME in double, but with single accuracy. More...

static double	pmePotentialCorrectionSingleAccuracy (double z2)
	Potential correction due to PME in double, but with single accuracy. More...

template<int align>
static void	gatherLoadTranspose (const float base, const std::int32_t offset[], float v0, float v1, float v2, float *v3)
	Load 4 consecutive floats from base/offset into four variables. More...

template<int align>
static void	gatherLoadTranspose (const float base, const std::int32_t offset[], float v0, float *v1)
	Load 2 consecutive floats from base/offset into four variables. More...

template<int align>
static void	gatherLoadUTranspose (const float base, const std::int32_t offset[], float v0, float v1, float v2)
	Load 3 consecutive floats from base/offsets, store into three vars. More...

template<int align>
static void	transposeScatterStoreU (float *base, const std::int32_t offset[], float v0, float v1, float v2)
	Store 3 floats to 3 to base/offset. More...

template<int align>
static void	transposeScatterIncrU (float *base, const std::int32_t offset[], float v0, float v1, float v2)
	Add 3 floats to base/offset. More...

template<int align>
static void	transposeScatterDecrU (float *base, const std::int32_t offset[], float v0, float v1, float v2)
	Subtract 3 floats from base/offset. More...

static void	expandScalarsToTriplets (float scalar, float triplets0, float triplets1, float *triplets2)
	Copy single float to three variables. More...

template<int align>
static void	gatherLoadBySimdIntTranspose (const float base, std::int32_t offset, float v0, float v1, float v2, float *v3)
	Load 4 floats from base/offsets and store into variables. More...

template<int align>
static void	gatherLoadUBySimdIntTranspose (const float base, std::int32_t offset, float v0, float *v1)
	Load 2 floats from base/offsets and store into variables (unaligned). More...

template<int align>
static void	gatherLoadBySimdIntTranspose (const float base, std::int32_t offset, float v0, float *v1)
	Load 2 floats from base/offsets and store into variables (aligned). More...

static float	reduceIncr4ReturnSum (float *m, float v0, float v1, float v2, float v3)
	Add each float to four consecutive memory locations, return sum. More...

template<int align>
static void	gatherLoadTranspose (const double base, const std::int32_t offset[], double v0, double v1, double v2, double *v3)
	Load 4 consecutive doubles from base/offset into four variables. More...

template<int align>
static void	gatherLoadTranspose (const double base, const std::int32_t offset[], double v0, double *v1)
	Load 2 consecutive doubles from base/offset into four variables. More...

template<int align>
static void	gatherLoadUTranspose (const double base, const std::int32_t offset[], double v0, double v1, double v2)
	Load 3 consecutive doubles from base/offsets, store into three vars. More...

template<int align>
static void	transposeScatterStoreU (double *base, const std::int32_t offset[], double v0, double v1, double v2)
	Store 3 doubles to 3 to base/offset. More...

template<int align>
static void	transposeScatterIncrU (double *base, const std::int32_t offset[], double v0, double v1, double v2)
	Add 3 doubles to base/offset. More...

template<int align>
static void	transposeScatterDecrU (double *base, const std::int32_t offset[], double v0, double v1, double v2)
	Subtract 3 doubles from base/offset. More...

static void	expandScalarsToTriplets (double scalar, double triplets0, double triplets1, double *triplets2)
	Copy single double to three variables. More...

template<int align>
static void	gatherLoadBySimdIntTranspose (const double base, std::int32_t offset, double v0, double v1, double v2, double *v3)
	Load 4 doubles from base/offsets and store into variables. More...

template<int align>
static void	gatherLoadUBySimdIntTranspose (const double base, std::int32_t offset, double v0, double *v1)
	Load 2 doubles from base/offsets and store into variables (unaligned). More...

template<int align>
static void	gatherLoadBySimdIntTranspose (const double base, std::int32_t offset, double v0, double *v1)
	Load 2 doubles from base/offsets and store into variables (aligned). More...

static double	reduceIncr4ReturnSum (double *m, double v0, double v1, double v2, double v3)
	Add each double to four consecutive memory locations, return sum. More...

std::unique_ptr< IMDModule >	createSwapCoordinatesModule ()
	Creates a module for Computational Electrophysiology swapping.

bool	decideWhetherToUseGpusForNonbondedWithThreadMpi (TaskTarget nonbondedTarget, bool haveAvailableDevices, const std::vector< int > &userGpuTaskAssignment, EmulateGpuNonbonded emulateGpuNonbonded, bool buildSupportsNonbondedOnGpu, bool nonbondedOnGpuIsUseful, bool binaryReproducibilityRequested, int numRanksPerSimulation)
	Decide whether this thread-MPI simulation will run nonbonded tasks on GPUs. More...

static bool	decideWhetherToUseGpusForPmeFft (const TaskTarget pmeFftTarget)

static bool	canUseGpusForPme (const bool useGpuForNonbonded, const TaskTarget pmeTarget, const TaskTarget pmeFftTarget, const t_inputrec &inputrec, std::string *errorMessage)

bool	decideWhetherToUseGpusForPmeWithThreadMpi (bool useGpuForNonbonded, TaskTarget pmeTarget, TaskTarget pmeFftTarget, int numDevicesToUse, const std::vector< int > &userGpuTaskAssignment, const t_inputrec &inputrec, int numRanksPerSimulation, int numPmeRanksPerSimulation)
	Decide whether this thread-MPI simulation will run PME tasks on GPUs. More...

bool	decideWhetherToUseGpusForNonbonded (TaskTarget nonbondedTarget, const std::vector< int > &userGpuTaskAssignment, EmulateGpuNonbonded emulateGpuNonbonded, bool buildSupportsNonbondedOnGpu, bool nonbondedOnGpuIsUseful, bool binaryReproducibilityRequested, bool gpusWereDetected)
	Decide whether the simulation will try to run nonbonded tasks on GPUs. More...

bool	decideWhetherToUseGpusForPme (bool useGpuForNonbonded, TaskTarget pmeTarget, TaskTarget pmeFftTarget, const std::vector< int > &userGpuTaskAssignment, const t_inputrec &inputrec, int numRanksPerSimulation, int numPmeRanksPerSimulation, bool gpusWereDetected)
	Decide whether the simulation will try to run tasks of different types on GPUs. More...

PmeRunMode	determinePmeRunMode (bool useGpuForPme, const TaskTarget &pmeFftTarget, const t_inputrec &inputrec)
	Determine PME run mode. More...

bool	decideWhetherToUseGpusForBonded (bool useGpuForNonbonded, bool useGpuForPme, TaskTarget bondedTarget, const t_inputrec &inputrec, const gmx_mtop_t &mtop, int numPmeRanksPerSimulation, bool gpusWereDetected)
	Decide whether the simulation will try to run bonded tasks on GPUs. More...

bool	decideWhetherToUseGpuForUpdate (bool isDomainDecomposition, bool useUpdateGroups, PmeRunMode pmeRunMode, bool havePmeOnlyRank, bool useGpuForNonbonded, TaskTarget updateTarget, bool gpusWereDetected, const t_inputrec &inputrec, const gmx_mtop_t &mtop, bool useEssentialDynamics, bool doOrientationRestraints, bool haveFrozenAtoms, bool useModularSimulator, bool doRerun, const gmx::MDLogger &mdlog)
	Decide whether to use GPU for update. More...

bool	decideWhetherDirectGpuCommunicationCanBeUsed (const DevelopmentFeatureFlags &devFlags, bool haveMts, bool haveSwapCoords, const gmx::MDLogger &mdlog)
	Decide whether direct GPU communication can be used. More...

bool	decideWhetherToUseGpuForHalo (bool havePPDomainDecomposition, bool useGpuForNonbonded, bool canUseDirectGpuComm, bool useModularSimulator, bool doRerun, bool haveEnergyMinimization, const gmx::MDLogger &mdlog)
	Decide whether to use GPU for halo exchange. More...

SimulationWorkload	createSimulationWorkload (const t_inputrec &inputrec, bool disableNonbondedCalculation, const DevelopmentFeatureFlags &devFlags, bool havePpDomainDecomposition, bool haveSeparatePmeRank, bool useGpuForNonbonded, PmeRunMode pmeRunMode, bool useGpuForBonded, bool useGpuForUpdate, bool useGpuDirectHalo, bool canUseDirectGpuComm, bool useGpuPmeDecomposition)
	Build datastructure that contains decisions whether to run different workload task on GPUs. More...

static bool	haveSpecialForces (const t_inputrec &inputrec, const gmx::ForceProviders &forceProviders, const pull_t pull_work, const gmx_edsam ed)
	Return true if there are special forces computed. More...

DomainLifetimeWorkload	setupDomainLifetimeWorkload (const t_inputrec &inputrec, const t_forcerec &fr, const pull_t pull_work, const gmx_edsam ed, const t_mdatoms &mdatoms, const SimulationWorkload &simulationWork)
	Set up workload flags that have the lifetime of the PP domain decomposition. More...

StepWorkload	setupStepWorkload (const int legacyFlags, ArrayRef< const gmx::MtsLevel > mtsLevels, const int64_t step, const DomainLifetimeWorkload &domainWork, const SimulationWorkload &simulationWork)
	Set up force flag struct from the force bitmask. More...

std::vector< GpuTask >	findGpuTasksOnThisRank (bool haveGpusOnThisPhysicalNode, TaskTarget nonbondedTarget, TaskTarget pmeTarget, TaskTarget bondedTarget, TaskTarget updateTarget, bool useGpuForNonbonded, bool useGpuForPme, bool rankHasPpTask, bool rankHasPmeTask)
	Returns container of all tasks on this rank that are eligible for GPU execution. More...

GpuTasksOnRanks	findAllGpuTasksOnThisNode (ArrayRef< const GpuTask > gpuTasksOnThisRank, const PhysicalNodeCommunicator &physicalNodeComm)
	Returns container of all tasks on all ranks of this node that are eligible for GPU execution. More...

void	checkHardwareOversubscription (int numThreadsOnThisRank, int rank, const HardwareTopology &hwTop, const PhysicalNodeCommunicator &comm, const MDLogger &mdlog)
	Warns for oversubscribing the hardware threads, when that is the case.

std::vector< int >	parseUserGpuIdString (const std::string &gpuIdString)
	Parse a GPU ID specifier string into a container describing device IDs exposed to the run. More...

std::vector< int >	makeListOfAvailableDevices (gmx::ArrayRef< const std::unique_ptr< DeviceInformation >> deviceInfoList, const std::string &devicesSelectedByUserString)
	Implement GPU ID selection by returning the available GPU IDs on this physical node that are compatible. More...

std::vector< int >	parseUserTaskAssignmentString (const std::string &gpuIdString)
	Parse a GPU ID specifier string into a container describing device ID to task mapping. More...

std::vector< int >	makeGpuIds (ArrayRef< const int > compatibleGpus, size_t numGpuTasks)
	Make a vector containing `numGpuTasks` IDs of the IDs found in `compatibleGpus`. More...

std::string	makeGpuIdString (const std::vector< int > &gpuIds, int totalNumberOfTasks)
	Convert a container of GPU deviced IDs to a string that can be used by gmx tune_pme as input to mdrun -gputasks. More...

void	checkUserGpuIds (ArrayRef< const std::unique_ptr< DeviceInformation >> deviceInfoList, ArrayRef< const int > compatibleGpus, ArrayRef< const int > gpuIds)
	Check that all user-selected GPUs are compatible. More...

void	reportGpuUsage (const MDLogger &mdlog, ArrayRef< const GpuTaskAssignment > gpuTaskAssignmentOnRanksOfThisNode, size_t numGpuTasksOnThisNode, size_t numPpRanks, bool printHostName, PmeRunMode pmeRunMode, const SimulationWorkload &simulationWork)
	Log a report on how GPUs are being used on the ranks of the physical node of rank 0 of the simulation. More...

template<GpuTask TaskType>
static bool	hasTaskType (const GpuTaskMapping &mapping)
	Function for whether the task of `mapping` has value `TaskType`. More...

static bool	hasPmeOrNonbondedTask (const GpuTaskMapping &mapping)
	Function for whether the `mapping` has the GPU PME or Nonbonded task. More...

static std::vector< int >	parseGpuDeviceIdentifierList (const std::string &gpuIdString)
	Parse a GPU ID specifier string into a container. More...

void	writeHeader (TextWriter *writer, const std::string &text, const std::string &section, bool writeFormattedText)
	Write appropiate Header to output stream. More...

void	writeSystemInformation (TextWriter *writer, const gmx_mtop_t &top, bool writeFormattedText)
	Write information about the molecules in the system. More...

void	writeParameterInformation (TextWriter *writer, const t_inputrec &ir, bool writeFormattedText)
	Write information about system parameters. More...

void	writeInformation (TextOutputFile *outputStream, const t_inputrec &ir, const gmx_mtop_t &top, bool writeFormattedText, bool notStdout)
	Wrapper for writing out information. More...

void	blockaToExclusionBlocks (const t_blocka *b, gmx::ArrayRef< ExclusionBlock > b2)
	Convert the exclusions. More...

void	exclusionBlocksToBlocka (gmx::ArrayRef< const ExclusionBlock > b2, t_blocka *b)
	Convert the exclusions expressed in `b` into t_blocka form.

void	mergeExclusions (ListOfLists< int > *excl, gmx::ArrayRef< ExclusionBlock > b2)
	Merge the contents of `b2` into `excl`. More...

Isotope	getIsotopeFromString (const std::string &isotope)
	Convert isotope name from string to enum.

std::vector< Isotope >	getIsotopes (const t_atoms *atoms)
	Reads element list and returns vector of isotopes.

std::vector < AtomicStructureFactor >	readAtomicStructureFactors ()
	Helper function to read in atomic scattering data from file.

gmx_rmpbc_t	gmx_rmpbc_init (const gmx::TopologyInformation &topInfo)
	Convenience overload useful for implementing legacy tools.

static std::size_t	getPageSize ()
	Return a page size, from a sysconf/WinAPI query if available, or a default guess (4096 bytes). More...

void	printBinaryInformation (FILE *fp, const IProgramContext &programContext)
	Print basic information about the executable. More...

void	printBinaryInformation (FILE *fp, const IProgramContext &programContext, const BinaryInformationSettings &settings)
	Print basic information about the executable with custom settings. More...

void	printBinaryInformation (TextWriter *writer, const IProgramContext &programContext, const BinaryInformationSettings &settings)
	Print basic information about the executable with custom settings. More...

ArrayRef< bool >	makeArrayRef (std::vector< BoolType > &boolVector)
	Create ArrayRef to bool from reference to std::vector<BoolType>. More...

ArrayRef< const bool >	makeConstArrayRef (const std::vector< BoolType > &boolVector)
	Create ArrayRef to const bool from reference to std::vector<BoolType>. More...

std::string	bromacs ()
	Return a cool definition for the acronym GROMACS.

std::string	getCoolQuote ()
	Return a string with a cool quote.

std::string	getCudaDriverVersionString ()
	Returns a string of the CUDA driver version.

std::string	getCudaRuntimeVersionString ()
	Returns a string of the CUDA runtime version.

const char *	getErrorCodeString (int errorcode)
	Returns a short string description of an error code. More...

void	printFatalErrorMessage (FILE *fp, const std::exception &ex)
	Formats a standard fatal error message for reporting an exception. More...

std::string	formatExceptionMessageToString (const std::exception &ex)
	Formats an error message for reporting an exception. More...

void	formatExceptionMessageToFile (FILE *fp, const std::exception &ex)
	Formats an error message for reporting an exception. More...

void	formatExceptionMessageToWriter (TextWriter *writer, const std::exception &ex)
	Formats an error message for reporting an exception. More...

int	processExceptionAtExit (const std::exception &ex)
	Handles an exception that is causing the program to terminate. More...

void	processExceptionAsFatalError (const std::exception &ex)
	Helper function for terminating the program on an exception. More...

const DataFileFinder &	getLibraryFileFinder ()
	Gets a finder for locating data files from share/top/. More...

void	setLibraryFileFinder (const DataFileFinder *finder)
	Sets a finder for location data files from share/top/. More...

std::filesystem::path	findLibraryFile (const std::filesystem::path &filename, bool bAddCWD=true, bool bFatal=true)
	Finds full path for a library file. More...

FilePtr	openLibraryFile (const std::filesystem::path &filename, bool bAddCWD=true, bool bFatal=true)
	Opens a library file for reading in an RAII-style `FILE` handle. More...

std::size_t	pageSize ()
	Return the memory page size on this system. More...

void	init (int argc, char **argv)
	Initializes the GROMACS library. More...

void	finalize ()
	Deinitializes the GROMACS library. More...

void	writeKeyValueTreeAsMdp (TextWriter *writer, const KeyValueTreeObject &tree)
	Write a flat key-value `tree` to `writer` in mdp style. More...

std::string_view	mpiLibraryVersionString ()
	Return the string obtained from the MPI library via MPI_Get_library_version.

bool	usingIntelMpi ()
	Return whether GROMACS is linked against an MPI library describing itself as Intel MPI.

GpuAwareMpiStatus	checkMpiCudaAwareSupport ()
	Wrapper on top of `MPIX_Query_cuda_support()` For MPI implementations which don't support this function, it returns `NotSupported`. Even when an MPI implementation does support this function, MPI library might not be robust enough to detect CUDA-aware support at runtime correctly e.g. when UCX PML is used or CUDA is disabled at runtime. More...

GpuAwareMpiStatus	checkMpiHipAwareSupport ()
	Wrapper on top of `MPIX_Query_hip_support()` or `MPIX_Query_rocm_support()`. For MPI implementations which don't support this function, it returns `NotSupported`. More...

GpuAwareMpiStatus	checkMpiZEAwareSupport ()
	Wrapper on top of `MPIX_Query_ze_support()` (for MPICH) or custom logic (for IntelMPI). More...

void	niceHeader (TextWriter writer, const char fn, char commentChar)
	Prints creation time stamp and user information into a string as comments, and returns it. More...

std::vector < std::filesystem::path >	splitPathEnvironment (const std::string &pathEnv)
	Split PATH environment variable into search paths. More...

std::vector < std::filesystem::path >	getSystemExecutablePaths ()
	Get collection of possible executable paths.

std::string	stripSourcePrefix (const char *path)
	Strip source prefix from path.

std::filesystem::path	concatenateBeforeExtension (const std::filesystem::path &path, const std::string &addition)
	Concatenate before extension.

std::filesystem::path	stripExtension (const std::filesystem::path &path)
	Remove extension from file path.

bool	extensionMatches (const std::filesystem::path &path, std::string_view extension)
	Check if file extension of `path` without final '.' matches `extension`.

void	MPI_Comm_free_wrapper (MPI_Comm *comm)
	Wrapper function for RAII-style cleanup. More...

template<typename ValueType , int NumExpectedValues>
static std::optional < std::array< ValueType, NumExpectedValues > >	parsedArrayFromInputString (const std::string &str)
	Convert a string into an array of values. More...

template<typename ValueType , int NumExpectedValues>
static std::string	stringIdentityTransformWithArrayCheck (const std::string &toConvert, const std::string &errorContextMessage)
	Returns the input string, throwing an exception if the demanded conversion to an array will not succeed. More...

template<class Function >
auto	dispatchTemplatedFunction (Function &&f)

const IProgramContext &	getProgramContext ()
	Returns the global IProgramContext instance. More...

void	setProgramContext (const IProgramContext *context)
	Sets the global IProgramContext instance. More...

std::size_t	countWords (const char *s)
	Returns number of space-separated words in zero-terminated char ptr. More...

std::size_t	countWords (const std::string &str)
	Returns the number of space-separated words in a string object. More...

bool	endsWith (const char str, const char suffix)
	Tests whether a string ends with another string. More...

std::string	stripSuffixIfPresent (const std::string &str, const char *suffix)
	Removes a suffix from a string. More...

std::string	stripString (const std::string &str)
	Removes leading and trailing whitespace from a string. More...

std::string	formatString (gmx_fmtstr const char *fmt,...)

std::string	formatStringV (const char *fmt, va_list ap)
	Formats a string (vsnprintf() wrapper). More...

std::vector< std::string >	splitString (const std::string &str)
	Splits a string to whitespace separated tokens. More...

std::vector< std::string >	splitDelimitedString (const std::string &str, char delim)
	Splits a string to tokens separated by a given delimiter. More...

std::vector< std::string >	splitAndTrimDelimitedString (const std::string &str, char delim)
	Splits `str` to tokens separated by delimiter `delim`. Removes leading and trailing whitespace from those strings with std::isspace. More...

std::string	replaceAll (const std::string &input, const char from, const char to)
	Replace all occurrences of a string with another string. More...

std::string	replaceAll (const std::string &input, const std::string &from, const std::string &to)
	Replace all occurrences of a string with another string. More...

std::string	replaceAllWords (const std::string &input, const char from, const char to)
	Replace whole words with others. More...

std::string	replaceAllWords (const std::string &input, const std::string &from, const std::string &to)
	Replace whole words with others. More...

bool	equalCaseInsensitive (const std::string &source, const std::string &target)
	Return whether two strings are equal, ignoring case. More...

bool	equalIgnoreDash (const std::string &source, const std::string &target)
	Return whether too strings are case sensitive equal, ignoring dashes.

bool	equalCaseInsensitive (const std::string &source, const std::string &target, size_t maxLengthOfComparison)
	Checks if at most `maxLengthOfComparison` characters of two strings match case insensitive. More...

std::string	toUpperCase (const std::string &text)
	Makes the string uppercase. More...

std::string	toLowerCase (const std::string &text)
	Makes the string lowercase. More...

std::string	getSyclCompilerVersion ()
	Returns an internal version strings of the Intel DPC++ and hipSYCL compiler.

int	gmx_mdrun (int argc, char *argv[])
	Implements C-style main function for mdrun. More...

int	gmx_mdrun (MPI_Comm communicator, const gmx_hw_info_t &hwinfo, int argc, char *argv[])
	Implements C-style main function for mdrun. More...

AnalysisHistogramSettingsInitializer	histogramFromRange (real min, real max)
	Initializes a histogram using a range and a bin width. More...

AnalysisHistogramSettingsInitializer	histogramFromBins (real start, int nbins, real binwidth)
	Initializes a histogram using bin width and the number of bins. More...

static float	invsqrt (float x)
	Calculate 1.0/sqrt(x) in single precision. More...

static double	invsqrt (double x)
	Calculate 1.0/sqrt(x) in double precision, but single range. More...

static double	invsqrt (int x)
	Calculate 1.0/sqrt(x) for integer x in double precision. More...

static float	invcbrt (float x)
	Calculate inverse cube root of x in single precision. More...

static double	invcbrt (double x)
	Calculate inverse sixth root of x in double precision. More...

static double	invcbrt (int x)
	Calculate inverse sixth root of integer x in double precision. More...

static float	sixthroot (float x)
	Calculate sixth root of x in single precision. More...

static double	sixthroot (double x)
	Calculate sixth root of x in double precision. More...

static double	sixthroot (int x)
	Calculate sixth root of integer x, return double. More...

static float	invsixthroot (float x)
	Calculate inverse sixth root of x in single precision. More...

static double	invsixthroot (double x)
	Calculate inverse sixth root of x in double precision. More...

static double	invsixthroot (int x)
	Calculate inverse sixth root of integer x in double precision. More...

template<typename T >
T	square (T x)
	calculate x^2 More...

template<typename T >
T	power3 (T x)
	calculate x^3 More...

template<typename T >
T	power4 (T x)
	calculate x^4 More...

template<typename T >
T	power5 (T x)
	calculate x^5 More...

template<typename T >
T	power6 (T x)
	calculate x^6 More...

template<typename T >
T	power12 (T x)
	calculate x^12 More...

static real	series_sinhx (real x)
	Maclaurin series for sinh(x)/x. More...

constexpr int32_t	exactDiv (int32_t a, int32_t b)
	Exact integer division, 32bit. More...

constexpr int64_t	exactDiv (int64_t a, int64_t b)
	Exact integer division, 64bit.

static int	roundToInt (float x)
	Round float to int. More...

static int	roundToInt (double x)
	Round double to int.

static int64_t	roundToInt64 (float x)
	Round float to int64_t.

static int64_t	roundToInt64 (double x)
	Round double to int64_t.

template<typename T , typename = std::enable_if_t<std::is_integral<T>::value>>
static constexpr bool	isPowerOfTwo (const T v)
	Check whether `v` is an integer power of 2.

template<typename ValueType >
BasicVector< ValueType >	operator* (const BasicVector< ValueType > &basicVector, const ValueType &scalar)
	Allow vector scalar multiplication.

template<typename ValueType >
BasicVector< ValueType >	operator* (const ValueType &scalar, const BasicVector< ValueType > &basicVector)
	Allow scalar vector multiplication.

template<typename VectorType >
static VectorType	unitVector (const VectorType &v)
	unitv for gmx::BasicVector

template<typename ValueType >
static ValueType	norm (BasicVector< ValueType > v)
	norm for gmx::BasicVector

template<typename ValueType >
static ValueType	norm2 (BasicVector< ValueType > v)
	Square of the vector norm for gmx::BasicVector.

template<typename VectorType >
static VectorType	cross (const VectorType &a, const VectorType &b)
	cross product for gmx::BasicVector

template<typename ValueType >
static ValueType	dot (BasicVector< ValueType > a, BasicVector< ValueType > b)
	dot product for gmx::BasicVector

template<typename VectorType >
static VectorType	scaleByVector (const VectorType &a, const VectorType &b)
	Multiply two vectors element by element and return the result.

template<typename VectorType >
static VectorType	elementWiseMin (const VectorType &a, const VectorType &b)
	Return the element-wise minimum of two vectors.

template<typename VectorType >
static VectorType	elementWiseMax (const VectorType &a, const VectorType &b)
	Return the element-wise maximum of two vectors.

template<typename ValueType >
static BasicVector< ValueType > ::RawArray *	as_vec_array (BasicVector< ValueType > *x)
	Casts a gmx::BasicVector array into an equivalent raw C array.

template<typename ValueType >
static const BasicVector < ValueType >::RawArray *	as_vec_array (const BasicVector< ValueType > *x)
	Casts a gmx::BasicVector array into an equivalent raw C array.

static rvec *	as_rvec_array (RVec *x)
	Casts a gmx::RVec array into an `rvec` array.

static const rvec *	as_rvec_array (const RVec *x)
	Casts a gmx::RVec array into an `rvec` array.

static dvec *	as_dvec_array (DVec *x)
	Casts a gmx::DVec array into an `Dvec` array.

static ivec *	as_ivec_array (IVec *x)
	Casts a gmx::IVec array into an `ivec` array.

static const dvec *	as_dvec_array (const DVec *x)
	Casts a gmx::DVec array into an `dvec` array.

static const ivec *	as_ivec_array (const IVec *x)
	Casts a gmx::IVec array into an `ivec` array.

template<typename T >
ArrayRef< std::conditional_t < std::is_const< T >::value, const typename T::value_type, typename T::value_type > >	makeArrayRef (T &c)
	Create ArrayRef from container with type deduction. More...

template<typename T >
ArrayRef< const typename T::value_type >	makeConstArrayRef (const T &c)
	Create ArrayRef to const T from container with type deduction. More...

template<typename T >
void	swap (ArrayRef< T > &a, ArrayRef< T > &b)
	Simple swap method for ArrayRef objects. More...

template<typename T >
std::vector< T >	copyOf (const ArrayRef< const T > &arrayRef)
	Return a vector that is a copy of an ArrayRef. More...

template<typename T >
Index	ssize (const T &t)
	Return signed size of container.

template<typename EnumerationArrayType >
EnumerationArrayType::EnumerationWrapperType	keysOf (const EnumerationArrayType &)
	Returns an object that provides iterators over the keys associated with `EnumerationArrayType`. More...

template<class Exception , class Tag , class T >
std::enable_if_t < std::is_base_of < GromacsException, Exception > ::value, Exception >	operator<< (Exception ex, const ExceptionInfo< Tag, T > &item)
	Associates extra information with an exception. More...

void	fclose_wrapper (FILE *fp)
	fclose wrapper to be used as unique_ptr deleter

static bool	isNullOrEmpty (const char *str)
	Tests whether a string is null or empty. More...

static bool	startsWith (const std::string &str, const std::string &prefix)
	Tests whether a string starts with another string. More...

static bool	startsWith (const char str, const char prefix)
	Tests whether a string starts with another string. More...

static bool	endsWith (const std::string &str, const char *suffix)
	Tests whether a string ends with another string. More...

static bool	contains (const std::string &str, const char *substr)
	Tests whether a string contains another as a substring. More...

static bool	contains (const std::string &str, const std::string &substr)
	Tests whether a string contains another as a substring. More...

static bool	endsWith (const std::string &str, const std::string &suffix)
	Tests whether a string ends with another string. More...

std::string	formatString (const char *fmt,...)
	Formats a string (snprintf() wrapper). More...

template<typename InputIterator , typename FormatterType >
std::string	formatAndJoin (InputIterator begin, InputIterator end, const char *separator, const FormatterType &formatter)
	Formats all the range as strings, and then joins them with a separator in between. More...

template<typename ContainerType , typename FormatterType >
std::string	formatAndJoin (const ContainerType &container, const char *separator, const FormatterType &formatter)
	Formats all elements of the container as strings, and then joins them with a separator in between. More...

template<typename InputIterator >
std::string	joinStrings (InputIterator begin, InputIterator end, const char *separator)
	Joins strings from a range with a separator in between. More...

template<typename ContainerType >
std::string	joinStrings (const ContainerType &container, const char *separator)
	Joins strings from a container with a separator in between. More...

template<size_t count>
std::string	joinStrings (const char const (&array)[count], const char separator)
	Joins strings from an array with a separator in between. More...

template<class T >
void	free_wrapper (T *p)
	Wrapper of standard library free(), to be used as unique_cptr deleter for memory allocated by malloc, e.g. by an external library such as TNG.

template<class T >
void	sfree_wrapper (T *p)
	sfree wrapper to be used as unique_cptr deleter

template<typename T , typename D >
std::unique_ptr< T, D >	create_unique_with_deleter (T *t, D d)
	Create unique_ptr with any deleter function or lambda.


void	applyGlobalSimulationState (const SimulationInput &simulationInput, PartialDeserializedTprFile partialDeserializedTpr, t_state globalState, t_inputrec inputrec, gmx_mtop_t globalTopology)
	Get the global simulation input. More...

std::unique_ptr< t_state >	globalSimulationState (const SimulationInput &)

void	applyGlobalInputRecord (const SimulationInput &, t_inputrec *)

void	applyGlobalTopology (const SimulationInput &, gmx_mtop_t *)


template<typename T >
std::remove_const_t< T >	norm (T *v)
	Forward operations on C Array style vectors to C implementations. More...

template<typename T >
std::remove_const_t< T >	norm2 (T *v)

Variables
const gmx::EnumerationArray < XvgFormat, const char * >	c_xvgFormatNames
	Names for XvgFormat. More...

static const int	c_linewidth = 80 - 2
	Linewidth used for warning output.

static const int	c_biasMaxNumDim = 4
	The maximum dimensionality of the AWH coordinate.

static const std::string	c_colvarsModuleName = "colvars"
	Tag with name of the Colvars MDModule.

static const std::string	colvarsConfig = "colvars_sample.dat"

static const EnumerationArray < DensitySimilarityMeasureMethod, const char * >	c_densitySimilarityMeasureMethodNames
	Name the methods that may be used to evaluate similarity between densities. More...

static const EnumerationArray < DensityFittingAmplitudeMethod, const char * >	c_densityFittingAmplitudeMethodNames
	The names of the methods to determine the amplitude of the atoms to be spread on a grid. More...

static const std::string	c_qmmmCP2KModuleName = "qmmm-cp2k"
	Tag with name of the QMMM with CP2K MDModule.

static const EnumerationArray < QMMMQMMethod, const char * >	c_qmmmQMMethodNames
	The names of the supported QM methods. More...

const std::vector< std::string >	periodic_system
	symbols of the elements in periodic table More...

static const EnumerationArray < ChangeSettingType, const char * >	c_changeSettingTypeNames
	Mapping for enums from ChangeSettingType. More...

static const EnumerationArray < ChangeAtomsType, const char * >	c_changeAtomsTypeNames
	Mapping for enums from ChangeAtomsType. More...

	pmeStream

static constexpr int64_t	sc_checkpointMaxAtomCount = std::numeric_limits<unsigned int>::max() / 3
	The maximum number of atoms that can be stored in a checkpoint file.

static constexpr Architecture	c_architecture
	Constant that tells what the architecture is. More...

constexpr int	c_loopWait = 1
	How long shall we wait in seconds until we check for a connection again?

constexpr int	c_connectWait = 1
	How long shall we check for the IMD_GO?

constexpr int	c_headerSize = 8
	IMD Header Size.

constexpr int	c_protocolVersion = 2
	IMD Protocol Version.

static const char	IMDstr [] = "IMD:"
	Tag output from the IMD module with this string. More...

constexpr int	c_maxConnections = 1
	Currently only 1 client connection is supported.

static constexpr int	numFTypesOnGpu = 8
	The number on bonded function types supported on GPUs.

constexpr std::array< int, numFTypesOnGpu >	fTypesOnGpu
	List of all bonded function types supported on GPUs. More...

static const int	simd_width = 1
	Define simd_width for memory allocation used for SIMD code.

static constexpr int	c_threadsPerBlock = 256
	Number of threads in a GPU block.

static constexpr int	sc_workGroupSize = 256
	Number of work-items in a work-group.

static const EnumerationArray < IncompatibilityReasons, std::string >	reasonStrings
	Strings explaining why the system is incompatible with update groups. More...

static constexpr int	c_ftypeVsiteStart = F_VSITE1
	The start value of the vsite indices in the ftype enum. More...

static constexpr int	c_ftypeVsiteEnd = F_VSITEN + 1
	The start and end value of the vsite indices in the ftype enum.

static constexpr int64_t	sc_atomInfo_EnergyGroupIdMask = 0b11111111
	The first 8 bits are reserved for energy-group ID.

static const gmx::EnumerationArray < MtsForceGroups, std::string >	mtsForceGroupNames
	Names for the MTS force groups. More...

const std::array< RVec, 2 >	c_forces = { { { 0.5, 0.1, 1.2 }, { -2.1, 0.2, 0.3 } } }

static constexpr int	s_maxNumThreadsForReduction = 256
	The max thread number is arbitrary, we used a fixed number to avoid memory management. Using more than 16 threads is probably never useful performance wise.

	boxRel_ { { 0 } }

static constexpr EnumerationArray< NhcUsage, const char * >	nhcUsageNames = { "System", "Barostat" }

	boxVelocity_ { { 0 } }

	previousBox_ { { 0 } }

static constexpr bool	sc_calculateShiftForces = true
	Whether we calculate shift forces, always true, because it's cheap anyhow.

constexpr int	c_centralShiftIndex = detail::c_numIvecs / 2

constexpr int	c_numShiftVectors = detail::c_numIvecs

constexpr bool	c_gpuBuildSyclWithoutGpuFft

constexpr double	c_angstrom = 1e-10

constexpr double	c_kilo = 1e3

constexpr double	c_nano = 1e-9

constexpr double	c_pico = 1e-12

constexpr double	c_nm2A = c_nano / c_angstrom

constexpr double	c_cal2Joule = 4.184

constexpr double	c_electronCharge = 1.602176634e-19

constexpr double	c_amu = 1.66053906660e-27

constexpr double	c_boltzmann = 1.380649e-23

constexpr double	c_avogadro = 6.02214076e23

constexpr double	c_universalGasConstant = c_boltzmann * c_avogadro

constexpr double	c_boltz = c_universalGasConstant / c_kilo

constexpr double	c_faraday = c_electronCharge * c_avogadro

constexpr double	c_planck1 = 6.62607015e-34

constexpr double	c_planck = (c_planck1 * c_avogadro / (c_pico * c_kilo))

constexpr double	c_epsilon0Si = 8.8541878128e-12

constexpr double	c_epsilon0

constexpr double	c_speedOfLight

constexpr double	c_rydberg = 1.0973731568160e-02

constexpr double	c_one4PiEps0 = (1.0 / (4.0 * 3.14159265358979323846 * c_epsilon0))

constexpr double	c_barMdunits = (1e5 * c_nano * c_pico * c_pico / c_amu)

constexpr double	c_presfac = 1.0 / c_barMdunits

constexpr double	c_debye2Enm = (1e-15 / (c_speedOfLight * c_electronCharge))

constexpr double	c_enm2Debye = 1.0 / c_debye2Enm

constexpr double	c_fieldfac = c_faraday / c_kilo

constexpr double	c_hartree2Kj = ((2.0 * c_rydberg * c_planck * c_speedOfLight) / c_avogadro)

constexpr double	c_bohr2Nm = 0.0529177210903

constexpr double	c_hartreeBohr2Md = (c_hartree2Kj * c_avogadro / c_bohr2Nm)

constexpr double	c_rad2Deg = 180.0 / 3.14159265358979323846

constexpr double	c_deg2Rad = 3.14159265358979323846 / 180.0


static constexpr int64_t	sc_atomInfo_FreeEnergyPerturbation = 1 << 15
	Constants whose bit describes a property of an atom in AtomInfoWithinMoleculeBlock.atomInfo. More...

static constexpr int64_t	sc_atomInfo_HasPerturbedCharge = 1 << 16

static constexpr int64_t	sc_atomInfo_Exclusion = 1 << 17

static constexpr int64_t	sc_atomInfo_Constraint = 1 << 20

static constexpr int64_t	sc_atomInfo_Settle = 1 << 21

static constexpr int64_t	sc_atomInfo_BondCommunication = 1 << 22

static constexpr int64_t	sc_atomInfo_HasVdw = 1 << 23

static constexpr int64_t	sc_atomInfo_HasCharge = 1 << 24


constexpr int	c_dBoxZ = 1
	Maximum dimensions of grid expressing shifts across PBC.

constexpr int	c_dBoxY = 1

constexpr int	c_dBoxX = 2

Typedef Documentation

template<class T >

using gmx::AlignedAllocator = typedef Allocator<T, AlignedAllocationPolicy>

Aligned memory allocator.

Template Parameters

T	Type of objects to allocate

This convenience partial specialization can be used for the optional allocator template parameter in standard library containers, which is necessary e.g. to use SIMD aligned load and store operations on data in those containers. The memory will always be aligned according to the behavior of AlignedAllocationPolicy.

template<class ElementType >

using gmx::BasicMatrix3x3 = typedef MultiDimArray<std::array<ElementType, 3 * 3>, extents<3, 3>>

Three-by-three matrix of ElementType.

Template Parameters

ElementType type of element to be stored in matrix

using gmx::BoxMatrix = typedef std::array<std::array<real, DIM>, DIM>

A 3x3 matrix data type useful for simulation boxes.

Todo:: Implement a full replacement for C-style real[DIM][DIM]

typedef ThreeFry2x64Fast gmx::DefaultRandomEngine

Default fast and accurate random engine in Gromacs.

This engine will return 2*2^64 random results using the default gmx::RandomDomain::Other stream, and can be initialized with a single seed argument without having to remember empty template angle brackets.

template<class T >

using gmx::HostAllocator = typedef Allocator<T, HostAllocationPolicy>

Memory allocator that uses HostAllocationPolicy.

Template Parameters

T	Type of objects to allocate

This convenience partial specialization can be used for the optional allocator template parameter in standard library containers whose memory may be used for e.g. GPU transfers. The memory will always be allocated according to the behavior of HostAllocationPolicy.

using gmx::Index = typedef std::ptrdiff_t

Integer type for indexing into arrays or vectors.

Same as ptrdiff_t.

using gmx::Matrix3x3 = typedef BasicMatrix3x3<real>

Three-by-three real number matrix.

Note: will replace the C-style real[3][3] "matrix"

template<class T >

using gmx::PageAlignedAllocator = typedef Allocator<T, PageAlignedAllocationPolicy>

PageAligned memory allocator.

Template Parameters

T	Type of objects to allocate

This convenience partial specialization can be used for the optional allocator template parameter in standard library containers, which is necessary for locking memory pages for asynchronous transfer between a GPU device and the host. The memory will always be aligned according to the behavior of PageAlignedAllocationPolicy.

typedef std::random_device gmx::RandomDevice

Random device.

For now this is identical to the standard library, but since we use the GROMACS random module for all other random engines and distributions it is convenient to have this too in the same module.

Enumeration Type Documentation

enum gmx::AppendingBehavior

strong

Enumeration for mdrun appending behavior.

Enumerator
Auto	Append only if user command-line and file input is correct.
Appending	Must append.
NoAppending	Must not append.

enum gmx::Architecture

strong

Enum for GROMACS CPU hardware detection support.

Enumerator
Unknown	Not one of the cases below.
X86	X86.
Arm	ARM.
PowerPC	IBM PowerPC.
RiscV32	32-bit RISC-V
RiscV64	64-bit RISC-V

enum gmx::AtomLocality : int

strong

Atom locality indicator: local, non-local, all.

Used for calls to: gridding, force calculation, x/f buffer operations

Enumerator
Local	Local atoms.
NonLocal	Non-local atoms.
All	Both local and non-local atoms.
Count	The number of atom locality types.

enum gmx::AwhOutputEntryType

strong

Enum with the AWH variables to write.

Enumerator
MetaData	Meta data.
CoordValue	Coordinate value.
Pmf	The pmf.
Bias	The bias.
Visits	The number of visits.
Weights	The weights.
Target	The target distribition.
SharedForceCorrelationVolume	The force correlation volume shared between multiple walkers.
SharedFrictionTensor	The full friction tensor shared between multiple walkers.

enum gmx::AwhOutputMetaData

strong

Enum with the types of metadata to write.

Enumerator
NumBlock	The number of blocks.
TargetError	The target error.
ScaledSampleWeight	The logarithm of the sample weight relative to a sample weight of 1 at the initial time.
Count	The number of enum values, not including Count.

enum gmx::CheckpointSignal

strong

Checkpoint signals.

Signals set and read by CheckpointHandler. Possible signals include

nothing to signal
do checkpoint (at next NS step)

enum gmx::CoordinateFileFlags : unsigned long

strong

The enums here define the flags specifying the requirements of different outputadapter modules.

When building the object for deciding on the output to a new coordinate file, the CoordinateFile object needs to be able to validate that the dependencies of attached IOutputAdapters are fulfilled. Classes and interfaces that use the enum can check their dependencies against the information encoded in the flags and can then perform an appropriate reaction if there is a mismatch.

Todo:: Use std::bitset<16> for the entries.

Enumerator
Base	Base setting that says that the module has no requirements. Sets the flags to default setting to make sure all output methods are supported.
RequireForceOutput	Requires output method to support force output. If set, only output methods supporting writing of forces will work, others will generate an invalid input error.
RequireVelocityOutput	Requires output method to support velocity output. If set, only writing to files that support velocity output will succeed. Other writing methods will generate an error.
RequireAtomConnections	Requires support for connection information in output format. If set, only file output that supports writing of connection information will succeed. This means for now that only PDB and TNG files can be written. Other file writing methods will fail.
RequireAtomInformation	Requires that output format supports the writing of atom information to the file. If set, files will only be written if they can output the information from t_atoms and otherwise create an error while writing.
RequireChangedOutputPrecision	Requires that output format supports writing user-specified output precision. If set, output will only be written if the format supports the writing of custom precision of the included data.
RequireNewFrameStartTime	Requires that output format supports writing time to the file.
RequireNewFrameTimeStep	Requires that output format supports writing time to the file.
RequireNewBox	Requires that output format supports writing box information.
RequireCoordinateSelection	Requires output to support changes to selection of coordinates. Default for most methods, will need to be able to write coordinates to output file or generate an error.
Count	Needed for enumeration array.

enum gmx::DDBondedChecking : bool

strong

Options for checking bonded interactions.

These values must match the bool false and true used for mdrun -ddcheck

Enumerator
ExcludeZeroLimit	Do not check bonded interactions that go to 0 for large distances.
All	Check all bonded interactions.

enum gmx::DdRankOrder

strong

The options for the domain decomposition MPI task ordering.

Enumerator
select	First value (needed to cope with command-line parsing)
interleave	Interleave the PP and PME ranks.
pp_pme	First all PP ranks, all PME rank at the end.
cartesian	Use Cartesian communicators for PP, PME and PP-PME.
Count	The number of options.

enum gmx::DensityFittingAmplitudeMethod : int

strong

The methods that determine how amplitudes are spread on a grid in density guided simulations.

Enumerator
Unity	same spread amplitude, unity, for all atoms
Mass	atom mass is the spread amplitude
Charge	partial charge determines the spread amplitude

enum gmx::DensitySimilarityMeasureMethod : int

strong

The methods that determine how two densities are compared to one another.

Enumerator

innerProduct

Measure similarity between densities as normalized inner product of their voxel values.

$\mathrm{Similarity}(\rho_{\mathrm{r}},\rho_{\mathrm{c}}) = \frac{1}{N_\mathrm{voxel}}/\sum_{v=1}^{N_\mathrm{voxel}} \rho^v_{\mathrm{r}} \rho^v_{\mathrm{c}}$

relativeEntropy

Measure similarity between densities by negative relative entropy.

Note: Voxels with negative values are ignored.

$\mathrm{Similarity}(\rho_{\mathrm{r}},\rho_{\mathrm{c}}) = \sum_{v=1}^{N_\mathrm{voxel}} \rho^v_{\mathrm{r}} (\log(\rho^v_{\mathrm{c}}) - \log(\rho^v_{\mathrm{r}}))$

crossCorrelation

Measure similarity between densities by cross correlation.

$\mathrm{Similarity}(\rho_{\mathrm{r}},\rho_{\mathrm{c}}) = \frac{\sum_{v}\left((\rho_{\mathrm{r}} - \bar{\rho}_{\mathrm{r}})(\rho_{\mathrm{c}} - \bar{\rho}_{\mathrm{c}})\right)} {\sqrt{\sum_v(\rho_{\mathrm{r}} - \bar{\rho}_{\mathrm{r}})^2 \sum_v (\rho_{\mathrm{c}} - \bar{\rho}_{\mathrm{c}})^2}}$

enum gmx::DeviceStreamType : int

strong

Class enum to describe the different logical streams used for GPU work.

Whether the actual streams differ is an implementation detail of the manager class.

Enumerator
NonBondedLocal	Stream primarily for short-ranged local nonbonded work.
NonBondedNonLocal	Stream primarily for short-ranged nonlocal nonbonded work.
Pme	Stream primarily for PME work.
PmePpTransfer	Stream primarily for data exchange between PME and PP ranks.
UpdateAndConstraints	Stream primarily for update and constraints.
Count	Conventional termination of the enumeration.

enum gmx::DlbOption

strong

The options for the dynamic load balancing.

Enumerator
select	First value (needed to cope with command-line parsing)
turnOnWhenUseful	Turn on DLB when we think it would improve performance.
no	Never turn on DLB.
yes	Turn on DLB from the start and keep it on.
Count	The number of options.

enum gmx::EmulateGpuNonbonded : bool

strong

Help pass GPU-emulation parameters with type safety.

Enumerator
No	Do not emulate GPUs.
Yes	Do emulate GPUs.

enum gmx::EndianSwapBehavior : int

strong

Specify endian swapping behavoir.

Enumerator
DoNotSwap	Don't touch anything.
Swap	User-enforced swapping.
SwapIfHostIsBigEndian	Only swap if machine we execute on is big-endian.
SwapIfHostIsLittleEndian	Only swap if machine we execute on is little-endian.
Count	Number of possible behaviors.

enum gmx::EnergySignallerVirialMode

strong

When we calculate virial.

Enumerator
Off	No specific virial calculation - calculate when energy is calculated.
OnStep	Calculate on virial frequency steps.
OnStepAndNext	Calculate on virial frequency steps and on step after.
Count	The number of entries.

enum gmx::FftBackend

strong

Enumerator
Cufft	supports only single-GPU
OclVkfft	supports only single-GPU
Ocl	supports only single-GPU
CuFFTMp	supports only multi-gpu
HeFFTe_CUDA	supports only multi-gpu
HeFFTe_Sycl_OneMkl	supports only multi-gpu
HeFFTe_Sycl_Rocfft	supports only multi-gpu
HeFFTe_Sycl_cuFFT	supports only multi-gpu
SyclMkl	supports only single-GPU
SyclRocfft	supports only single-GPU
SyclVkfft	supports only single-GPU
SyclBbfft	supports only single-GPU
Sycl	stubs for not supported configurations

enum gmx::FlexibleConstraintTreatment

strong

Tells make_at2con how to treat flexible constraints.

Enumerator
Include	Include all flexible constraints.
Exclude	Exclude all flexible constraints.

enum gmx::FrameConverterFlags : unsigned long

strong

The enums here define the guarantees provided by frameconverters concerning the modifications they provide.

A method can specify different kind of guarantees for the operation, and aggregate methods can combine those flags to provide an overview about what has happened to a coordinate frame during processing.

Enumerator
NoGuarantee	Base setting means no guarantee is done by a module.
MoleculesAreWhole	Tells us that molecules have been made whole.
NoPBCJumps	Tells us that no jumps over periodic boundary are present. Implies molecules are made whole.
MoleculeCOMInBox	Tells us that COM of all molecules is in the box.
ResidueCOMInBox	Tells us that COM of residues is in the box.
AtomsInBox	Tells us that all atoms are in the box.
UnitCellIsRectangular	Tells us a converter changed the unit cell to rectangular.
UnitCellIsTriclinic	Tells us a converter changed the unit cell to triclinic.
UnitCellIsCompact	Tells us a converter changed the unit cell to compact.
SystemIsCenteredInBox	Tells us that converter centered system in a box. Invalidated by calling a method that changes the type of box.
FitToReferenceRotTrans	Tells us that converter has fit coordinate data to reference. Specific for rotational and translational fit.
FitToReferenceRotTransXY	Tells us that converter fit coordinate data to reference. Specific for rotation and translation in XY plane.
FitToReferenceTranslation	Tells us that converter fit coordinate data to reference. Specific for translational fit.
FitToReferenceTranslationXY	Tells us that converter fit coordinate data to reference. Specific for translational fit in XY plane.
FitToReferenceProgressive	Tells us that converter fit coordinate data to reference. Specific for progressive fit.
NewSystemCenter	Tells us that converter has set a new center for the system. This affects the routines that place atoms in the box and the unit cell changing routines, so they have to be invalidated by any method setting this flag.
Count	Final entry to get number of operations.

enum gmx::GpuAwareMpiStatus : int

strong

Enum describing GPU-aware support in underlying MPI library.

Ordinal, so that the lowest value can represent the minimal level of support found across a set of devices, perhaps across nodes or ranks.

Enumerator
NotSupported	GPU-aware support NOT available or not known.
Forced	GPU-aware support forced using env variable.
Supported	GPU-aware support available.

enum gmx::GpuTask : int

strong

Types of compute tasks that can be run on a GPU.

These names refer to existing practice in GROMACS, which is not strictly accurate.

Enumerator
Nonbonded	Short-ranged interactions.
Pme	Long-ranged interactions.
Count	Number of possible tasks.

enum gmx::GraphState : int

strong

State of graph.

Enumerator
Invalid	Invalid, i.e before recording has started (including after reset)
Recording	Recording is underway and has not yet finished.
Recorded	Recording has finished, but graph is not yet instantiated.
Instantiated	Instantiated and ready to launch.
Count	Number of valid values.

enum gmx::ILJInteractions

strong

The fraction of i-particles for which LJ interactions need to be computed.

Enumerator
All	all i-particles
Half	the first half of the i-particles
None	none of i-particles

enum gmx::IMDMessageType : int

strong

Enum for types of IMD messages.

We use the same records as the NAMD/VMD IMD implementation.

Enumerator
Disconnect	client disconnect
Energies	energy data
FCoords	atomic coordinates
Go	start command for the simulation
Handshake	handshake to determine little/big endianness
Kill	terminates the simulation
Mdcomm	force data
Pause	pauses the simulation
TRate	sets the IMD transmission and processing rate
IOerror	I/O error.
Count	number of entries

enum gmx::InteractionLocality : int

strong

Interaction locality indicator: local, non-local, all.

Used for calls to: pair-search, force calculation, x/f buffer operations

Enumerator
Local	Interactions between local atoms only.
NonLocal	Interactions between non-local and (non-)local atoms.
Count	The number of interaction locality types.

enum gmx::KernelCoulombType

strong

List of type of Nbnxm kernel coulomb type implementations.

Enumerator
RF	Reaction-field, also used for plain cut-off.
EwaldAnalytical	Ewald with analytical reciprocal contribution correction.
EwaldTabulated	Ewald with tabulated reciprocal contribution correction.

enum gmx::MrcDataMode : int32_t

strong

The type of density data stored in an mrc file. As named in "EMDB Map Distribution Format Description Version 1.01 (c) emdatabank.org 2014" Modes 0-4 are defined by the standard. NOTE only mode 2 is currently implemented and used.

Enumerator
uInt8	compressed data mode, 8 bits, signed byte (range -128 to 127, ISO/IEC 10967)
int16	16 bits, signed integer (range -32768 to 32767, ISO/IEC 10967)
float32	32 bits, floating point number (IEEE 754)
complexInt32	32 bits, complex signed integers (ISO/IEC 10967)
complexFloat64	64 bits, complex floating point numbers (IEEE 754)

enum gmx::MtsForceGroups : int

strong

Force group available for selection for multiple time step integration.

Enumerator
LongrangeNonbonded	PME-mesh or Ewald for electrostatics and/or LJ.
Nonbonded	Non-bonded pair interactions.
Pair	Bonded pair interactions.
Dihedral	Dihedrals, including cmap (not restraints)
Angle	Bonded angle potentials (not restraints)
Pull	COM pulling.
Awh	Accelerated weight histogram method.
Count	The number of groups above.

enum gmx::NhcUsage

strong

The usages of Nose-Hoover chains.

Enumerator
System	Couple system to temperature bath.
Barostat	Couple barostat to temperature bath.
Count	Number of enum entries.

enum gmx::Normalization

strong

Enum with different ways of normalizing the output.

Enumerator
None	No normalization.
Coordinate	Scale using the internal/user input coordinate scaling factor.
FreeEnergy	Normalize free energy values by subtracting the minimum value.
Distribution	Normalize the distribution to 1.

enum gmx::NumTempScaleValues

strong

Sets the number of different temperature coupling values.

This is needed to template the kernel

Todo:: Unify with similar enum in CPU update module

Enumerator
None	No temperature coupling.
Single	Single T-scaling value (one group)
Multiple	Multiple T-scaling values, need to use T-group indices.
Count	Number of valid values.

enum gmx::ObservablesReducerStatus : int

strong

Report whether the reduction has happened this step.

Enumerator
ReadyToReduce	Reduction has not yet happened this step.
AlreadyReducedThisStep	Reduction has happened this step.

enum gmx::PbcMode

strong

PBC modes for vsite construction and spreading.

Enumerator
all	Apply normal, simple PBC for all vsites.
none	No PBC treatment needed.

enum gmx::PinningPolicy : int

strong

Helper enum for pinning policy of the allocation of HostAllocationPolicy.

For an efficient non-blocking transfer (e.g. to a GPU), the memory pages for a buffer need to be pinned to a physical page. Aligning such buffers to a physical page should miminize the number of pages that need to be pinned. However, some buffers that may be used for such transfers may also be used in either GROMACS builds or run paths that cannot use such a device, so the policy can be configured so that the resource consumption is no higher than required for correct, efficient operation in all cases.

enum gmx::QMMMQMMethod

strong

Enumerator for supported QM methods Also could be INPUT which means external input file provided with the name determined by QMMMParameters::qminputfilename_.

Enumerator
PBE	DFT with PBE functional.
BLYP	DFT with BLYP functional.
INPUT	User provides suitable input file for QM package.

enum gmx::RandomDomain

strong

Enumerated values for fixed part of random seed (domain)

Random numbers are used in many places in GROMACS, and to avoid identical streams the random seeds should be different. Instead of keeping track of several different user-provided seeds, it is better to use the fact that generators like ThreeFry take two 64-bit keys, and combine a general user-provided 64-bit random seed with a second constant value from this list to make each stream guaranteed unique.

Note: There is no reason to go overboard with adding options; we only need to guarantee different streams for cases that might be present simultaneously in a single simulation. As an example, two different integrators (or thermostats) can reuse the same domain.; When you do add options, leave some space between the values so you can group new options with old ones without changing old values.

Enumerator
Other	Generic - stream uniqueness is not important.
MaxwellVelocities	Veolcity assignment from Maxwell distribution.
TestParticleInsertion	Test particle insertion.
UpdateCoordinates	Particle integrators.
UpdateConstraints	Second integrator step for constraints.
Thermostat	Stochastic temperature coupling.
Barostat	Stochastic pressure coupling.
ReplicaExchange	Replica exchange metropolis moves.
ExpandedEnsemble	Expanded ensemble lambda moves.
AwhBiasing	AWH biasing reference value moves.

enum gmx::ReductionRequirement : int

strong

Control whether reduction is required soon.

Enumerator
Soon	Reduce whenever the runner next checks with the ObservablesReducer.
Eventually	Reduce whenever the runner next checks with the ObservablesReducer after some module requires reduction Soon.

enum gmx::ResetSignal

strong

Reset signals.

Signals set and read by ResetHandler. Possible signals include

nothing to signal
reset counters (as soon as signal is received)

enum gmx::ScheduleOnInitStep

strong

Whether the element does schedule on the initial step.

Enumerator
Yes	Schedule on first step.
No	Do not schedule on first step.
Count	Number of enum entries.

enum gmx::SpaceGroup : int32_t

strong

Space group in three dimensions.

Currently only "no symmetry" is supported, the complete enum class would hold 230 symbols.

Table 12.3.4.1 Standard space-group symbols, pages 824-831, International Tables for Crystallography, Volume A, fifth edition

Enumerator
P1	no symmetry

enum gmx::StartingBehavior : int

strong

Enumeration for describing how mdrun is (re)starting.

Enumerator
RestartWithAppending	Restarting with appending, if a checkpoint is supplied and other conditions are met.
RestartWithoutAppending	Restarting without appending, when a checkpoint is supplied.
NewSimulation	Not restarting.
Count	Mark the end of the enumeration.

enum gmx::StopSignal : int

strong

Stop signals.

Signals that stop conditions can send to all ranks. Possible signals include

nothing to signal
stop at the next neighbor-searching step
stop as soon as signal is received

enum gmx::StripStrings : int

strong

Enum class for whether StringToEnumValueConverter will strip strings of leading and trailing whitespace before comparison.

Enumerator
No	Do not strip strings.
Yes	Strip strings.

enum gmx::VirtualSiteVirialHandling : int

strong

Tells how to handle virial contributions due to virtual sites.

Enumerator
None	Do not compute virial contributions.
Pbc	Add contributions working over PBC to shift forces.
NonLinear	Compute contributions due to non-linear virtual sites.

enum gmx::VSiteOperation

strong

Whether we calculate vsite positions, velocities, or both.

Enumerator
Positions	Calculate only positions.
Velocities	Calculate only velocities.
PositionsAndVelocities	Calculate both positions and velocities.
Count	The number of entries.

Function Documentation

static float gmx::abs ( float a )

inlinestatic

Float Floating-point abs().

Parameters

a	any floating point values

Returns: abs(a) for each element.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::abs ( double a )

inlinestatic

double doubleing-point abs().

Parameters

a	any doubleing point values

Returns: abs(a) for each element.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::acos ( float x )

inlinestatic

Float acos.

Parameters

x	The argument to evaluate acos for

Returns: Acos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::acos ( double x )

inlinestatic

Double acos.

Parameters

x	The argument to evaluate acos for

Returns: Acos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::acosSingleAccuracy ( double x )

inlinestatic

Double acos, but with single accuracy.

Parameters

x	The argument to evaluate acos for

Returns: Acos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static OutputAdapterContainer gmx::addOutputAdapters	(	const OutputRequirements &	requirements,
		AtomsDataPtr	atoms,
		const Selection &	sel,
		unsigned long	abilities
	)

static

Creates a new container object with the user requested IOutputAdapter derived methods attached to it.

Parameters

[in]	requirements	Specifications for modules to add.
[in]	atoms	Local copy of atom information to use.
[in]	sel	Selection to use for choosing atoms to write out.
[in]	abilities	Specifications for what the output method can do.

Returns: New container for IoutputAdapter derived methods.

void gmx::addWithCoupled	(	ArrayRef< const int >	iatoms,
		const int	stride,
		ArrayRef< const std::vector< AtomsAdjacencyListElement >>	atomsAdjacencyList,
		ArrayRef< int >	splitMap,
		const int	c,
		int *	currentMapIndex
	)

inline

Add constraint to splitMap with all constraints coupled to it.

Adds the constraint c from the constrain list iatoms to the map splitMap if it was not yet added. Then goes through all the constraints coupled to c and calls itself recursively. This ensures that all the coupled constraints will be added to neighboring locations in the final data structures on the device, hence mapping all coupled constraints to the same thread block. A value of -1 in the splitMap is used to flag that constraint was not yet added to the splitMap.

Parameters

[in]	iatoms	The list of constraints.
[in]	stride	Number of elements per constraint in `iatoms`.
[in]	atomsAdjacencyList	Information about connections between atoms.
[out]	splitMap	Map of sequential constraint indexes to indexes to be on the device
[in]	c	Sequential index for constraint to consider adding.
[in,out]	currentMapIndex	The rolling index for the constraints mapping.

static void gmx::adjustAtomInformation	(	t_atoms *	atoms,
		t_atoms *	selectionAtoms,
		const Selection &	sel
	)

static

Modify atoms information in coordinate frame to fit output selection.

Changes the information contained in the coordinate frame t_atoms struct to match the selection provided to the module.

Parameters

[in]	atoms	Pointer to original t_atoms.
[in]	selectionAtoms	Pointer to local atoms.
[in]	sel	Reference to selection.

bool gmx::advancePointInSubgrid	(	const BiasGrid &	grid,
		const awh_ivec	subgridOrigin,
		const awh_ivec	subgridNpoints,
		int *	gridPointIndex
	)

Find the next grid point in the sub-part of the grid given a starting point.

The given grid point index is updated to the next valid grid point index by traversing the sub-part of the grid, here termed the subgrid. Since the subgrid range might extend beyond the actual size of the grid, the subgrid is traversed until a point both in the subgrid and grid is found. If no point is found, the function returns false and the index is not modified. The starting point needs to be inside of the subgrid. However, if this index is not given, meaning < 0, then the search is initialized at the subgrid origin, i.e. in this case the "next" grid point index is defined to be the first common grid/subgrid point.

Parameters

[in]	grid	The grid.
[in]	subgridOrigin	Vector locating the subgrid origin relative to the grid origin.
[in]	subgridNpoints	Number of points along each subgrid dimension.
[in,out]	gridPointIndex	Pointer to the starting/next grid point index.

Returns: true if the grid point was updated.

static float gmx::andNot	(	float	a,
		float	b
	)

inlinestatic

Bitwise andnot for two scalar float variables.

Parameters

a	data1
b	data2

Returns: (~data1) & data2

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::andNot	(	double	a,
		double	b
	)

inlinestatic

Bitwise andnot for two scalar double variables.

Parameters

a	data1
b	data2

Returns: (~data1) & data2

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::andNot	(	std::int32_t	a,
		std::int32_t	b
	)

inlinestatic

Bitwise andnot for two scalar integer variables.

Parameters

a	data1
b	data2

Returns: (~data1) & data2

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static bool gmx::anyBiasIsScaledByMetric ( const AwhParams & awhParams )

static

Checks whether any bias scales the target distribution based on the AWH friction metric.

Parameters

[in] awhParams The AWH params to check.

Returns: true if any of the biases scale the target distribution by the friction metric.

static bool gmx::anyDimUsesProvider	(	const AwhBiasParams &	awhBiasParams,
		const AwhCoordinateProviderType	awhCoordProvider
	)

static

Checks whether any dimension uses the given coordinate provider type.

Parameters

[in]	awhBiasParams	The bias params to check.
[in]	awhCoordProvider	The type of coordinate provider

Returns: true if any dimension of the bias is linked to the given provider

static bool gmx::anyDimUsesProvider	(	const AwhParams &	awhParams,
		const AwhCoordinateProviderType	awhCoordProvider
	)

static

Checks whether any dimension uses the given coordinate provider type.

Parameters

[in]	awhParams	The AWH params to check.
[in]	awhCoordProvider	The type of coordinate provider

Returns: true if any dimension of awh is linked to the given provider type.

static bool gmx::anyTrue ( bool a )

inlinestatic

Returns if the boolean is true.

Parameters

a	Logical variable.

Returns: true if a is true, otherwise false.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

void gmx::applyGlobalSimulationState	(	const SimulationInput &	simulationInput,
		PartialDeserializedTprFile *	partialDeserializedTpr,
		t_state *	globalState,
		t_inputrec *	inputrec,
		gmx_mtop_t *	globalTopology
	)

Get the global simulation input.

Acquire global simulation data structures from the SimulationInput handle. Note that global data is returned in the calling thread. In parallel computing contexts, the client is responsible for calling only where needed.

Example: if (SIMMAIN(cr)) { // Only the main rank has the global state globalState = globalSimulationState(simulationInput);

// Read (nearly) all data required for the simulation applyGlobalInputRecord(simulationInput, inputrec); applyGlobalTopology(simulationInput, &mtop); }

Todo:: Factor the logic for global/local and main-rank-checks. The SimulationInput utilities should behave properly for the various distributed data scenarios. Consider supplying data directly to the consumers rather than exposing the implementation details of the legacy aggregate types.

void gmx::applyLocalState	(	const SimulationInput &	simulationInput,
		t_fileio *	logfio,
		const t_commrec *	cr,
		int *	dd_nc,
		t_inputrec *	ir,
		t_state *	state,
		ObservablesHistory *	observablesHistory,
		bool	reproducibilityRequested,
		const MDModulesNotifiers &	notifiers,
		gmx::ReadCheckpointDataHolder *	modularSimulatorCheckpointData,
		bool	useModularSimulator
	)

Initialize local stateful simulation data.

Establish an invariant for the simulator at a trajectory point. Call on all ranks (after domain decomposition and task assignments).

After this call, the simulator has all of the information it will receive in order to advance a trajectory from the current step. Checkpoint information has been applied, if applicable, and stateful data has been (re)initialized.

Warning: Mdrunner instances do not clearly distinguish between global and local versions of t_state.

Todo:: Factor the distributed data aspects of simulation input data into the SimulationInput implementation.

Todo:: Consider refactoring to decouple the checkpoint facility from its consumers (state, observablesHistory, mdModulesNotifiers, and parts of ir).

Warning: It is the caller’s responsibility to make sure that preconditions are satisfied for the parameter objects.

See Also: globalSimulationState(); applyGlobalInputRecord(); applyGlobalTopology()

static float gmx::asin ( float x )

inlinestatic

float asin.

Parameters

x	The argument to evaluate asin for

Returns: Asin(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::asin ( double x )

inlinestatic

Double asin.

Parameters

x	The argument to evaluate asin for

Returns: Asin(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::asinSingleAccuracy ( double x )

inlinestatic

Double asin, but with single accuracy.

Parameters

x	The argument to evaluate asin for

Returns: Asin(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::assertMatrixIsBoxMatrix ( const Matrix3x3 gmx_used_in_debug & m )

inlinestatic

Assert that the matrix m describes a simulation box.

The GROMACS convention is that all simulation box descriptions are normalized to have zero entries in the upper triangle. This function asserts if that is not true.

static void gmx::assertMatrixIsBoxMatrix ( const matrix gmx_used_in_debug m )

inlinestatic

Assert that the matrix m describes a simulation box.

The GROMACS convention is that all simulation box descriptions are normalized to have zero entries in the upper triangle. This function asserts if that is not true.

static void gmx::assignVsitesToThread	(	VsiteThread *	tData,
		int	thread,
		int	nthread,
		int	natperthread,
		gmx::ArrayRef< int >	taskIndex,
		ArrayRef< const InteractionList >	ilist,
		ArrayRef< const t_iparams >	ip,
		ArrayRef< const ParticleType >	ptype
	)

static

Here we try to assign all vsites that are in our local range.

Our task local atom range is tData->rangeStart - tData->rangeEnd. Vsites that depend only on local atoms, as indicated by taskIndex[]==thread, are assigned to task tData->ilist. Vsites that depend on non-local atoms but not on other vsites are assigned to task tData->id_task.ilist. taskIndex[] is set for all vsites in our range, either to our local tasks or to the single last task as taskIndex[]=2*nthreads.

static float gmx::atan ( float x )

inlinestatic

Float atan.

Parameters

x	The argument to evaluate atan for

Returns: Atan(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::atan ( double x )

inlinestatic

Double atan.

Parameters

x	The argument to evaluate atan for

Returns: Atan(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::atan2	(	float	y,
		float	x
	)

inlinestatic

Float atan2(y,x).

Parameters

y	Y component of vector, any quartile
x	X component of vector, any quartile

Returns: Atan(y,x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::atan2	(	double	y,
		double	x
	)

inlinestatic

Double atan2(y,x).

Parameters

y	Y component of vector, any quartile
x	X component of vector, any quartile

Returns: Atan(y,x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::atan2SingleAccuracy	(	double	y,
		double	x
	)

inlinestatic

Double atan2(y,x), but with single accuracy.

Parameters

y	Y component of vector, any quartile
x	X component of vector, any quartile

Returns: Atan(y,x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::atanSingleAccuracy ( double x )

inlinestatic

Double atan, but with single accuracy.

Parameters

x	The argument to evaluate atan for

Returns: Atan(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static InteractionLocality gmx::atomToInteractionLocality ( const AtomLocality atomLocality )

inlinestatic

Convert atom locality to interaction locality.

In the current implementation the this is straightforward conversion: local to local, non-local to non-local.

Parameters

[in] atomLocality Atom locality specifier

Returns: Interaction locality corresponding to the atom locality passed.

template<class BasicMdspan >

constexpr std::enable_if_t<BasicMdspan::is_always_contiguous(), typename BasicMdspan::pointer> gmx::begin ( const BasicMdspan & basicMdspan )

Free begin function addressing memory of a contiguously laid out basic_mdspan.

Note: Changing the elements that basic_mdspan views does not change the view itself, so a single begin that takes a const view suffices.

void gmx::biasesAreCompatibleForSharingBetweenSimulations	(	const AwhParams &	awhParams,
		ArrayRef< const size_t >	pointSize,
		const BiasSharing &	biasSharing
	)

Checks whether biases are compatible for sharing between simulations, throws when not.

Should be called simultaneously on the main rank of every simulation. Note that this only checks for technical compatibility. It is up to the user to check that the sharing physically makes sense. Throws an exception when shared biases are not compatible.

Parameters

[in]	awhParams	The AWH parameters.
[in]	pointSize	Vector of grid-point sizes for each bias.
[in]	biasSharing	Object for communication for sharing bias data over simulations.

static float gmx::blend	(	float	a,
		float	b,
		bool	sel
	)

inlinestatic

Blend float selection.

Parameters

a	First source
b	Second source
sel	Boolean selector

Returns: Select b if sel is true, a otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::blend	(	double	a,
		double	b,
		bool	sel
	)

inlinestatic

Blend double selection.

Parameters

a	First source
b	Second source
sel	Boolean selector

Returns: Select b if sel is true, a otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::blend	(	std::int32_t	a,
		std::int32_t	b,
		bool	sel
	)

inlinestatic

Blend integer selection.

Parameters

a	First source
b	Second source
sel	Boolean selector

Returns: Select b if sel is true, a otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

void gmx::blockaToExclusionBlocks	(	const t_blocka *	b,
		gmx::ArrayRef< ExclusionBlock >	b2
	)

Convert the exclusions.

Convert t_blocka exclusions in b into ExclusionBlock form and include them in b2.

Parameters

[in]	b	Exclusions in t_blocka form.
[in,out]	b2	ExclusionBlocks to populate with t_blocka exclusions.

std::unique_ptr< BoxDeformation > gmx::buildBoxDeformation	(	const Matrix3x3 &	initialBox,
		DDRole	ddRole,
		NumRanks	numRanks,
		MPI_Comm	communicator,
		const t_inputrec &	inputrec
	)

Factory function for box deformation module.

If the inputrec specifies the use of box deformation during the update phase, communicates the initialBox from SIMMAIN to other ranks, and constructs and returns an object to manage that update.

Exceptions

NotImplementedError if the inputrec specifies an unsupported combination.

bool gmx::buildSupportsListedForcesGpu ( std::string * error )

Checks whether the GROMACS build allows to compute bonded interactions on a GPU.

Parameters

[out] error If non-null, the diagnostic message when bondeds cannot run on a GPU.

Returns: true when this build can run bonded interactions on a GPU, false otherwise.

Exceptions

std::bad_alloc when out of memory.

real gmx::calculateAcceptanceWeight	(	LambdaWeightCalculation	calculationMode,
		real	lambdaEnergyDifference
	)

Calculates the acceptance weight for a lambda state transition.

Parameters

[in]	calculationMode	How the lambda weights are calculated
[in]	lambdaEnergyDifference	The difference in energy between the two states

Returns: The acceptance weight

template<MathOptimization opt = MathOptimization::Safe>

static float gmx::cbrt ( float x )

inlinestatic

Float cbrt(x). This is the cubic root.

Parameters

x	Argument, should be >= 0.

Returns: The cubic root of x. Undefined if argument is invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<MathOptimization opt = MathOptimization::Safe>

static double gmx::cbrt ( double x )

inlinestatic

Double cbrt(x). This is the cubic root.

Parameters

x	Argument, should be >= 0.

Returns: The cubic root of x. Undefined if argument is invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

const char * gmx::centerTypeNames ( CenteringType type )

Get names for the different centering types.

Parameters

[in] type What name needs to be provided.

template<typename PinnableVector >

void gmx::changePinningPolicy	(	PinnableVector *	v,
		PinningPolicy	pinningPolicy
	)

Helper function for changing the pinning policy of a pinnable vector.

If the vector has contents, then a full reallocation and buffer copy are needed if the policy change requires tighter restrictions, and desirable even if the policy change requires looser restrictions. That cost is OK, because GROMACS will do this operation very rarely (e.g. when auto-tuning and deciding to switch whether a task will run on a GPU, or not).

void gmx::checkAwhParams	(	const AwhParams &	awhParams,
		const t_inputrec &	inputrec,
		WarningHandler *	wi
	)

Check the AWH parameters.

Parameters

[in]	awhParams	The AWH parameters.
[in]	inputrec	Input parameter struct.
[in,out]	wi	Struct for bookeeping warnings.

static DeviceStatus gmx::checkGpu	(	size_t	deviceId,
		const DeviceInformation &	deviceInfo
	)

static

Check whether the ocl_gpu_device is suitable for use by mdrun.

Runs sanity checks: checking that the runtime can compile a dummy kernel and this can be executed; Runs compatibility checks verifying the device OpenCL version requirement and vendor/OS support.

Parameters

[in]	deviceId	The runtime-reported numeric ID of the device.
[in]	deviceInfo	The device info pointer.

Returns: A DeviceStatus to indicate if the GPU device is supported and if it was able to run basic functionality checks.

static bool gmx::checkIfRandomDeviceIsFunctional ( )

static

Check if the RDRAND random device functioning correctly.

Due to a bug in AMD Ryzen microcode, RDRAND may always return -1 (0xFFFFFFFF). To avoid that, fall back to using PRNG instead of RDRAND if this happens.

Returns: The result of the checks.

static void gmx::checkInputConsistencyInterval	(	const AwhParams &	awhParams,
		WarningHandler *	wi
	)

static

Check if the starting configuration is consistent with the given interval.

Parameters

[in]	awhParams	AWH parameters.
[in,out]	wi	Struct for bookeeping warnings.

GpuAwareMpiStatus gmx::checkMpiCudaAwareSupport ( )

Wrapper on top of MPIX_Query_cuda_support() For MPI implementations which don't support this function, it returns NotSupported. Even when an MPI implementation does support this function, MPI library might not be robust enough to detect CUDA-aware support at runtime correctly e.g. when UCX PML is used or CUDA is disabled at runtime.

Returns: CUDA-aware status in MPI implementation

GpuAwareMpiStatus gmx::checkMpiHipAwareSupport ( )

Wrapper on top of MPIX_Query_hip_support() or MPIX_Query_rocm_support(). For MPI implementations which don't support this function, it returns NotSupported.

Currently, this function is only supported by MPICH and OpenMPI 5.0-rc, and is not very reliable.

Returns: HIP-aware status in MPI implementation

GpuAwareMpiStatus gmx::checkMpiZEAwareSupport ( )

Wrapper on top of MPIX_Query_ze_support() (for MPICH) or custom logic (for IntelMPI).

For other MPI implementations which perhaps don't support the above function, it returns NotSupported.

Returns: LevelZero-aware status in MPI implementation

std::vector< std::string > gmx::checkMtsRequirements ( const t_inputrec & ir )

Checks whether the MTS requirements on other algorithms and output frequencies are met.

Note: exits with an assertion failure when ir.useMts == true && haveValidMtsSetup(ir) == false

Parameters

[in] ir Complete input record

Returns: list of error messages, empty when all MTS requirements are met

template<typename VersionEnum >

VersionEnum gmx::checkpointVersion	(	const ReadCheckpointData *	checkpointData,
		const std::string &	key,
		const VersionEnum	programVersion
	)

Read a checkpoint version enum variable.

This reads the checkpoint version from file. The read version is returned.

If the read version is more recent than the code version, this throws an error, since we cannot know what has changed in the meantime. Using newer checkpoint files with old code is not a functionality we can offer. Note, however, that since the checkpoint version is saved by module, older checkpoint files of all simulations that don't use that specific module can still be used.

Allowing backwards compatibility of files (i.e., reading an older checkpoint file with a newer version of the code) is in the responsibility of the caller module. They can use the returned file checkpoint version to do that:

const auto fileVersion = checkpointVersion(checkpointData, "version", c_currentVersion);
if (fileVersion >= CheckpointVersion::AddedX)
{
    checkpointData->scalar("x", &x_));
}

Template Parameters

VersionEnum The type of the checkpoint version enum

Parameters

checkpointData	A reading checkpoint data object
key	The key under which the version is saved - also used for error output
programVersion	The checkpoint version of the current code

Returns: The checkpoint version read from file

template<typename VersionEnum >

VersionEnum gmx::checkpointVersion	(	WriteCheckpointData *	checkpointData,
		const std::string &	key,
		const VersionEnum	programVersion
	)

Write the current code checkpoint version enum variable.

Write the current program checkpoint version to the checkpoint data object. Returns the written checkpoint version to mirror the signature of the reading version.

Template Parameters

VersionEnum The type of the checkpoint version enum

Parameters

checkpointData	A writing checkpoint data object
key	The key under which the version is saved
programVersion	The checkpoint version of the current code

Returns: The checkpoint version written to file

void gmx::checkUserGpuIds	(	ArrayRef< const std::unique_ptr< DeviceInformation >>	deviceInfoList,
		ArrayRef< const int >	compatibleGpus,
		ArrayRef< const int >	gpuIds
	)

Check that all user-selected GPUs are compatible.

Given the gpuIds and hardwareInfo, throw if any selected GPUs is not compatible.

The error is given with a suitable descriptive message, which will have context if this check is done after the hardware detection results have been reported to the user. However, note that only the GPUs detected on the main rank are reported, because of the existing limitations of that reporting.

Todo:: Note that the selected GPUs can be different on each rank, and the IDs of compatible GPUs can be different on each node, so this routine ought to do communication to determine whether all ranks are able to proceed. Currently this relies on the MPI runtime to kill the other processes because GROMACS lacks the appropriate infrastructure to do a good job of coordinating error messages and behaviour across MPMD ranks and multiple simulations.

Parameters

[in]	deviceInfoList	Information on the GPUs on this physical node.
[in]	compatibleGpus	Vector of GPUs that are compatible
[in]	gpuIds	The GPU IDs selected by the user.

Exceptions

std::bad_alloc If out of memory InconsistentInputError If the assigned GPUs are not valid

template<KernelLayoutClusterRatio clusterRatio>

static int gmx::cjFromCi ( const int iCluster )

inlinestatic

Returns the j-cluster index for the given i-cluster index.

Template Parameters

clusterRatio The ratio of cluster size, supported are 0.5,1,2, checked at compile time

Parameters

iCluster The index of the i-cluster

Returns: the j-cluster index corresponding to iCluster

static double gmx::computeDerivativeForTransformationPullCoord	(	pull_coord_work_t *	coord,
		const int	variablePcrdIndex
	)

static

Calculates and returns the derivative of a transformation pull coordinate from a dependent coordinate.

Note #1: this requires that getTransformationPullCoordinateValue() has been called before with the current coordinates.

Note #2: this method will not compute inner derivates. That is taken care of in the regular pull code

Parameters

[in]	coord	The (transformation) coordinate to compute the value for
[in]	variablePcrdIndex	Pull coordinate index of a variable.

static int gmx::computeExpectedNumGlobalBondedInteractions	(	const gmx_mtop_t &	mtop,
		const DDBondedChecking	ddBondedChecking,
		const bool	useUpdateGroups
	)

static

Compute the total bonded interaction count.

Parameters

[in]	mtop	The global system topology
[in]	ddBondedChecking	Which interations to check
[in]	useUpdateGroups	Whether update groups are in use

When using domain decomposition without update groups, constraint-type interactions can be split across domains, and so we do not consider them in this correctness check. Otherwise, we include them.

int gmx::computeFepPeriod	(	const t_inputrec &	inputrec,
		const ReplicaExchangeParameters &	replExParams
	)

Compute the period at which FEP calculation is performed.

This harmonizes the free energy calculation period specified by nstdhdl with the periods specified by expanded ensemble, replica exchange, and AWH.

Parameters

inputrec	The input record
replExParams	The replica exchange parameters

Returns: The period required by the involved algorithms

real gmx::computeMaxUpdateGroupRadius	(	const gmx_mtop_t &	mtop,
		ArrayRef< const RangePartitioning >	updateGroupingPerMoleculeType,
		real	temperature
	)

Returns the maximum update group radius.

Note: When updateGroups is empty, 0 is returned.

Parameters

[in]	mtop	The system topology
[in]	updateGroupingPerMoleculeType	List of update group, size should match the number of moltypes in `mtop` or be 0
[in]	temperature	The maximum reference temperature, pass -1 when unknown or not applicable

RVec gmx::computeQMBoxVec	(	const RVec &	a,
		const RVec &	b,
		const RVec &	c,
		real	h,
		real	minNorm,
		real	maxNorm
	)

Transforms vector a such as distance from it to the plane defined by vectors b and c will be h minimum length will be milL and maximum length maxL.

Parameters

[in]	a	Vector which should be scaled
[in]	b	First vector that forms the plane
[in]	c	Second vector that forms the plane
[in]	h	Distance from the end of a to the plane of (b,c)
[in]	minNorm	Minimum norm of vector
[in]	maxNorm	Maximum norm of vector

void gmx::constrain_coordinates	(	gmx::Constraints *	constr,
		bool	do_log,
		bool	do_ene,
		int64_t	step,
		t_state *	state,
		ArrayRefWithPadding< RVec >	xp,
		real *	dvdlambda,
		bool	computeVirial,
		tensor	constraintsVirial
	)

Constraint coordinates.

The dvdlambda contribution has to be added to the bonded interactions

bool gmx::constrain_lincs	(	bool	computeRmsd,
		const t_inputrec &	ir,
		int64_t	step,
		Lincs *	lincsd,
		ArrayRef< const real >	invmass,
		const t_commrec *	cr,
		const gmx_multisim_t *	ms,
		ArrayRefWithPadding< const RVec >	x,
		ArrayRefWithPadding< RVec >	xprime,
		ArrayRef< RVec >	min_proj,
		const matrix	box,
		t_pbc *	pbc,
		bool	hasMassPerturbed,
		real	lambda,
		real *	dvdlambda,
		real	invdt,
		ArrayRef< RVec >	v,
		bool	bCalcVir,
		tensor	vir_r_m_dr,
		ConstraintVariable	econq,
		t_nrnb *	nrnb,
		int	maxwarn,
		int *	warncount,
		gmx_wallcycle *	wcycle
	)

Applies LINCS constraints.

Returns: true if the constraining succeeded.

void gmx::constrain_velocities	(	gmx::Constraints *	constr,
		bool	do_log,
		bool	do_ene,
		int64_t	step,
		t_state *	state,
		real *	dvdlambda,
		bool	computeVirial,
		tensor	constraintsVirial
	)

Constrain velocities only.

The dvdlambda contribution has to be added to the bonded interactions

template<int numPartnerAtoms>

static real gmx::constraintGroupRadius	(	const gmx_moltype_t &	moltype,
		gmx::ArrayRef< const t_iparams >	iparams,
		const int	centralAtom,
		const ListOfLists< int > &	at2con,
		const std::unordered_multimap< int, int > &	angleIndices,
		const real	constraintLength,
		const real	temperature
	)

static

When possible, computes the maximum radius of constrained atom in an update group.

Supports groups with 2 or 3 atoms where all partner atoms are connected to each other by angle potentials. The temperature is used to compute a radius that is not exceeded with a chance of 10^-9. Note that this computation assumes there are no other strong forces working on these angular degrees of freedom. The return value is -1 when all partners are not connected to each other by one angle potential, when a potential is perturbed or when an angle could reach more than 180 degrees.

template<VSiteCalculatePosition calculatePosition, VSiteCalculateVelocity calculateVelocity>

static void gmx::construct_vsites	(	const ThreadingInfo *	threadingInfo,
		ArrayRef< RVec >	x,
		ArrayRef< RVec >	v,
		ArrayRef< const t_iparams >	ip,
		ArrayRef< const InteractionList >	ilist,
		const DomainInfo &	domainInfo,
		const matrix	box
	)

static

Dispatch the vsite construction tasks for all threads.

Parameters

[in]	threadingInfo	Used to divide work over threads when != nullptr
[in,out]	x	Coordinates to construct vsites for
[in,out]	v	When not empty, velocities are generated for virtual sites
[in]	ip	Interaction parameters for all interaction, only vsite parameters are used
[in]	ilist	The interaction lists, only vsites are usesd
[in]	domainInfo	Information about PBC and DD
[in]	box	Used for PBC when PBC is set in domainInfo

template<VSiteCalculatePosition calculatePosition, VSiteCalculateVelocity calculateVelocity>

static void gmx::construct_vsites_thread	(	ArrayRef< RVec >	x,
		ArrayRef< RVec >	v,
		ArrayRef< const t_iparams >	ip,
		ArrayRef< const InteractionList >	ilist,
		const t_pbc *	pbc_null
	)

static

Executes the vsite construction task for a single thread.

Template Parameters

calculatePosition	Whether we are calculating positions
calculateVelocity	Whether we are calculating velocities

Parameters

[in,out]	x	Coordinates to construct vsites for
[in,out]	v	Velocities are generated for virtual sites if calculateVelocity is true
[in]	ip	Interaction parameters for all interaction, only vsite parameters are used
[in]	ilist	The interaction lists, only vsites are usesd
[in]	pbc_null	PBC struct, used for PBC distance calculations when !=nullptr

void gmx::constructVirtualSites	(	ArrayRef< RVec >	x,
		ArrayRef< const t_iparams >	ip,
		ArrayRef< const InteractionList >	ilist
	)

Create positions of vsite atoms based for the local system.

Parameters

[in,out]	x	The coordinates
[in]	ip	Interaction parameters
[in]	ilist	The interaction list

void gmx::constructVirtualSitesGlobal	(	const gmx_mtop_t &	mtop,
		ArrayRef< RVec >	x
	)

Create positions of vsite atoms for the whole system assuming all molecules are wholex.

Parameters

[in]	mtop	The global topology
[in,out]	x	The global coordinates

static CheckpointSignal gmx::convertToCheckpointSignal ( signed char sig )

inlinestatic

Convert signed char (as used by SimulationSignal) to CheckpointSignal enum.

Expected values are sig == 0 – no signal sig >= 1 – signal received

static ResetSignal gmx::convertToResetSignal ( signed char sig )

inlinestatic

Convert signed char (as used by SimulationSignal) to ResetSignal enum.

Expected values are sig == 0 – no signal sig >= 1 – signal received

static StopSignal gmx::convertToStopSignal ( signed char sig )

inlinestatic

Convert signed char (as used by SimulationSignal) to StopSignal enum.

Expected values are sig == 0 – no signal sig >= 1 – stop at next NS sig <= -1 – stop asap

static float gmx::copysign	(	float	x,
		float	y
	)

inlinestatic

Composes single value with the magnitude of x and the sign of y.

Parameters

x	Value to set sign for
y	Value used to set sign

Returns: Magnitude of x, sign of y

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::copysign	(	double	x,
		double	y
	)

inlinestatic

Composes double value with the magnitude of x and the sign of y.

Parameters

x	Value to set sign for
y	Value used to set sign

Returns: Magnitude of x, sign of y

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::cos ( float x )

inlinestatic

Float cos.

Parameters

x	The argument to evaluate cos for

Returns: Cos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::cos ( double x )

inlinestatic

Double cos.

Parameters

x	The argument to evaluate cos for

Returns: Cos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::cosSingleAccuracy ( double x )

inlinestatic

Double cos, but with single accuracy.

Parameters

x	The argument to evaluate cos for

Returns: Cos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

int gmx::countInterUpdategroupVsites	(	const gmx_mtop_t &	mtop,
		ArrayRef< const RangePartitioning >	updateGroupingsPerMoleculeType
	)

Return the number of virtual sites that cross update groups.

Parameters

[in]	mtop	The global topology
[in]	updateGroupingsPerMoleculeType	Update grouping per molecule type, pass empty when not using update groups

static int64_t gmx::countSamples ( ArrayRef< const PointState > pointState )

static

Count the total number of samples / sample weight over all grid points.

Parameters

[in] pointState The state of the points in a bias.

Returns: the total sample count.

static int gmx::countTrailingZeroRows	(	const MultiDimArray< std::vector< double >, dynamicExtents2D > &	data,
		int	numRows,
		int	numColumns
	)

static

Count trailing data rows containing only zeros.

Parameters

[in]	data	2D data array.
[in]	numRows	Number of rows in array.
[in]	numColumns	Number of cols in array.

Returns: the number of trailing zero rows.

bool gmx::cpuIsAmdZen1 ( const CpuInfo & cpuInfo )

Return true if the CPU is a first generation AMD Zen (produced by AMD or Hygon)

Parameters

cpuInfo Object with cpu information

Returns: True if running on a first generation AMD Zen

bool gmx::cpuIsX86Nehalem ( const CpuInfo & cpuInfo )

Return true if the CPU is an Intel x86 Nehalem.

Parameters

cpuInfo Object with cpu information

Returns: True if running on Nehalem CPU

std::unique_ptr< IMDModule > gmx::createElectricFieldModule ( )

Creates a module for an external electric field.

The returned class describes the time dependent electric field that can be applied to all charges in a simulation. The field is described by the following: E(t) = A cos(omega*(t-t0))*exp(-sqr(t-t0)/(2.0*sqr(sigma))); If sigma = 0 there is no pulse and we have instead E(t) = A cos(omega*t)

force is kJ mol^-1 nm^-1 = e * kJ mol^-1 nm^-1 / e

WARNING: There can be problems with the virial. Since the field is not self-consistent this is unavoidable. For neutral molecules the virial is correct within this approximation. For neutral systems with many charged molecules the error is small. But for systems with a net charge or a few charged molecules the error can be significant when the field is high. Solution: implement a self-consistent electric field into PME.

SimulationWorkload gmx::createSimulationWorkload	(	const t_inputrec &	inputrec,
		bool	disableNonbondedCalculation,
		const DevelopmentFeatureFlags &	devFlags,
		bool	havePpDomainDecomposition,
		bool	haveSeparatePmeRank,
		bool	useGpuForNonbonded,
		PmeRunMode	pmeRunMode,
		bool	useGpuForBonded,
		bool	useGpuForUpdate,
		bool	useGpuDirectHalo,
		bool	canUseDirectGpuComm,
		bool	useGpuPmeDecomposition
	)

Build datastructure that contains decisions whether to run different workload task on GPUs.

Parameters

[in]	inputrec	The input record
[in]	disableNonbondedCalculation	Disable calculation of nonbonded forces
[in]	devFlags	The development feature flags
[in]	havePpDomainDecomposition	Whether PP domain decomposition is used in this run.
[in]	haveSeparatePmeRank	Whether separate PME rank(s) are used in this run.
[in]	useGpuForNonbonded	Whether we have short-range nonbonded interactions calculations on GPU(s).
[in]	pmeRunMode	Run mode indicating what resource is PME executed on.
[in]	useGpuForBonded	Whether bonded interactions are calculated on GPU(s).
[in]	useGpuForUpdate	Whether coordinate update and constraint solving is performed on GPU(s).
[in]	useGpuDirectHalo	Whether halo exchange is performed directly between GPUs.
[in]	canUseDirectGpuComm	Whether direct GPU communication can be used in this run.
[in]	useGpuPmeDecomposition	GPU based PME decomposition used.

Returns: Simulation lifetime constant workload description.

std::unique_ptr< TrajectoryFrameWriter > gmx::createTrajectoryFrameWriter	(	const gmx_mtop_t *	top,
		const Selection &	sel,
		const std::string &	filename,
		AtomsDataPtr	atoms,
		OutputRequirements	requirements
	)

Factory function for TrajectoryFrameWriter.

Used to initialize a new instance of TrajectoryFrameWriter with the user supplied information for writing trajectory data to disk. Information needed is the file type, file name corresponding to the type, if available topology information and selection information.

If supplied, the modules contained within adapters are registered on the TrajectoryFrameWriter if possible.

The factory function is responsible for the initial santity checks concerning file types and availability of topology information, with the registration of modules being the second part.

Parameters

[in]	top	Pointer to full topology or null.
[in]	sel	Reference to global selection used to construct the object.
[in]	filename	Name of new output file, used to deduce file type.
[in]	atoms	Smart Pointer to atoms data or null.
[in]	requirements	Container for settings obtained to specify which OutputAdapters should be registered.

Exceptions

InconsistentInputError When user input and requirements don't match.

void gmx::cshake	(	const int	iatom[],
		int	ncon,
		int *	nnit,
		int	maxnit,
		ArrayRef< const real >	constraint_distance_squared,
		ArrayRef< RVec >	positions,
		const t_pbc *	pbc,
		ArrayRef< const RVec >	initial_displacements,
		ArrayRef< const real >	half_of_reduced_mass,
		real	omega,
		ArrayRef< const real >	invmass,
		ArrayRef< const real >	distance_squared_tolerance,
		ArrayRef< real >	scaled_lagrange_multiplier,
		int *	nerror
	)

Inner kernel for SHAKE constraints.

Regular iterative shake.

Original implementation from R.C. van Schaik and W.F. van Gunsteren (ETH Zuerich, June 1992), adapted for GROMACS by David van der Spoel November 1992.

The algorithm here is based section five of Ryckaert, Ciccotti and Berendsen, J Comp Phys, 23, 327, 1977.

Parameters

[in]	iatom	Mini-topology of triplets of constraint type (unused in this function) and indices of two atoms involved
[in]	ncon	Number of constraints
[out]	nnit	Number of iterations performed
[in]	maxnit	Maximum number of iterations permitted
[in]	constraint_distance_squared	The objective value for each constraint
[in,out]	positions	The initial (and final) values of the positions of all atoms
[in]	pbc	PBC information
[in]	initial_displacements	The initial displacements of each constraint
[in]	half_of_reduced_mass	Half of the reduced mass for each constraint
[in]	omega	SHAKE over-relaxation factor (set non-1.0 by using shake-sor=yes in the .mdp, but there is no documentation anywhere)
[in]	invmass	Inverse mass of each atom
[in]	distance_squared_tolerance	Multiplicative tolerance on the difference in the square of the constrained distance (see code)
[out]	scaled_lagrange_multiplier	Scaled Lagrange multiplier for each constraint (-2 * eta from p. 336 of the paper, divided by the constraint distance)
[out]	nerror	Zero upon success, returns one more than the index of the problematic constraint if the input was malformed

Todo:: Make SHAKE use better data structures, in particular for iatom.

gmx::EnumerationArray< FreeEnergyPerturbationCouplingType, real > gmx::currentLambdas	(	int64_t	step,
		const t_lambda &	fepvals,
		int	currentLambdaState
	)

Evaluate the current lambdas.

Parameters

[in]	step	the current simulation step
[in]	fepvals	describing the lambda setup
[in]	currentLambdaState	the lambda state to use to set the lambdas, -1 if not set

Returns: the current lambda-value array

static bool gmx::cvtB2IB ( bool a )

inlinestatic

Just return a boolean (mimicks SIMD real-to-int bool conversions)

Parameters

a boolean

Returns: same boolean

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::cvtD2F ( double a )

inlinestatic

Convert double to float (mimicks SIMD conversion)

Parameters

a double

Returns: a, as float

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::cvtF2D ( float a )

inlinestatic

Convert float to double (mimicks SIMD conversion)

Parameters

a float

Returns: a, as double double

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::cvtI2R ( std::int32_t a )

inlinestatic

Return integer.

This function mimicks the SIMD integer-to-real conversion routines. By simply returning an integer, we let the compiler sort out whether the conversion should be to float or double rather than using proxy objects.

Parameters

a integer

Returns: same value (a)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static bool gmx::cvtIB2B ( bool a )

inlinestatic

Just return a boolean (mimicks SIMD int-to-real bool conversions)

Parameters

a boolean

Returns: same boolean

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::cvtR2I ( float a )

inlinestatic

Round single precision floating point to integer.

Parameters

a float

Returns: Integer format, a rounded to nearest integer.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::cvtR2I ( double a )

inlinestatic

Round single precision doubleing point to integer.

Parameters

a double

Returns: Integer format, a rounded to nearest integer.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::cvttR2I ( float a )

inlinestatic

Truncate single precision floating point to integer.

Parameters

a float

Returns: Integer format, a truncated to integer.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::cvttR2I ( double a )

inlinestatic

Truncate single precision doubleing point to integer.

Parameters

a double

Returns: Integer format, a truncated to integer.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

void gmx::dd_partition_system	(	FILE *	fplog,
		const gmx::MDLogger &	mdlog,
		int64_t	step,
		const t_commrec *	cr,
		bool	bMainState,
		t_state *	state_global,
		const gmx_mtop_t &	top_global,
		const t_inputrec &	inputrec,
		const MDModulesNotifiers &	mdModulesNotifiers,
		gmx::ImdSession *	imdSession,
		pull_t *	pull_work,
		t_state *	state_local,
		gmx::ForceBuffers *	f,
		gmx::MDAtoms *	mdAtoms,
		gmx_localtop_t *	top_local,
		t_forcerec *	fr,
		gmx::VirtualSitesHandler *	vsite,
		gmx::Constraints *	constr,
		t_nrnb *	nrnb,
		gmx_wallcycle *	wcycle,
		bool	bVerbose
	)

TODO Remove fplog when group scheme and charge groups are gone.

Partition the system over the nodes.

step is only used for printing error messages. If bMainState==TRUE then state_global from the main node is used, else state_local is redistributed between the nodes. When f!=NULL, *f will be reallocated to the size of state_local.

Parameters

[in]	fplog	Pointer to the log file
[in]	mdlog	MD file logger
[in]	step	Current step
[in]	cr	Communication record
[in]	bMainState	Is it a main state
[in]	state_global	Global state
[in]	top_global	Global topology
[in]	inputrec	Input record
[in]	mdModulesNotifiers	MDModules notifications handler
[in]	imdSession	IMD handle
[in]	pull_work	Pulling data
[in]	state_local	Local state
[in]	f	Force buffer
[in]	mdAtoms	MD atoms
[in]	top_local	Local topology
[in]	fr	Force record
[in]	vsite	Virtual sites handler
[in]	constr	Constraints
[in]	nrnb	Cycle counters
[in]	wcycle	Timers
[in]	bVerbose	Be verbose

bool gmx::decideWhetherDirectGpuCommunicationCanBeUsed	(	const DevelopmentFeatureFlags &	devFlags,
		bool	haveMts,
		bool	haveSwapCoords,
		const gmx::MDLogger &	mdlog
	)

Decide whether direct GPU communication can be used.

Takes into account the build type which determines feature support as well as GPU development feature flags, determines whether this run can use direct GPU communication. The final decision whether the run will use direct communication for either of the features which rely on it is made during task assignment / simulationWorkload initialization.

Parameters

[in]	devFlags	GPU development / experimental feature flags.
[in]	haveMts	Whether the simulation uses multiple time stepping
[in]	haveSwapCoords	Whether the swap-coords functionality is active
[in]	mdlog	MD logger.

Returns: Whether the MPI-parallel runs can use direct GPU communication.

bool gmx::decideWhetherToUseGpuForHalo	(	bool	havePPDomainDecomposition,
		bool	useGpuForNonbonded,
		bool	canUseDirectGpuComm,
		bool	useModularSimulator,
		bool	doRerun,
		bool	haveEnergyMinimization,
		const gmx::MDLogger &	mdlog
	)

Decide whether to use GPU for halo exchange.

Parameters

[in]	havePPDomainDecomposition	Whether PP domain decomposition is in use.
[in]	useGpuForNonbonded	Whether GPUs will be used for nonbonded interactions.
[in]	canUseDirectGpuComm	Whether direct GPU communication can be used.
[in]	useModularSimulator	Whether modularsimulator is in use.
[in]	doRerun	Whether this is a rerun.
[in]	haveEnergyMinimization	Whether energy minimization is in use.
[in]	mdlog	MD logger.

Returns: Whether halo exchange can be run on GPU.

bool gmx::decideWhetherToUseGpuForUpdate	(	bool	isDomainDecomposition,
		bool	useUpdateGroups,
		PmeRunMode	pmeRunMode,
		bool	havePmeOnlyRank,
		bool	useGpuForNonbonded,
		TaskTarget	updateTarget,
		bool	gpusWereDetected,
		const t_inputrec &	inputrec,
		const gmx_mtop_t &	mtop,
		bool	useEssentialDynamics,
		bool	doOrientationRestraints,
		bool	haveFrozenAtoms,
		bool	useModularSimulator,
		bool	doRerun,
		const gmx::MDLogger &	mdlog
	)

Decide whether to use GPU for update.

Parameters

[in]	isDomainDecomposition	Whether there more than one domain.
[in]	useUpdateGroups	If the constraints can be split across domains.
[in]	pmeRunMode	PME running mode: CPU, GPU or mixed.
[in]	havePmeOnlyRank	If there is a PME-only rank in the simulation.
[in]	useGpuForNonbonded	Whether GPUs will be used for nonbonded interactions.
[in]	updateTarget	User choice for running simulation on GPU.
[in]	gpusWereDetected	Whether compatible GPUs were detected on any node.
[in]	inputrec	The user input.
[in]	mtop	The global topology.
[in]	useEssentialDynamics	If essential dynamics is active.
[in]	doOrientationRestraints	If orientation restraints are enabled.
[in]	haveFrozenAtoms	If this simulation has frozen atoms (see Issue #3920).
[in]	useModularSimulator	Whether the modular simulator is used
[in]	doRerun	It this is a rerun.
[in]	mdlog	MD logger.

Returns: Whether complete simulation can be run on GPU.

Exceptions

std::bad_alloc If out of memory InconsistentInputError If the user requirements are inconsistent.

bool gmx::decideWhetherToUseGpusForBonded	(	bool	useGpuForNonbonded,
		bool	useGpuForPme,
		TaskTarget	bondedTarget,
		const t_inputrec &	inputrec,
		const gmx_mtop_t &	mtop,
		int	numPmeRanksPerSimulation,
		bool	gpusWereDetected
	)

Decide whether the simulation will try to run bonded tasks on GPUs.

Parameters

[in]	useGpuForNonbonded	Whether GPUs will be used for nonbonded interactions.
[in]	useGpuForPme	Whether GPUs will be used for PME interactions.
[in]	bondedTarget	The user's choice for mdrun -bonded for where to assign tasks.
[in]	inputrec	The user input.
[in]	mtop	The global topology.
[in]	numPmeRanksPerSimulation	The number of PME ranks in each simulation, can be -1 for auto.
[in]	gpusWereDetected	Whether compatible GPUs were detected on any node.

Returns: Whether the simulation will run bondeded tasks on GPUs.

Exceptions

std::bad_alloc If out of memory InconsistentInputError If the user requirements are inconsistent.

bool gmx::decideWhetherToUseGpusForNonbonded	(	TaskTarget	nonbondedTarget,
		const std::vector< int > &	userGpuTaskAssignment,
		EmulateGpuNonbonded	emulateGpuNonbonded,
		bool	buildSupportsNonbondedOnGpu,
		bool	nonbondedOnGpuIsUseful,
		bool	binaryReproducibilityRequested,
		bool	gpusWereDetected
	)

Decide whether the simulation will try to run nonbonded tasks on GPUs.

The final decision cannot be made until after the duty of the rank is known. But we need to know if nonbonded will run on GPUs for setting up DD (particularly rlist) and determining duty. If the user requires GPUs for the tasks of that duty, then it will be an error when none are found.

With thread-MPI, calls have been made to decideWhetherToUseGpusForNonbondedWithThreadMpi() and decideWhetherToUseGpusForPmeWithThreadMpi() to help determine the number of ranks and run some checks, but the final decision is made in this routine, along with many more consistency checks.

Parameters

[in]	nonbondedTarget	The user's choice for mdrun -nb for where to assign short-ranged nonbonded interaction tasks.
[in]	userGpuTaskAssignment	The user-specified assignment of GPU tasks to device IDs.
[in]	emulateGpuNonbonded	Whether we will emulate GPU calculation of nonbonded interactions.
[in]	buildSupportsNonbondedOnGpu	Whether GROMACS was build with GPU support.
[in]	nonbondedOnGpuIsUseful	Whether computing nonbonded interactions on a GPU is useful for this calculation.
[in]	binaryReproducibilityRequested	Whether binary reprocibility was requested
[in]	gpusWereDetected	Whether compatible GPUs were detected on any node.

Returns: Whether the simulation will run nonbonded and PME tasks, respectively, on GPUs.

Exceptions

std::bad_alloc If out of memory InconsistentInputError If the user requirements are inconsistent.

bool gmx::decideWhetherToUseGpusForNonbondedWithThreadMpi	(	TaskTarget	nonbondedTarget,
		bool	haveAvailableDevices,
		const std::vector< int > &	userGpuTaskAssignment,
		EmulateGpuNonbonded	emulateGpuNonbonded,
		bool	buildSupportsNonbondedOnGpu,
		bool	nonbondedOnGpuIsUseful,
		bool	binaryReproducibilityRequested,
		int	numRanksPerSimulation
	)

Decide whether this thread-MPI simulation will run nonbonded tasks on GPUs.

The number of GPU tasks and devices influences both the choice of the number of ranks, and checks upon any such choice made by the user. So we need to consider this before any automated choice of the number of thread-MPI ranks.

Parameters

[in]	nonbondedTarget	The user's choice for mdrun -nb for where to assign short-ranged nonbonded interaction tasks.
[in]	haveAvailableDevices	Whether there are available devices.
[in]	userGpuTaskAssignment	The user-specified assignment of GPU tasks to device IDs.
[in]	emulateGpuNonbonded	Whether we will emulate GPU calculation of nonbonded interactions.
[in]	buildSupportsNonbondedOnGpu	Whether GROMACS was built with GPU support.
[in]	nonbondedOnGpuIsUseful	Whether computing nonbonded interactions on a GPU is useful for this calculation.
[in]	binaryReproducibilityRequested	Whether binary reprocibility was requested
[in]	numRanksPerSimulation	The number of ranks in each simulation.

Returns: Whether the simulation will run nonbonded tasks on GPUs.

Exceptions

std::bad_alloc If out of memory InconsistentInputError If the user requirements are inconsistent.

bool gmx::decideWhetherToUseGpusForPme	(	bool	useGpuForNonbonded,
		TaskTarget	pmeTarget,
		TaskTarget	pmeFftTarget,
		const std::vector< int > &	userGpuTaskAssignment,
		const t_inputrec &	inputrec,
		int	numRanksPerSimulation,
		int	numPmeRanksPerSimulation,
		bool	gpusWereDetected
	)

Decide whether the simulation will try to run tasks of different types on GPUs.

The final decision cannot be made until after the duty of the rank is known. But we need to know if nonbonded will run on GPUs for setting up DD (particularly rlist) and determining duty. If the user requires GPUs for the tasks of that duty, then it will be an error when none are found.

With thread-MPI, calls have been made to decideWhetherToUseGpusForNonbondedWithThreadMpi() and decideWhetherToUseGpusForPmeWithThreadMpi() to help determine the number of ranks and run some checks, but the final decision is made in this routine, along with many more consistency checks.

Parameters

[in]	useGpuForNonbonded	Whether GPUs will be used for nonbonded interactions.
[in]	pmeTarget	The user's choice for mdrun -pme for where to assign long-ranged PME nonbonded interaction tasks.
[in]	pmeFftTarget	The user's choice for mdrun -pmefft for where to do FFT for PME.
[in]	userGpuTaskAssignment	The user-specified assignment of GPU tasks to device IDs.
[in]	inputrec	The user input
[in]	numRanksPerSimulation	The number of ranks in each simulation.
[in]	numPmeRanksPerSimulation	The number of PME ranks in each simulation.
[in]	gpusWereDetected	Whether compatible GPUs were detected on any node.

Returns: Whether the simulation will run nonbonded and PME tasks, respectively, on GPUs.

Exceptions

std::bad_alloc If out of memory InconsistentInputError If the user requirements are inconsistent.

bool gmx::decideWhetherToUseGpusForPmeWithThreadMpi	(	bool	useGpuForNonbonded,
		TaskTarget	pmeTarget,
		TaskTarget	pmeFftTarget,
		int	numDevicesToUse,
		const std::vector< int > &	userGpuTaskAssignment,
		const t_inputrec &	inputrec,
		int	numRanksPerSimulation,
		int	numPmeRanksPerSimulation
	)

Decide whether this thread-MPI simulation will run PME tasks on GPUs.

The number of GPU tasks and devices influences both the choice of the number of ranks, and checks upon any such choice made by the user. So we need to consider this before any automated choice of the number of thread-MPI ranks.

Parameters

[in]	useGpuForNonbonded	Whether GPUs will be used for nonbonded interactions.
[in]	pmeTarget	The user's choice for mdrun -pme for where to assign long-ranged PME nonbonded interaction tasks.
[in]	pmeFftTarget	The user's choice for mdrun -pmefft for where to run FFT.
[in]	numDevicesToUse	The number of compatible GPUs that the user permitted us to use.
[in]	userGpuTaskAssignment	The user-specified assignment of GPU tasks to device IDs.
[in]	inputrec	The user input
[in]	numRanksPerSimulation	The number of ranks in each simulation.
[in]	numPmeRanksPerSimulation	The number of PME ranks in each simulation.

Returns: Whether the simulation will run PME tasks on GPUs.

Exceptions

std::bad_alloc If out of memory InconsistentInputError If the user requirements are inconsistent.

static void gmx::deepCopy_t_trxframe	(	const t_trxframe &	input,
		t_trxframe *	copy,
		RVec *	xvec,
		RVec *	vvec,
		RVec *	fvec,
		int *	indexvec
	)

static

Create a deep copy of a t_trxframe input into copy.

When running the analysis tools and changing values with the outputadapters, a deep copy of the input coordinate frame has to be created first to ensure that the data is not changed if it is needed for other tools following with analysis later. Therefore, the data is passed to copy by performing a deep copy first.

The method allocates new storage for coordinates of the x, v, and f arrays in the new coordinate frame. This means that those arrays need to be free'd after the frame has been processed and been written to disk.

Parameters

[in]	input	Reference input coordinate frame.
[in,out]	copy	Pointer to new output frame that will receive the deep copy.
[in]	xvec	Pointer to local coordinate storage vector.
[in]	vvec	Pointer to local velocity storage vector.
[in]	fvec	Pointer to local force storage vector.
[in]	indexvec	Pointer to local index storage vector.

MrcDensityMapHeader gmx::deserializeMrcDensityMapHeader ( ISerializer * serializer )

Deserializes an MrcDensityMapHeader from a given serializer.

Parameters

[in] serializer the serializer

Returns: mrc density map header

static DeviceDetectionResult gmx::detectAllDeviceInformation ( const PhysicalNodeCommunicator & physicalNodeComm )

static

Detect GPUs when that makes sense to attempt.

Parameters

[in] physicalNodeComm The communicator across this physical node

Returns: The result of the detection, perhaps including diagnostic messages to issue later.

Todo:: Coordinating the efficient detection of devices across multiple ranks per node should be separated from the lower-level hardware detection. See https://gitlab.com/gromacs/gromacs/-/issues/3650.

PmeRunMode gmx::determinePmeRunMode	(	bool	useGpuForPme,
		const TaskTarget &	pmeFftTarget,
		const t_inputrec &	inputrec
	)

Determine PME run mode.

Given the PME task assignment in useGpuForPme and the user-provided FFT task target in pmeFftTarget, returns a PME run mode for the current run. It also checks the compatibility of the two.

Note: Aborts the run upon incompatible values of useGpuForPme and pmeFftTarget.

Parameters

[in]	useGpuForPme	PME task assignment, true if PME task is mapped to the GPU.
[in]	pmeFftTarget	The user's choice for -pmefft for where to assign the FFT work of the PME task.
[in]	inputrec	The user input record

template<typename ElementType , int N, int M = N>

MultiDimArray<std::array<ElementType, N * M>, extents<N, M> > gmx::diagonalMatrix ( const ElementType value )

Create a diagonal matrix of ElementType with N * M elements.

Template Parameters

ElementType	type of matrix elements
N	number of rows
M	number of columns, defaults to number of rows if not set

Parameters

value The value that fills the leading diagonal

Returns: a matrix with values value where row equals column index and null where row does not equal column index

void gmx::distributeTransformationPullCoordForce	(	pull_coord_work_t *	pcrd,
		gmx::ArrayRef< pull_coord_work_t >	variableCoords
	)

Distributes the force on a transformation pull coordinates to the involved coordinates of lower rank.

Note: There is no recursion applied here, which means that this function needs to be called in a reverse loop over the pull coordinates to ensure that forces on recursive transformation coordinates are distributed correctly.

Parameters

[in,out]	pcrd	The transformation pull coordinate to act on
[in,out]	variableCoords	List of variable coords up to the coord index of `pcrd`

void gmx::doDeviceTransfers	(	const DeviceContext &	deviceContext,
		const DeviceInformation &	deviceInfo,
		ArrayRef< const char >	input,
		ArrayRef< char >	output
	)

Helper function for GPU test code to be platform agnostic.

Transfers input to device 0, if present, and transfers it back into output. Both sizes must match. If no devices are present, do a simple host-side buffer copy instead.

Exceptions

InternalError Upon any GPU API error condition.

template<class BasicMdspan >

constexpr std::enable_if_t<BasicMdspan::is_always_contiguous(), typename BasicMdspan::pointer> gmx::end ( const BasicMdspan & basicMdspan )

Free end function addressing memory of a contiguously laid out basic_mdspan.

Note: Changing the elements that basic_mdspan views does not change the view itself, so a single end that takes a const view suffices.

static void gmx::ensureStateAndRunConsistency	(	const BiasParams &	params,
		const BiasState &	state
	)

static

Check if the state (loaded from checkpoint) and the run are consistent.

When the state and the run setup are inconsistent, an exception is thrown.

Parameters

[in]	params	The parameters of the bias.
[in]	state	The state of the bias.

static const char* gmx::enumValueToString ( AtomLocality enumValue )

static

Get the human-friendly name for atom localities.

Parameters

[in] enumValue The enum value to get the name for.

static const char* gmx::enumValueToString ( InteractionLocality enumValue )

static

Get the human-friendly name for interaction localities.

Parameters

[in] enumValue The enum value to get the name for.

static float gmx::erf ( float x )

inlinestatic

Float erf(x).

Parameters

x Argument.

Returns: erf(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::erf ( double x )

inlinestatic

Double erf(x).

Parameters

x Argument.

Returns: erf(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::erfc ( float x )

inlinestatic

Float erfc(x).

Parameters

x Argument.

Returns: erfc(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::erfc ( double x )

inlinestatic

Double erfc(x).

Parameters

x Argument.

Returns: erfc(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::erfcSingleAccuracy ( double x )

inlinestatic

Double erfc(x), but with single accuracy.

Parameters

x Argument.

Returns: erfc(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

double gmx::erfinv ( double x )

Inverse error function, double precision.

Parameters

x	Argument, should be in the range -1.0 < x < 1.0

Returns: The inverse of the error function if the argument is inside the range, +/- infinity if it is exactly 1.0 or -1.0, and NaN otherwise.

float gmx::erfinv ( float x )

Inverse error function, single precision.

Parameters

x	Argument, should be in the range -1.0 < x < 1.0

Returns: The inverse of the error function if the argument is inside the range, +/- infinity if it is exactly 1.0 or -1.0, and NaN otherwise.

static double gmx::erfSingleAccuracy ( double x )

inlinestatic

Double erf(x), but with single accuracy.

Parameters

x Argument.

Returns: erf(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

constexpr int32_t gmx::exactDiv	(	int32_t	a,
		int32_t	b
	)

Exact integer division, 32bit.

Parameters

a	dividend. Function asserts that it is a multiple of divisor
b	divisor

Returns: quotient of division

template<MathOptimization opt = MathOptimization::Safe>

static float gmx::exp ( float x )

inlinestatic

Float exp(x).

Parameters

x Argument.

Returns: exp(x). Undefined if input argument caused overflow.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<MathOptimization opt = MathOptimization::Safe>

static double gmx::exp ( double x )

inlinestatic

Double exp(x).

Parameters

x Argument.

Returns: exp(x). Undefined if input argument caused overflow.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<MathOptimization opt = MathOptimization::Safe>

static float gmx::exp2 ( float x )

inlinestatic

Float 2^x.

Parameters

x Argument.

Returns: 2^x. Undefined if input argument caused overflow.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<MathOptimization opt = MathOptimization::Safe>

static double gmx::exp2 ( double x )

inlinestatic

Double 2^x.

Parameters

x Argument.

Returns: 2^x. Undefined if input argument caused overflow.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::exp2SingleAccuracy ( double x )

inlinestatic

Double 2^x, but with single accuracy.

Parameters

x Argument.

Returns: 2^x. Undefined if input argument caused overflow.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::expandScalarsToTriplets	(	float	scalar,
		float *	triplets0,
		float *	triplets1,
		float *	triplets2
	)

inlinestatic

Copy single float to three variables.

Parameters

	scalar	Floating-point input.
[out]	triplets0	Copy 1.
[out]	triplets1	Copy 2.
[out]	triplets2	Copy 3.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::expandScalarsToTriplets	(	double	scalar,
		double *	triplets0,
		double *	triplets1,
		double *	triplets2
	)

inlinestatic

Copy single double to three variables.

Parameters

	scalar	Floating-point input.
[out]	triplets0	Copy 1.
[out]	triplets1	Copy 2.
[out]	triplets2	Copy 3.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

ExponentialMovingAverageState gmx::exponentialMovingAverageStateFromKeyValueTree ( const KeyValueTreeObject & object )

Sets the exponential moving average state from a key-value-tree object.

Sets the expoential moving average state from a key-value-tree object.

static double gmx::expSingleAccuracy ( double x )

inlinestatic

Double exp(x), but with single accuracy.

Parameters

x Argument.

Returns: exp(x). Undefined if input argument caused overflow.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static int gmx::fillSupportedSubGroupSizes	(	const cl_device_id	devId,
		const DeviceVendor	deviceVendor,
		int	resultCapacity,
		int *	result
	)

static

Return the list of sub-group sizes supported by the device.

Parameters

devId	OpenCL device ID.
deviceVendor	Device vendor.
resultCapacity	The capacity of `result`. Program is aborted if device returns more.
result	Pointer to pre-allocated result array, capable of holding at least `resultCapacity` elements.

Returns: Number of elements written to results, that is, the number of sub-group sizes supported.

GpuTasksOnRanks gmx::findAllGpuTasksOnThisNode	(	ArrayRef< const GpuTask >	gpuTasksOnThisRank,
		const PhysicalNodeCommunicator &	physicalNodeComm
	)

Returns container of all tasks on all ranks of this node that are eligible for GPU execution.

Perform all necessary communication for preparing for task assignment. Separating this aspect makes it possible to unit test the logic of task assignment.

std::vector< GpuTask > gmx::findGpuTasksOnThisRank	(	bool	haveGpusOnThisPhysicalNode,
		TaskTarget	nonbondedTarget,
		TaskTarget	pmeTarget,
		TaskTarget	bondedTarget,
		TaskTarget	updateTarget,
		bool	useGpuForNonbonded,
		bool	useGpuForPme,
		bool	rankHasPpTask,
		bool	rankHasPmeTask
	)

Returns container of all tasks on this rank that are eligible for GPU execution.

Parameters

[in]	haveGpusOnThisPhysicalNode	Whether there are any GPUs on this physical node.
[in]	nonbondedTarget	The user's choice for mdrun -nb for where to assign short-ranged nonbonded interaction tasks.
[in]	pmeTarget	The user's choice for mdrun -pme for where to assign long-ranged PME nonbonded interaction tasks.
[in]	bondedTarget	The user's choice for mdrun -bonded for where to assign tasks.
[in]	updateTarget	The user's choice for mdrun -update for where to assign tasks.
[in]	useGpuForNonbonded	Whether GPUs will be used for nonbonded interactions.
[in]	useGpuForPme	Whether GPUs will be used for PME interactions.
[in]	rankHasPpTask	Whether this rank has a PP task
[in]	rankHasPmeTask	Whether this rank has a PME task

std::filesystem::path gmx::findLibraryFile	(	const std::filesystem::path &	filename,
		bool	bAddCWD = `true`,
		bool	bFatal = `true`
	)

Finds full path for a library file.

Searches in the configured library directories for filename. If bAddCWD is true, searches first in the current directory. Fatal error results if the file is not found in any location and bFatal is true.

static void gmx::flagInteractionsForType	(	const int	ftype,
		const InteractionList &	il,
		const reverse_ilist_t &	ril,
		const Range< int > &	atomRange,
		const int	numAtomsPerMolecule,
		ArrayRef< const int >	globalAtomIndices,
		ArrayRef< int >	isAssigned
	)

static

Checks whether interactions have been assigned for one function type.

Loops over a list of interactions in the local topology of one function type and flags each of the interactions as assigned in the global isAssigned list. Exits with an inconsistency error when an interaction is assigned more than once.

static float gmx::fma	(	float	a,
		float	b,
		float	c
	)

inlinestatic

Float Fused-multiply-add. Result is a*b + c.

Parameters

a	factor1
b	factor2
c	term

Returns: a*b + c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::fma	(	double	a,
		double	b,
		double	c
	)

inlinestatic

double Fused-multiply-add. Result is a*b + c.

Parameters

a	factor1
b	factor2
c	term

Returns: a*b + c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::fms	(	float	a,
		float	b,
		float	c
	)

inlinestatic

Float Fused-multiply-subtract. Result is a*b - c.

Parameters

a	factor1
b	factor2
c	term

Returns: a*b - c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::fms	(	double	a,
		double	b,
		double	c
	)

inlinestatic

double Fused-multiply-subtract. Result is a*b - c.

Parameters

a	factor1
b	factor2
c	term

Returns: a*b - c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::fnma	(	float	a,
		float	b,
		float	c
	)

inlinestatic

Float Fused-negated-multiply-add. Result is -a*b + c.

Parameters

a	factor1
b	factor2
c	term

Returns: -a*b + c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::fnma	(	double	a,
		double	b,
		double	c
	)

inlinestatic

double Fused-negated-multiply-add. Result is - a*b + c.

Parameters

a	factor1
b	factor2
c	term

Returns: -a*b + c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::fnms	(	float	a,
		float	b,
		float	c
	)

inlinestatic

Float Fused-negated-multiply-subtract. Result is -a*b - c.

Parameters

a	factor1
b	factor2
c	term

Returns: -a*b - c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::fnms	(	double	a,
		double	b,
		double	c
	)

inlinestatic

double Fused-negated-multiply-subtract. Result is -a*b - c.

Parameters

a	factor1
b	factor2
c	term

Returns: -a*b - c

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static int gmx::forceGroupMtsLevel	(	ArrayRef< const MtsLevel >	mtsLevels,
		const MtsForceGroups	mtsForceGroup
	)

inlinestatic

Returns the MTS level at which a force group is to be computed.

Parameters

[in]	mtsLevels	List of force groups for each MTS level, can be empty without MTS
[in]	mtsForceGroup	The force group to query the MTS level for

template<int align>

static void gmx::gatherLoadBySimdIntTranspose	(	const float *	base,
		std::int32_t	offset,
		float *	v0,
		float *	v1,
		float *	v2,
		float *	v3
	)

inlinestatic

Load 4 floats from base/offsets and store into variables.

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Aligned pointer to the start of the memory.
	offset	Integer type with offset to the start of each triplet.
[out]	v0	First float, base[align*offset[0]].
[out]	v1	Second float, base[align*offset[0] + 1].
[out]	v2	Third float, base[align*offset[0] + 2].
[out]	v3	Fourth float, base[align*offset[0] + 3].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadBySimdIntTranspose	(	const float *	base,
		std::int32_t	offset,
		float *	v0,
		float *	v1
	)

inlinestatic

Load 2 floats from base/offsets and store into variables (aligned).

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Aligned pointer to the start of the memory.
	offset	Integer type with offset to the start of each triplet.
[out]	v0	First float, base[align*offset[0]].
[out]	v1	Second float, base[align*offset[0] + 1].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadBySimdIntTranspose	(	const double *	base,
		std::int32_t	offset,
		double *	v0,
		double *	v1,
		double *	v2,
		double *	v3
	)

inlinestatic

Load 4 doubles from base/offsets and store into variables.

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Aligned pointer to the start of the memory.
	offset	Integer type with offset to the start of each triplet.
[out]	v0	First double, base[align*offset[0]].
[out]	v1	Second double, base[align*offset[0] + 1].
[out]	v2	Third double, base[align*offset[0] + 2].
[out]	v3	Fourth double, base[align*offset[0] + 3].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadBySimdIntTranspose	(	const double *	base,
		std::int32_t	offset,
		double *	v0,
		double *	v1
	)

inlinestatic

Load 2 doubles from base/offsets and store into variables (aligned).

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Aligned pointer to the start of the memory.
	offset	Integer type with offset to the start of each triplet.
[out]	v0	First double, base[align*offset[0]].
[out]	v1	Second double, base[align*offset[0] + 1].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadTranspose	(	const float *	base,
		const std::int32_t	offset[],
		float *	v0,
		float *	v1,
		float *	v2,
		float *	v3
	)

inlinestatic

Load 4 consecutive floats from base/offset into four variables.

Template Parameters

align Alignment of the memory from which we read.

Parameters

	base	Pointer to the start of the memory area
	offset	Index to data.
[out]	v0	1st float, base[align*offset[0]].
[out]	v1	2nd float, base[align*offset[0] + 1].
[out]	v2	3rd float, base[align*offset[0] + 2].
[out]	v3	4th float, base[align*offset[0] + 3].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadTranspose	(	const float *	base,
		const std::int32_t	offset[],
		float *	v0,
		float *	v1
	)

inlinestatic

Load 2 consecutive floats from base/offset into four variables.

Template Parameters

align Alignment of the memory from which we read.

Parameters

	base	Pointer to the start of the memory area
	offset	Index to data.
[out]	v0	1st float, base[align*offset[0]].
[out]	v1	2nd float, base[align*offset[0] + 1].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadTranspose	(	const double *	base,
		const std::int32_t	offset[],
		double *	v0,
		double *	v1,
		double *	v2,
		double *	v3
	)

inlinestatic

Load 4 consecutive doubles from base/offset into four variables.

Template Parameters

align Alignment of the memory from which we read.

Parameters

	base	Pointer to the start of the memory area
	offset	Index to data.
[out]	v0	1st double, base[align*offset[0]].
[out]	v1	2nd double, base[align*offset[0] + 1].
[out]	v2	3rd double, base[align*offset[0] + 2].
[out]	v3	4th double, base[align*offset[0] + 3].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadTranspose	(	const double *	base,
		const std::int32_t	offset[],
		double *	v0,
		double *	v1
	)

inlinestatic

Load 2 consecutive doubles from base/offset into four variables.

Template Parameters

align Alignment of the memory from which we read.

Parameters

	base	Pointer to the start of the memory area
	offset	Index to data.
[out]	v0	1st double, base[align*offset[0]].
[out]	v1	2nd double, base[align*offset[0] + 1].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadUBySimdIntTranspose	(	const float *	base,
		std::int32_t	offset,
		float *	v0,
		float *	v1
	)

inlinestatic

Load 2 floats from base/offsets and store into variables (unaligned).

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Aligned pointer to the start of the memory.
	offset	Integer type with offset to the start of each triplet.
[out]	v0	First float, base[align*offset[0]].
[out]	v1	Second float, base[align*offset[0] + 1].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadUBySimdIntTranspose	(	const double *	base,
		std::int32_t	offset,
		double *	v0,
		double *	v1
	)

inlinestatic

Load 2 doubles from base/offsets and store into variables (unaligned).

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Aligned pointer to the start of the memory.
	offset	Integer type with offset to the start of each triplet.
[out]	v0	First double, base[align*offset[0]].
[out]	v1	Second double, base[align*offset[0] + 1].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadUTranspose	(	const float *	base,
		const std::int32_t	offset[],
		float *	v0,
		float *	v1,
		float *	v2
	)

inlinestatic

Load 3 consecutive floats from base/offsets, store into three vars.

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Pointer to the start of the memory area
	offset	Offset to the start of data.
[out]	v0	1st value, base[align*offset[0]].
[out]	v1	2nd value, base[align*offset[0] + 1].
[out]	v2	3rd value, base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::gatherLoadUTranspose	(	const double *	base,
		const std::int32_t	offset[],
		double *	v0,
		double *	v1,
		double *	v2
	)

inlinestatic

Load 3 consecutive doubles from base/offsets, store into three vars.

Template Parameters

align Alignment of the memory from which we read, i.e. distance (measured in elements, not bytes) between index points.

Parameters

	base	Pointer to the start of the memory area
	offset	Offset to the start of data.
[out]	v0	1st double, base[align*offset[0]].
[out]	v1	2nd double, base[align*offset[0] + 1].
[out]	v2	3rd double, base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<class RealType = real, unsigned int Bits, class Rng >

RealType gmx::generateCanonical ( Rng & g )

Generate a floating-point value with specified number of random bits.

Template Parameters

RealType	Floating-point type to generate
Bits	Number of random bits to generate
Rng	Random number generator class

Parameters

g	Random number generator to use

This implementation avoids the bug in libc++ and stdlibc++ (which is due to the C++ standard being unclear) where 1.0 can be returned occasionally.

static double gmx::get_pull_coord_period	(	const t_pull_coord &	pullCoordParams,
		const t_pbc &	pbc,
		const real	intervalLength
	)

static

Gets the period of a pull coordinate.

Parameters

[in]	pullCoordParams	The parameters for the pull coordinate.
[in]	pbc	The PBC setup
[in]	intervalLength	The length of the AWH interval for this pull coordinate

Returns: the period (or 0 if not periodic).

TranslateAndScale gmx::getCoordinateTransformationToLattice ( const MrcDensityMapHeader & header )

Extract the transformation into lattice coordinates.

Note: Transformation into lattice coordinates is not treated uniformly in different implementations for the mrc format,e.g., vmd, pymol and chimera have different conventions. Following the vmd implementation here.

In determining the density origin coordinates, explicit ORIGIN records (also called origin2k) in the user defined floats 13 - 15, corresponding to words 50,51 and 52 in the mrc header, precedence over ColumnRowSectionStart. Only if above values are zero, using the column, row and section start to determine the translation vector.

Parameters

[in] header from which the coordinate transformation is to be extracted

Returns: a functor that transforms real space coordinates into the lattice

double gmx::getDeviationFromPointAlongGridAxis	(	const BiasGrid &	grid,
		int	dimIndex,
		int	pointIndex,
		double	value
	)

Get the deviation along one dimension from the given value to a point in the grid.

Parameters

[in]	grid	The grid.
[in]	dimIndex	Dimensional index in [0, ndim -1].
[in]	pointIndex	BiasGrid point index.
[in]	value	Value along the given dimension.

Returns: the deviation of the given value to the given point.

double gmx::getDeviationFromPointAlongGridAxis	(	const BiasGrid &	grid,
		int	dimIndex,
		int	pointIndex1,
		int	pointIndex2
	)

Get the deviation from one point to another along one dimension in the grid.

Parameters

[in]	grid	The grid.
[in]	dimIndex	Dimensional index in [0, ndim -1].
[in]	pointIndex1	Grid point index of the first point.
[in]	pointIndex2	Grid point index of the second point.

Returns: the deviation of the two points along the given axis.

dynamicExtents3D gmx::getDynamicExtents3D ( const MrcDensityMapHeader & header )

Extract the extents of the density data.

Parameters

[in] header from which the extents are to be extracted

Returns: density data extents in three dimensions.

static int gmx::getFileType ( const std::string & filename )

static

Get the internal file type from the filename.

Parameters

[in] filename Filename of output file.

Exceptions

InvalidInputError When unable to work on an emoty file name.

Returns: integer value of file type.

static int gmx::getNearestIndexInGrid	(	const awh_dvec	value,
		ArrayRef< const GridAxis >	axis
	)

static

Map a value to the nearest point in the grid.

Parameters

[in]	value	Value.
[in]	axis	The grid axes.

Returns: the point index nearest to the value.

static std::size_t gmx::getPageSize ( )

static

Return a page size, from a sysconf/WinAPI query if available, or a default guess (4096 bytes).

Todo:: Move this function into sysinfo.cpp where other OS-specific code/includes live

static PbcMode gmx::getPbcMode ( const t_pbc * pbcPtr )

static

Returns the PBC mode based on the system PBC and vsite properties.

Parameters

[in] pbcPtr A pointer to a PBC struct or nullptr when no PBC treatment is required

double gmx::getSqrtDeterminant ( gmx::ArrayRef< const double > correlationIntegral )

Returns the volume element of the correlation metric.

The matrix of the metric equals the time-integrated correlation matrix. The volume element of the metric therefore equals the square-root of the absolute value of its determinant according to the standard formula for a volume element in a metric space.

The order of the tensor elements is: 1-dimensional tensor: [0] 2-dimensional tensor: [0 1; 1 2] 3-dimensional tensor: [0 1 3; 1 2 4; 3 4 5]

Parameters

[in] correlationIntegral A pre-filled vector of time integral elements. The correlation index lists the elements of the upper-triangular correlation matrix row-wise, so e.g. in 3D: 0 (0,0), 1 (1,0), 2 (1,1), 3 (2,0), 4 (2,1), 5 (2,2).

Returns: the volume element.

static unsigned long gmx::getSupportedOutputAdapters ( int filetype )

static

Get the flag representing the requirements for a given file output.

Also checks if the supplied topology is sufficient through the pointer to mtop.

Parameters

[in] filetype Internal file type used to check requirements.

Exceptions

InvalidInputError When encountering an invalid file type.

Returns: Requirements represent by the bitmask in the return type.

double gmx::getTransformationPullCoordinateValue	(	pull_coord_work_t *	coord,
		ArrayRef< const pull_coord_work_t >	variableCoords,
		double	t
	)

Calculates pull->coord[coord_ind].spatialData.value for a transformation pull coordinate.

This requires the values of the pull coordinates of lower indices to be set

Parameters

[in]	coord	The (transformation) coordinate to compute the value for
[in]	variableCoords	Pull coordinates used as variables, entries 0 to coord->coordIndex will be used
[in]	t	The time

Returns: Transformation value for pull coordinate.

Exceptions

InconsistentInputError when the expression uses coordinates with index equal to or larger than the index of coord.

std::unique_ptr< gmx_hw_info_t > gmx::gmx_detect_hardware	(	const PhysicalNodeCommunicator &	physicalNodeComm,
		MPI_Comm	libraryCommWorld
	)

Run detection and make correct and consistent hardware information available on all ranks.

May do communication on libraryCommWorld when compiled with real MPI.

This routine is designed to be called once on each process. In a thread-MPI configuration, it may only be called before the threads are spawned. With real MPI, communication is needed to coordinate the results. In all cases, any thread within a process may use the returned handle.

int gmx::gmx_mdrun	(	int	argc,
		char *	argv[]
	)

Implements C-style main function for mdrun.

This implementation detects hardware itself, as suits the gmx wrapper binary.

Parameters

[in]	argc	Number of C-style command-line arguments
[in]	argv	C-style command-line argument strings

int gmx::gmx_mdrun	(	MPI_Comm	communicator,
		const gmx_hw_info_t &	hwinfo,
		int	argc,
		char *	argv[]
	)

Implements C-style main function for mdrun.

This implementation facilitates reuse of infrastructure. This includes the information about the hardware detected across the given communicator. That suits e.g. efficient implementation of test fixtures.

Parameters

[in]	communicator	The communicator to use for the simulation
[in]	hwinfo	Describes the hardware detected on the physical nodes of the communicator
[in]	argc	Number of C-style command-line arguments
[in]	argv	C-style command-line argument strings

Todo:: Progress on https://gitlab.com/gromacs/gromacs/-/issues/3774 will remove the need of test binaries to call gmx_mdrun in a way that is different from the command-line and gmxapi.

static bool gmx::gpuAccelerationOfNonbondedIsUseful	(	const MDLogger &	mdlog,
		const t_inputrec &	ir,
		const bool	issueWarning,
		const bool	doRerun
	)

static

Return whether GPU acceleration of nonbondeds is supported with the given settings.

If not, and if a warning may be issued, logs a warning about falling back to CPU code. With thread-MPI, only the first call to this function should have issueWarning true.

std::int64_t gmx::greatestCommonDivisor	(	std::int64_t	p,
		std::int64_t	q
	)

Find greatest common divisor of two numbers.

Parameters

p	First number, positive
q	Second number, positive

Returns: Greatest common divisor of p and q

std::tuple< StartingBehavior, LogFilePtr > gmx::handleRestart	(	bool	isSimulationMain,
		MPI_Comm	communicator,
		const gmx_multisim_t *	ms,
		AppendingBehavior	appendingBehavior,
		int	nfile,
		t_filenm	fnm[]
	)

Handle startup of mdrun, particularly regarding -cpi and -append.

If there is a checkpoint file, then prepare to start from that state. If possible/required, do so with appending. If some files are not found when appending should be done, we will instead issue a fatal error to avoid unintentional problems.

If there is no checkpoint file, we return a value to indicate a new simulation is starting.

On return, fnm is updated with suffix strings for part numbers if we are doing a restart from checkpoint and are not appending.

The routine also does communication to coordinate behaviour between all simulations, including for error conditions.

Exceptions

FileIOError	When the filesystem behavior prevents the user's choices being implemented.
InconsistentInputError	When the users's choices cannot be implemented.
GromacsException	On ranks upon which the error condition was not detected.

Parameters

[in]	isSimulationMain	Whether this rank is the main rank of a simulation
[in]	communicator	MPI communicator
[in]	ms	Handles multi-simulations.
[in]	appendingBehavior	User choice for appending
[in]	nfile	Size of fnm struct
[in,out]	fnm	Filename parameters to mdrun

Returns: Description of how mdrun is starting

static bool gmx::hasIncompatibleVsites	(	const gmx_moltype_t &	moltype,
		gmx::ArrayRef< const t_iparams >	iparams
	)

static

Returns whether moltype has incompatible vsites.

For simplicity the only compatible vsites are linear 2 or 3 atom sites that are constructed in between the 2 or 3 contructing atoms,

static bool gmx::hasPmeOrNonbondedTask ( const GpuTaskMapping & mapping )

static

Function for whether the mapping has the GPU PME or Nonbonded task.

Parameters

[in] mapping Current GPU task mapping.

Returns: If PME on Nonbonded GPU task was assigned to this mapping.

template<GpuTask TaskType>

static bool gmx::hasTaskType ( const GpuTaskMapping & mapping )

static

Function for whether the task of mapping has value TaskType.

Parameters

[in] mapping Current GPU task mapping.

Returns: If TaskType task was assigned to the mapping.

bool gmx::haveBiasSharingWithinSimulation ( const AwhParams & awhParams )

Returns if any bias is sharing within a simulation.

Parameters

[in] awhParams The AWH parameters.

static bool gmx::haveSpecialForces	(	const t_inputrec &	inputrec,
		const gmx::ForceProviders &	forceProviders,
		const pull_t *	pull_work,
		const gmx_edsam *	ed
	)

static

Return true if there are special forces computed.

The conditionals exactly correspond to those in sim_util.cpp:computeSpecialForces().

bool gmx::haveValidMtsSetup ( const t_inputrec & ir )

Returns whether we use MTS and the MTS setup is internally valid.

Note that setupMtsLevels would have returned at least one error message when this function returns false

int gmx::identifyAvx512FmaUnits ( )

Test whether machine has dual AVX512 FMA units.

Returns: 1 or 2 for the number of AVX512 FMA units if AVX512 support is present, 0 if we know the hardware does not have AVX512 support, or -1 if the test cannot run because the compiler lacked AVX512 support.

template<typename ElementType , int N, int M = N>

MultiDimArray<std::array<ElementType, N * M>, extents<N, M> > gmx::identityMatrix ( )

Create an identity matrix of ElementType with N * M elements.

Template Parameters

ElementType	type of matrix elements
N	number of rows
M	number of columns, defaults to number of rows if not set

Returns: a matrix with values one where row equals column index and null where row does not equal column index

static bool gmx::imd_recv_mdcomm	(	IMDSocket *	socket,
		int32_t	nforces,
		int32_t *	forcendx,
		float *	forces
	)

static

Receive force indices and forces.

The number of forces was previously communicated via the header.

static int gmx::imd_send_rvecs	(	IMDSocket *	socket,
		int	nat,
		rvec *	x,
		char *	buffer
	)

static

Send positions from rvec.

We need a separate send buffer and conversion to Angstrom.

int gmx::imd_sock_listen ( IMDSocket * sock )

Set socket to listening state.

Prints out an error message if unsuccessful.

Parameters

sock	The IMD socket.

Returns: 0 if successful.

IMDSocket * gmx::imdsock_accept ( IMDSocket * sock )

Accept incoming connection and redirect to client socket.

Prints out an error message if unsuccessful.

Parameters

sock	The IMD socket.

Returns: IMD socket if successful, NULL otherwise.

int gmx::imdsock_bind	(	IMDSocket *	sock,
		int	port
	)

Bind the IMD socket to address and port.

Prints out an error message if unsuccessful. If port == 0, bind() assigns a free port automatically.

Parameters

sock	The IMD socket.
port	The port to bind to.

Returns: 0 if successful.

IMDSocket * gmx::imdsock_create ( )

Create an IMD main socket.

Returns: The IMD socket if successful. Otherwise prints an error message and returns NULL.

int gmx::imdsock_destroy ( IMDSocket * sock )

Close the socket and free the sock struct memory.

Writes an error message if unsuccessful.

Parameters

sock	The IMD socket.

Returns: 1 on success, or 0 if unsuccessful.

int gmx::imdsock_getport	(	IMDSocket *	sock,
		int *	port
	)

Get the port number used for IMD connection.

Prints out an error message if unsuccessful.

Parameters

sock	The IMD socket.
port	The assigned port number.

Returns: 0 if successful, an error code otherwise.

int gmx::imdsock_read	(	IMDSocket *	sock,
		char *	buffer,
		int	length
	)

Read from socket.

Parameters

sock	The IMD socket.
buffer	Buffer to put the read data.
length	Number of bytes to read.

Returns: The number of bytes read, or -1 for errors.

void gmx::imdsock_shutdown ( IMDSocket * sock )

Shutdown the socket.

Parameters

sock	The IMD socket.

int gmx::imdsock_tryread	(	IMDSocket *	sock,
		int	timeoutsec,
		int	timeoutusec
	)

Try to read from the socket.

Time out after waiting the interval specified. Print an error message if unsuccessful.

Parameters

sock	The IMD socket.
timeoutsec	Time out seconds
timeoutusec	Time out microseconds

int gmx::imdsock_write	(	IMDSocket *	sock,
		const char *	buffer,
		int	length
	)

Write to socket.

Parameters

sock	The IMD socket.
buffer	The data to write.
length	Number of bytes to write.

Returns: The number of bytes written, or -1.

void gmx::initCorrelationGridHistory	(	CorrelationGridHistory *	correlationGridHistory,
		int	numCorrelationTensors,
		int	tensorSize,
		int	blockDataListSize
	)

Initialize correlation grid history, sets all sizes.

Parameters

[in,out]	correlationGridHistory	Correlation grid history for main rank.
[in]	numCorrelationTensors	Number of correlation tensors in the grid.
[in]	tensorSize	Number of correlation elements in each tensor.
[in]	blockDataListSize	The number of blocks in the list of each tensor element.

CorrelationGridHistory gmx::initCorrelationGridHistoryFromState ( const CorrelationGrid & corrGrid )

Allocate a correlation grid history with the same structure as the given correlation grid.

This function would be called at the start of a new simulation. Note that only sizes and memory are initialized here. History data is set by updateCorrelationGridHistory.

Parameters

[in,out] corrGrid Correlation grid state to initialize with.

Returns: the correlation grid history struct.

static void gmx::initializeProjectionMatrix	(	const real	invmO,
		const real	invmH,
		const real	dOH,
		const real	dHH,
		matrix	inverseCouplingMatrix
	)

static

Initializes a projection matrix.

Parameters

[in]	invmO	Reciprocal oxygen mass
[in]	invmH	Reciprocal hydrogen mass
[in]	dOH	Target O-H bond length
[in]	dHH	Target H-H bond length
[out]	inverseCouplingMatrix	Inverse bond coupling matrix for the projection version of SETTLE

bool gmx::inputSupportsListedForcesGpu	(	const t_inputrec &	ir,
		const gmx_mtop_t &	mtop,
		std::string *	error
	)

Checks whether the input system allows to compute bonded interactions on a GPU.

Parameters

[in]	ir	Input system.
[in]	mtop	Complete system topology to search for supported interactions.
[out]	error	If non-null, the error message if the input is not supported on GPU.

Returns: true if PME can run on GPU with this input, false otherwise.

static bool gmx::intervalIsInPeriodicInterval	(	double	origin,
		double	end,
		double	period
	)

static

Checks if the given interval is defined in the correct periodic interval.

Parameters

[in]	origin	Start value of interval.
[in]	end	End value of interval.
[in]	period	Period (or 0 if not periodic).

Returns: true if the end point values are in the correct periodic interval.

static float gmx::inv ( float x )

inlinestatic

Calculate 1/x for float.

Parameters

x	Argument that must be nonzero. This routine does not check arguments.

Returns: 1/x. Result is undefined if your argument was invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::inv ( double x )

inlinestatic

Calculate 1/x for double.

Parameters

x	Argument that must be nonzero. This routine does not check arguments.

Returns: 1/x. Result is undefined if your argument was invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::invcbrt ( float x )

inlinestatic

Calculate inverse cube root of x in single precision.

Parameters

x Argument

Returns: x^(-1/3)

This routine is typically faster than using std::pow().

static double gmx::invcbrt ( double x )

inlinestatic

Calculate inverse sixth root of x in double precision.

Parameters

x Argument

Returns: x^(-1/3)

This routine is typically faster than using std::pow().

static double gmx::invcbrt ( int x )

inlinestatic

Calculate inverse sixth root of integer x in double precision.

Parameters

x Argument

Returns: x^(-1/3)

This routine is typically faster than using std::pow().

static Matrix3x3 gmx::invertBoxMatrix ( const Matrix3x3 & src )

inlinestatic

Invert a simulation-box matrix.

This routine assumes that src is a simulation-box matrix, i.e. has zeroes in the upper-right triangle.

Exceptions

RangeError if the product of the leading diagonal is too small.

static void gmx::invertBoxMatrix	(	const matrix	src,
		matrix	dest
	)

inlinestatic

Invert a simulation-box matrix in src, return in dest.

This routine assumes that src is a simulation-box matrix, i.e. has zeroes in the upper-right triangle. A fatal error occurs if the product of the leading diagonal is too small. The inversion can be done "in place", i.e src and dest can be the same matrix.

void gmx::invertMatrix	(	const matrix	src,
		matrix	dest
	)

Invert a general 3x3 matrix in src, return in dest.

A fatal error occurs if the determinant is too small. src and dest cannot be the same matrix.

static double gmx::invSingleAccuracy ( double x )

inlinestatic

Calculate 1/x for double, but with single accuracy.

Parameters

x	Argument that must be nonzero. This routine does not check arguments.

Returns: 1/x. Result is undefined if your argument was invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::invsixthroot ( float x )

inlinestatic

Calculate inverse sixth root of x in single precision.

Parameters

x	Argument, must be greater than zero.

Returns: x^(-1/6)

This routine is typically faster than using std::pow().

static double gmx::invsixthroot ( double x )

inlinestatic

Calculate inverse sixth root of x in double precision.

Parameters

x	Argument, must be greater than zero.

Returns: x^(-1/6)

This routine is typically faster than using std::pow().

static double gmx::invsixthroot ( int x )

inlinestatic

Calculate inverse sixth root of integer x in double precision.

Parameters

x	Argument, must be greater than zero.

Returns: x^(-1/6)

This routine is typically faster than using std::pow().

static float gmx::invsqrt ( float x )

inlinestatic

Calculate 1.0/sqrt(x) in single precision.

Parameters

x	Positive value to calculate inverse square root for

For now this is implemented with std::sqrt(x) since gcc seems to do a decent job optimizing it. However, we might decide to use instrinsics or compiler-specific functions in the future.

Returns: 1.0/sqrt(x)

static double gmx::invsqrt ( double x )

inlinestatic

Calculate 1.0/sqrt(x) in double precision, but single range.

Parameters

x	Positive value to calculate inverse square root for, must be in the input domain valid for single precision.

For now this is implemented with std::sqrt(x). However, we might decide to use instrinsics or compiler-specific functions in the future, and then we want to have the freedom to do the first step in single precision.

Returns: 1.0/sqrt(x)

static double gmx::invsqrt ( int x )

inlinestatic

Calculate 1.0/sqrt(x) for integer x in double precision.

Parameters

x	Positive value to calculate inverse square root for.

Returns: 1.0/sqrt(x)

static void gmx::invsqrtPair	(	float	x0,
		float	x1,
		float *	out0,
		float *	out1
	)

inlinestatic

Calculate 1/sqrt(x) for two floats.

Parameters

	x0	First argument, x0 must be positive - no argument checking.
	x1	Second argument, x1 must be positive - no argument checking.
[out]	out0	Result 1/sqrt(x0)
[out]	out1	Result 1/sqrt(x1)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::invsqrtPair	(	double	x0,
		double	x1,
		double *	out0,
		double *	out1
	)

inlinestatic

Calculate 1/sqrt(x) for two doubles.

Parameters

	x0	First argument, x0 must be positive - no argument checking.
	x1	Second argument, x1 must be positive - no argument checking.
[out]	out0	Result 1/sqrt(x0)
[out]	out1	Result 1/sqrt(x1)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::invsqrtPairSingleAccuracy	(	double	x0,
		double	x1,
		double *	out0,
		double *	out1
	)

inlinestatic

Calculate 1/sqrt(x) for two doubles, but with single accuracy.

Parameters

	x0	First argument, x0 must be positive - no argument checking.
	x1	Second argument, x1 must be positive - no argument checking.
[out]	out0	Result 1/sqrt(x0)
[out]	out1	Result 1/sqrt(x1)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::invsqrtSingleAccuracy ( double x )

inlinestatic

Calculate 1/sqrt(x) for double, but with single accuracy.

Parameters

x	Argument that must be >0. This routine does not check arguments.

Returns: 1/sqrt(x). Result is undefined if your argument was invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static DeviceStatus gmx::isDeviceFunctional ( const DeviceInformation & deviceInfo )

static

Checks that device deviceInfo is compatible with GROMACS.

Vendor and OpenCL version support checks are executed an the result of these returned.

Parameters

[in] deviceInfo The device info pointer.

Returns: The status enumeration value for the checked device:

static bool gmx::isDeviceFunctional	(	const DeviceInformation &	deviceInfo,
		std::string *	errorMessage
	)

static

Checks that device deviceInfo is sane (ie can run a kernel).

Compiles and runs a dummy kernel to determine whether the given OpenCL device functions properly.

Parameters

[in]	deviceInfo	The device info pointer.
[out]	errorMessage	An error message related to a failing OpenCL API call.

Exceptions

std::bad_alloc When out of memory.

Returns: Whether the device passed sanity checks

template<typename EnumerationArrayType >

EnumerationArrayType::EnumerationWrapperType gmx::keysOf ( const EnumerationArrayType & )

Returns an object that provides iterators over the keys associated with EnumerationArrayType.

This helper function is useful in contexts where there is an object of an EnumerationArray, and we want to use a range-based for loop over the keys associated with it, and it would be inconvenient to use the very word EnumerationArray<...> type, nor introduce a using statement for this purpose. It is legal in C++ to call a static member function (such as keys()) via an object rather than the type, but clang-tidy warns about that. So instead we make available a free function that calls that static method.

void gmx::launchForceReductionKernel	(	int	numAtoms,
		int	atomStart,
		bool	addRvecForce,
		bool	accumulate,
		const DeviceBuffer< Float3 >	d_nbnxmForceToAdd,
		const DeviceBuffer< Float3 >	d_rvecForceToAdd,
		DeviceBuffer< Float3 >	d_baseForce,
		DeviceBuffer< int >	d_cell,
		const DeviceStream &	deviceStream,
		DeviceBuffer< uint64_t >	d_forcesReadyNvshmemFlags,
		const uint64_t	forcesReadyNvshmemFlagsCounter
	)

Backend-specific function to launch GPU Force Reduction kernel.

Select templated Force reduction kernel and launch it.

In pseudocode:

* for (int i = 0; i < numAtoms; i++) {
*     totalForce = d_nbnxmForceToAdd[d_cell[i]]
*     if (accumulate)
*         totalForce += d_baseForce[atomStart + i]
*     if (addRvecForce)
*         totalForce += d_rvecForceToAdd[atomStart + i]
*     d_baseForce[atomStart + i] = totalForce[i]
* }
* 

Parameters

numAtoms	Number of atoms subject to reduction.
atomStart	First atom index (for `d_rvecForceToAdd` and `d_baseForce`).
addRvecForce	When `false`, `d_rvecForceToAdd` is ignored.
accumulate	When `false`, the previous values of `d_baseForce` are discarded.
d_nbnxmForceToAdd	Buffer containing Nbnxm forces in Nbnxm layout.
d_rvecForceToAdd	Optional buffer containing arbitrary forces in linear layout.
d_baseForce	Destination buffer for forces in linear layout.
d_cell	Atom index to Nbnxm cell index.
deviceStream	Device stream for kernel submission.
d_forcesReadyNvshmemFlags	NVSHMEM signals from PME to PP force transfer.
forcesReadyNvshmemFlagsCounter	Tracks NVSHMEM signal from PME to PP force transfer.

void gmx::launchLeapFrogKernel	(	int	numAtoms,
		DeviceBuffer< Float3 >	d_x,
		DeviceBuffer< Float3 >	d_xp,
		DeviceBuffer< Float3 >	d_v,
		DeviceBuffer< Float3 >	d_f,
		DeviceBuffer< float >	d_inverseMasses,
		float	dt,
		bool	doTemperatureScaling,
		int	numTempScaleValues,
		DeviceBuffer< unsigned short >	d_tempScaleGroups,
		DeviceBuffer< float >	d_lambdas,
		ParrinelloRahmanVelocityScaling	parrinelloRahmanVelocityScaling,
		Float3	prVelocityScalingMatrixDiagonal,
		const DeviceStream &	deviceStream
	)

Backend-specific function to launch GPU Leap Frog kernel.

Parameters

	numAtoms	Total number of atoms.
[in,out]	d_x	Buffer containing initial coordinates, and where the updated ones will be written.
[out]	d_xp	Buffer where a copy of the initial coordinates will be written.
[in,out]	d_v	Buffer containing initial velocities, and where the updated ones will be written.
[in]	d_f	Buffer containing forces.
[in]	d_inverseMasses	Buffer containing atoms' reciprocal masses.
	dt	Timestep.
	doTemperatureScaling	Whether temperature scaling is needed.
	numTempScaleValues	Number of different T-couple values.
	d_tempScaleGroups	Mapping of atoms into temperature scaling groups.
	d_lambdas	Temperature scaling factors (one per group).
	parrinelloRahmanVelocityScaling	The properties of the Parrinello-Rahman velocity scaling matrix.
	prVelocityScalingMatrixDiagonal	Diagonal elements of Parrinello-Rahman velocity scaling matrix.
	deviceStream	Device stream for kernel launch.

void gmx::launchLincsGpuKernel	(	LincsGpuKernelParameters *	kernelParams,
		const DeviceBuffer< Float3 > &	d_x,
		DeviceBuffer< Float3 >	d_xp,
		bool	updateVelocities,
		DeviceBuffer< Float3 >	d_v,
		real	invdt,
		bool	computeVirial,
		const DeviceStream &	deviceStream
	)

Backend-specific function to launch LINCS kernel.

Parameters

kernelParams	LINCS parameters.
d_x	Initial coordinates before the integration.
d_xp	Coordinates after the integration which will be updated.
updateVelocities	Whether to also update velocities.
d_v	Velocities to update (ignored if `updateVelocities` is `false`).
invdt	Reciprocal of timestep.
computeVirial	Whether to compute the virial.
deviceStream	Device stream for kernel launch.

void gmx::launchScaleCoordinatesKernel	(	int	numAtoms,
		DeviceBuffer< Float3 >	d_coordinates,
		const ScalingMatrix &	mu,
		const DeviceStream &	deviceStream
	)

Launches positions of velocities scaling kernel.

Parameters

[in]	numAtoms	Number of atoms in the system.
[in]	d_coordinates	Device buffer with position or velocities to be scaled.
[in]	mu	Scaling matrix.
[in]	deviceStream	Stream to launch kernel in.

void gmx::launchSettleGpuKernel	(	int	numSettles,
		const DeviceBuffer< WaterMolecule > &	d_atomIds,
		const SettleParameters &	settleParameters,
		const DeviceBuffer< Float3 > &	d_x,
		DeviceBuffer< Float3 >	d_xp,
		bool	updateVelocities,
		DeviceBuffer< Float3 >	d_v,
		real	invdt,
		bool	computeVirial,
		DeviceBuffer< float >	d_virialScaled,
		const PbcAiuc &	pbcAiuc,
		const DeviceStream &	deviceStream
	)

Apply SETTLE.

Applies SETTLE to coordinates and velocities, stored on GPU. Data at pointers d_xp and d_v change in the GPU memory. The results are not automatically copied back to the CPU memory. Method uses this class data structures which should be updated when needed using update method.

Parameters

[in]	numSettles	Number of SETTLE constraints.
[in]	d_atomIds	Device buffer with indices of atoms to be SETTLEd.
[in]	settleParameters	Parameters for SETTLE constraints.
[in]	d_x	Coordinates before timestep (in GPU memory)
[in,out]	d_xp	Coordinates after timestep (in GPU memory). The resulting constrained coordinates will be saved here.
[in]	updateVelocities	If the velocities should be updated.
[in,out]	d_v	Velocities to update (in GPU memory, can be nullptr if not updated)
[in]	invdt	Reciprocal timestep (to scale Lagrange multipliers when velocities are updated)
[in]	computeVirial	If virial should be updated.
[in,out]	d_virialScaled	Scaled virial tensor to be updated.
[in]	pbcAiuc	PBC data.
[in]	deviceStream	Device stream to launch kernel in.

template<NumTempScaleValues numTempScaleValues, ParrinelloRahmanVelocityScaling parrinelloRahmanVelocityScaling>

auto gmx::leapFrogKernel	(	Float3 *__restrict__	gm_x,
		Float3 *__restrict__	gm_xp,
		Float3 *__restrict__	gm_v,
		const Float3 *__restrict__	gm_f,
		const float *__restrict__	gm_inverseMasses,
		float	dt,
		const float *__restrict__	gm_lambdas,
		const unsigned short *__restrict__	gm_tempScaleGroups,
		Float3	prVelocityScalingMatrixDiagonal
	)

Main kernel for the Leap-Frog integrator.

The coordinates and velocities are updated on the GPU. Also saves the intermediate values of the coordinates for further use in constraints.

Each GPU thread works with a single particle.

Template Parameters

numTempScaleValues	The number of different T-couple values.
parrinelloRahmanVelocityScaling	The properties of the Parrinello-Rahman velocity scaling matrix.

Parameters

[in,out]	gm_x	Coordinates to update upon integration.
[out]	gm_xp	A copy of the coordinates before the integration (for constraints).
[in,out]	gm_v	Velocities to update.
[in]	gm_f	Atomic forces.
[in]	gm_inverseMasses	Reciprocal masses.
[in]	dt	Timestep.
[in]	gm_lambdas	Temperature scaling factors (one per group).
[in]	gm_tempScaleGroups	Mapping of atoms into groups.
[in]	prVelocityScalingMatrixDiagonal	Diagonal elements of Parrinello-Rahman velocity scaling matrix.

static void gmx::lincs_matrix_expand	(	const Lincs &	lincsd,
		const Task &	li_task,
		gmx::ArrayRef< const real >	blcc,
		gmx::ArrayRef< real >	rhs1,
		gmx::ArrayRef< real >	rhs2,
		gmx::ArrayRef< real >	sol
	)

static

Do a set of nrec LINCS matrix multiplications.

This function will return with up to date thread-local constraint data, without an OpenMP barrier.

template<bool updateVelocities, bool computeVirial, bool haveCoupledConstraints>

auto gmx::lincsKernel	(	sycl::handler &	cgh,
		const int	numConstraintsThreads,
		const AtomPair *__restrict__	gm_constraints,
		const float *__restrict__	gm_constraintsTargetLengths,
		const int *__restrict__	gm_coupledConstraintsCounts,
		const int *__restrict__	gm_coupledConstraintsIndices,
		const float *__restrict__	gm_massFactors,
		float *__restrict__	gm_matrixA,
		const float *__restrict__	gm_inverseMasses,
		const int	numIterations,
		const int	expansionOrder,
		const Float3 *__restrict__	gm_x,
		Float3 *__restrict__	gm_xp,
		const float	invdt,
		Float3 *__restrict__	gm_v,
		float *__restrict__	gm_virialScaled,
		PbcAiuc	pbcAiuc
	)

Main kernel for LINCS constraints.

See Hess et al., J. Comput. Chem. 18: 1463-1472 (1997) for the description of the algorithm.

In GPU version, one thread is responsible for all computations for one constraint. The blocks are filled in a way that no constraint is coupled to the constraint from the next block. This is achieved by moving active threads to the next block, if the correspondent group of coupled constraints is to big to fit the current thread block. This may leave some 'dummy' threads in the end of the thread block, i.e. threads that are not required to do actual work. Since constraints from different blocks are not coupled, there is no need to synchronize across the device. However, extensive communication in a thread block are still needed.

Todo:

Reduce synchronization overhead. Some ideas are:

Consider going to warp-level synchronization for the coupled constraints.
Move more data to local/shared memory and try to get rid of atomic operations (at least on the device level).
Use analytical solution for matrix A inversion.
Introduce mapping of thread id to both single constraint and single atom, thus designating Nth threads to deal with Nat <= Nth coupled atoms and Nc <= Nth coupled constraints. See Issue #2885 for details (https://gitlab.com/gromacs/gromacs/-/issues/2885)

The use of restrict for gm_xp and gm_v causes failure, probably because of the atomic operations. Investigate this issue further.

Template Parameters

updateVelocities	Whether velocities should be updated this step.
computeVirial	Whether virial tensor should be computed this step.
haveCoupledConstraints	If there are coupled constraints (i.e. LINCS iterations are needed).

Parameters

[in]	cgh	SYCL handler.
[in]	numConstraintsThreads	Total number of threads.
[in]	gm_constraints	List of constrained atoms.
[in]	gm_constraintsTargetLengths	Equilibrium distances for the constraints.
[in]	gm_coupledConstraintsCounts	Number of constraints, coupled with the current one.
[in]	gm_coupledConstraintsIndices	List of coupled with the current one.
[in]	gm_massFactors	Mass factors.
[in]	gm_matrixA	Elements of the coupling matrix.
[in]	gm_inverseMasses	1/mass for all atoms.
[in]	numIterations	Number of iterations used to correct the projection.
[in]	expansionOrder	Order of expansion when inverting the matrix.
[in]	gm_x	Unconstrained positions.
[in,out]	gm_xp	Positions at the previous step, will be updated.
[in]	invdt	Inverse timestep (needed to update velocities).
[in,out]	gm_v	Velocities of atoms, will be updated if `updateVelocities`.
[in,out]	gm_virialScaled	Scaled virial tensor (6 floats: [XX, XY, XZ, YY, YZ, ZZ]). Will be updated if `updateVirial`.
[in]	pbcAiuc	Periodic boundary data.

void gmx::linearArrayIndexToMultiDim	(	int	indexLinear,
		int	ndim,
		const awh_ivec	numPointsDim,
		awh_ivec	indexMulti
	)

Convert a linear array index to a multidimensional one.

Parameters

[in]	indexLinear	Linear array index
[in]	ndim	Number of dimensions of the array.
[in]	numPointsDim	Number of points for each dimension.
[out]	indexMulti	The multidimensional index.

void gmx::linearGridindexToMultiDim	(	const BiasGrid &	grid,
		int	indexLinear,
		awh_ivec	indexMulti
	)

Convert a linear grid point index to a multidimensional one.

Parameters

[in]	grid	The grid.
[in]	indexLinear	Linear grid point index to convert to a multidimensional one.
[out]	indexMulti	The multidimensional index.

static float gmx::log ( float x )

inlinestatic

Float log(x). This is the natural logarithm.

Parameters

x	Argument, should be >0.

Returns: The natural logarithm of x. Undefined if argument is invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::log ( double x )

inlinestatic

Double log(x). This is the natural logarithm.

Parameters

x	Argument, should be >0.

Returns: The natural logarithm of x. Undefined if argument is invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

unsigned int gmx::log2I ( std::uint32_t x )

Compute floor of logarithm to base 2, 32 bit unsigned argument.

Parameters

x	32-bit unsigned argument

Returns: log2(x)

Note: This version of the overloaded function uses unsigned arguments to be able to handle arguments using all 32 bits.

unsigned int gmx::log2I ( std::uint64_t x )

Compute floor of logarithm to base 2, 64 bit unsigned argument.

Parameters

x	64-bit unsigned argument

Returns: log2(x)

Note: This version of the overloaded function uses unsigned arguments to be able to handle arguments using all 64 bits.

unsigned int gmx::log2I ( std::int32_t x )

Compute floor of logarithm to base 2, 32 bit signed argument.

Parameters

x	32-bit signed argument

Returns: log2(x)

Note: This version of the overloaded function will assert that x is not negative.

unsigned int gmx::log2I ( std::int64_t x )

Compute floor of logarithm to base 2, 64 bit signed argument.

Parameters

x	64-bit signed argument

Returns: log2(x)

Note: This version of the overloaded function will assert that x is not negative.

void gmx::logHardwareDetectionWarnings	(	const gmx::MDLogger &	mdlog,
		const gmx_hw_info_t &	hardwareInformation
	)

Issue warnings to mdlog that were decided during detection.

Parameters

[in]	mdlog	Logger
[in]	hardwareInformation	The hardwareInformation

static double gmx::logSingleAccuracy ( double x )

inlinestatic

Double log(x), but with single accuracy. This is the natural logarithm.

Parameters

x	Argument, should be >0.

Returns: The natural logarithm of x. Undefined if argument is invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

ListOfLists< int > gmx::make_at2con	(	int	numAtoms,
		ArrayRef< const InteractionList >	ilist,
		ArrayRef< const t_iparams >	iparams,
		FlexibleConstraintTreatment	flexibleConstraintTreatment
	)

Returns a ListOfLists object to go from atoms to constraints.

The object will contain constraint indices with lower indices directly matching the order in F_CONSTR and higher indices matching the order in F_CONSTRNC offset by the number of constraints in F_CONSTR.

Parameters

[in]	numAtoms	The number of atoms to construct the list for
[in]	ilist	Interaction list, size F_NRE
[in]	iparams	Interaction parameters, can be null when `flexibleConstraintTreatment==Include`
[in]	flexibleConstraintTreatment	The flexible constraint treatment, see enum above

Returns: a ListOfLists object with all constraints for each atom

ListOfLists< int > gmx::make_at2con	(	const gmx_moltype_t &	moltype,
		gmx::ArrayRef< const t_iparams >	iparams,
		FlexibleConstraintTreatment	flexibleConstraintTreatment
	)

Returns a ListOfLists object to go from atoms to constraints.

The object will contain constraint indices with lower indices directly matching the order in F_CONSTR and higher indices matching the order in F_CONSTRNC offset by the number of constraints in F_CONSTR.

Parameters

[in]	moltype	The molecule data
[in]	iparams	Interaction parameters, can be null when `flexibleConstraintTreatment==Include`
[in]	flexibleConstraintTreatment	The flexible constraint treatment, see enum above

Returns: a ListOfLists object with all constraints for each atom

void gmx::make_local_shells	(	const t_commrec *	cr,
		const t_mdatoms &	md,
		gmx_shellfc_t *	shfc
	)

Gets the local shell with domain decomposition.

Parameters

[in]	cr	Communication record
[in]	md	The MD atom data
[in,out]	shfc	The shell/flexible-constraint data

ArrayRef< bool > gmx::makeArrayRef ( std::vector< BoolType > & boolVector )

Create ArrayRef to bool from reference to std::vector<BoolType>.

Allow to easily make views of bool from vectors of BoolType.

See Also: ArrayRef

template<typename T >

ArrayRef<std::conditional_t<std::is_const<T>::value, const typename T::value_type, typename T::value_type> > gmx::makeArrayRef ( T & c )

Create ArrayRef from container with type deduction.

See Also: ArrayRef

Todo:: Use std::is_const_v when CUDA 11 is a requirement.

static ListOfLists<int> gmx::makeAtomsToConstraintsList	(	int	numAtoms,
		ArrayRef< const InteractionList >	ilists,
		ArrayRef< const t_iparams >	iparams,
		FlexibleConstraintTreatment	flexibleConstraintTreatment
	)

static

Returns a block struct to go from atoms to constraints.

The block struct will contain constraint indices with lower indices directly matching the order in F_CONSTR and higher indices matching the order in F_CONSTRNC offset by the number of constraints in F_CONSTR.

Parameters

[in]	numAtoms	The number of atoms to construct the list for
[in]	ilists	The interaction lists, size F_NRE
[in]	iparams	Interaction parameters, can be null when `flexibleConstraintTreatment==Include`
[in]	flexibleConstraintTreatment	The flexible constraint treatment, see enum above

Returns: a block struct with all constraints for each atom

static std::vector<ListOfLists<int> > gmx::makeAtomToConstraintMappings	(	const gmx_mtop_t &	mtop,
		FlexibleConstraintTreatment	flexibleConstraintTreatment
	)

static

Makes a per-moleculetype container of mappings from atom indices to constraint indices.

Note that flexible constraints are only enabled with a dynamical integrator.

static std::vector<int> gmx::makeAtomToGroupMapping ( const gmx::RangePartitioning & grouping )

static

Returns the an array with group indices for each atom.

Parameters

[in] grouping The partitioning of the atom range into atom groups

ArrayRef< const bool > gmx::makeConstArrayRef ( const std::vector< BoolType > & boolVector )

Create ArrayRef to const bool from reference to std::vector<BoolType>.

Allow to easily make views of const bool from vectors of BoolType.

See Also: ArrayRef

template<typename T >

ArrayRef<const typename T::value_type> gmx::makeConstArrayRef ( const T & c )

Create ArrayRef to const T from container with type deduction.

See Also: ArrayRef

template<typename... Args>

std::unique_ptr<Constraints> gmx::makeConstraints	(	const gmx_mtop_t &	mtop,
		const t_inputrec &	ir,
		pull_t *	pull_work,
		bool	havePullConstraintsWork,
		bool	doEssentialDynamics,
		Args &&...	args
	)

Factory function for Constraints.

We only want an object to manage computing constraints when the simulation requires one. Checking for whether the object was made adds overhead to simulations that use constraints, while avoiding overhead on those that do not, so is a design trade-off we might reconsider some time.

Using a private constructor and a factory function ensures that we can only make a Constraints object when the prerequisites are satisfied, ie. that something needs them and if necessary has already been initialized.

Using the parameter pack insulates the factory function from changes to the type signature of the constructor that don't affect the logic here.

std::vector< int > gmx::makeGpuIds	(	ArrayRef< const int >	compatibleGpus,
		size_t	numGpuTasks
	)

Make a vector containing numGpuTasks IDs of the IDs found in compatibleGpus.

Exceptions

std::bad_alloc If out of memory

Returns: A sorted vector of IDs of compatible vectors, whose length matches that of the number of GPU tasks required.

std::string gmx::makeGpuIdString	(	const std::vector< int > &	gpuIds,
		int	totalNumberOfTasks
	)

Convert a container of GPU deviced IDs to a string that can be used by gmx tune_pme as input to mdrun -gputasks.

Produce a valid input for mdrun -gputasks that refers to the device IDs in gpuIds but produces a mapping for totalNumberOfTasks tasks. Note that gmx tune_pme does not currently support filling mdrun -gputasks.

Parameters

[in]	gpuIds	Container of device IDs
[in]	totalNumberOfTasks	Total number of tasks for the output mapping produced by the returned string.

Returns: A string that is suitable to pass to mdrun -gputasks.

Exceptions

std::bad_alloc If out of memory.

std::unique_ptr< ImdSession > gmx::makeImdSession	(	const t_inputrec *	ir,
		const t_commrec *	cr,
		gmx_wallcycle *	wcycle,
		gmx_enerdata_t *	enerd,
		const gmx_multisim_t *	ms,
		const gmx_mtop_t &	top_global,
		const MDLogger &	mdlog,
		gmx::ArrayRef< const gmx::RVec >	coords,
		int	nfile,
		const t_filenm	fnm[],
		const gmx_output_env_t *	oenv,
		const ImdOptions &	options,
		StartingBehavior	startingBehavior
	)

Makes and returns an initialized IMD session, which may be inactive.

This function is called before the main MD loop over time steps.

Parameters

ir	The inputrec structure containing the MD input parameters
cr	Information structure for MPI communication.
wcycle	Count wallcycles of IMD routines for diagnostic output.
enerd	Contains the GROMACS energies for the different interaction types.
ms	Handler for multi-simulations.
top_global	The topology of the whole system.
mdlog	Logger
coords	The starting positions of the atoms.
nfile	Number of files.
fnm	Struct containing file names etc.
oenv	Output options.
options	Options for interactive MD.
startingBehavior	Describes whether this is a restart appending to output files

std::vector< int > gmx::makeListOfAvailableDevices	(	gmx::ArrayRef< const std::unique_ptr< DeviceInformation >>	deviceInfoList,
		const std::string &	devicesSelectedByUserString
	)

Implement GPU ID selection by returning the available GPU IDs on this physical node that are compatible.

If the string supplied by the user is empty, then return the IDs of all compatible GPUs on this physical node. Otherwise, check the user specified compatible GPUs and return their IDs.

Parameters

[in]	deviceInfoList	Information on the GPUs on this physical node.
[in]	devicesSelectedByUserString	String like "013" or "0,1,3" typically supplied by the user to mdrun -gpu_id. Must contain only unique decimal digits, or only decimal digits separated by comma delimiters. A terminal comma is accceptable (and required to specify a single ID that is larger than 9).

Returns: A vector of unique compatible GPU IDs on this physical node.

Exceptions

std::bad_alloc If out of memory. InvalidInputError If an invalid character is found (ie not a digit or ',') or if identifiers are duplicated in the specifier list. InvalidInputError If devicesSelectedByUserString specifies IDs of the devices that are not compatible.

std::unique_ptr< MDAtoms > gmx::makeMDAtoms	(	FILE *	fp,
		const gmx_mtop_t &	mtop,
		const t_inputrec &	ir,
		const bool	rankHasPmeGpuTask
	)

Builder function for MdAtomsWrapper.

Builder function.

std::string gmx::makeOpenClInternalErrorString	(	const char *	message,
		cl_int	status
	)

inline

Make an error string following an OpenCL API call.

It is meant to be called with status != CL_SUCCESS, but it will work correctly even if it is called with no OpenCL failure.

Todo:: Make use of this function more.

Parameters

[in]	message	Supplies context, e.g. the name of the API call that returned the error.
[in]	status	OpenCL API status code

Returns: A string describing the OpenCL error.

uint64_t gmx::makeRandomSeed ( )

Return 64 random bits from the random device, suitable as seed.

If the internal random device output is smaller than 64 bits, this routine will use multiple calls internally until we have 64 bits of random data.

Returns: 64-bit unsigned integer with random bits.

template<typename GeneratorType >

static uint64_t gmx::makeRandomSeedInternal ( GeneratorType & gen )

static

Get the next pure or pseudo-random number.

Returns the next random number taken from the hardware generator or from PRNG.

Parameters

[in] gen Pseudo-random/random numbers generator/device to use.

Returns: Random or pseudo-random number.

std::variant< std::vector< RangePartitioning >, std::string > gmx::makeUpdateGroupingsPerMoleculeType ( const gmx_mtop_t & mtop )

Returns a vector with update groups for each moleculetype in mtop or an error string when the criteria (see below) are not satisfied.

An error string is returned when at least one moleculetype does not obey the restrictions of update groups, e.g. more than two constraints in a row.

Currently valid update groups are:

a single atom which is not a virtual site and does not have constraints;
or a group of atoms where all virtual sites are constructed from atoms within the group and at least one non-vsite atom is constrained to all other non-vsite atoms.

To have update groups, all virtual sites should be linear 2 or 3 atom constructions with coefficients >= 0 and sum of coefficients <= 1.

This vector is generally consumed in constructing an UpdateGroups object.

Parameters

[in] mtop The system topology

UpdateGroups gmx::makeUpdateGroups	(	const gmx::MDLogger &	mdlog,
		std::vector< RangePartitioning > &&	updateGroupingPerMoleculeType,
		real	maxUpdateGroupRadius,
		bool	doRerun,
		bool	useDomainDecomposition,
		bool	systemHasConstraintsOrVsites,
		real	cutoffMargin
	)

Builder for update groups.

Checks the conditions for using update groups, and logs a message if they cannot be used, along with the reason why not.

updateGroupingPerMoleculeType can not be empty (is asserted).

If PP domain decomposition is not in use, there is no reason to use update groups.

All molecule types in the system topology must be conform to the requirements, such that makeUpdateGroupingsPerMoleculeType() returns a non-empty vector.

mdrun -rerun does not support update groups (PBC corrections needed).

When we have constraints and/or vsites, it is beneficial to use update groups (when possible) to allow independent update of groups. But if there are no constraints or vsites, then there is no need to use update groups at all.

To use update groups, the large domain-to-domain cutoff distance should be compatible with the box size.

std::unique_ptr< VirtualSitesHandler > gmx::makeVirtualSitesHandler	(	const gmx_mtop_t &	mtop,
		const t_commrec *	cr,
		PbcType	pbcType,
		ArrayRef< const RangePartitioning >	updateGroupingPerMoleculeType
	)

Create the virtual site handler.

Parameters

[in]	mtop	The global topology
[in]	cr	The communication record
[in]	pbcType	The type of PBC
[in]	updateGroupingPerMoleculeType	Update grouping per molecule type, pass empty when not using update groups

Returns: A valid vsite handler object or nullptr when there are no virtual sites

static DevelopmentFeatureFlags gmx::manageDevelopmentFeatures	(	const gmx::MDLogger &	mdlog,
		const bool	useGpuForNonbonded,
		const PmeRunMode	pmeRunMode,
		const int	numRanksPerSimulation,
		const int	numPmeRanksPerSimulation,
		gmx::GpuAwareMpiStatus	gpuAwareMpiStatus
	)

static

Manage any development feature flag variables encountered.

The use of dev features indicated by environment variables is logged in order to ensure that runs with such features enabled can be identified from their log and standard output. Any cross dependencies are also checked, and if unsatisfied, a fatal error issued.

Note that some development features overrides are applied already here: the GPU communication flags are set to false in non-tMPI and non-CUDA builds.

Parameters

[in]	mdlog	Logger object.
[in]	useGpuForNonbonded	True if the nonbonded task is offloaded in this run.
[in]	pmeRunMode	Run mode indicating what resource is PME executed on.
[in]	numRanksPerSimulation	The number of ranks in each simulation.
[in]	numPmeRanksPerSimulation	The number of PME ranks in each simulation, can be -1
[in]	gpuAwareMpiStatus	Minimum level of GPU-aware MPI support across all ranks

Returns: The object populated with development feature flags.

void gmx::mapGridToDataGrid	(	std::vector< int > *	gridpointToDatapoint,
		const MultiDimArray< std::vector< double >, dynamicExtents2D > &	data,
		int	numDataPoints,
		const std::string &	dataFilename,
		const BiasGrid &	grid,
		const std::string &	correctFormatMessage
	)

Maps each point in the grid to a point in the data grid.

This functions maps an AWH bias grid to a user provided input data grid. The value of data grid point i along dimension d is given by data[d][i]. The number of dimensions of the data should equal that of the grid. A fatal error is thrown if extracting the data fails or the data does not cover the whole grid.

Parameters

[out]	gridpointToDatapoint	Array mapping each grid point to a data point index.
[in]	data	2D array in format ndim x ndatapoints with data grid point values.
[in]	numDataPoints	Number of data points.
[in]	dataFilename	The data filename.
[in]	grid	The grid.
[in]	correctFormatMessage	String to include in error message if extracting the data fails.

static float gmx::maskAdd	(	float	a,
		float	b,
		float	m
	)

inlinestatic

Add two float variables, masked version.

Parameters

a	term1
b	term2
m	mask

Returns: a+b where mask is true, a otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::maskAdd	(	double	a,
		double	b,
		double	m
	)

inlinestatic

Add two double variables, masked version.

Parameters

a	term1
b	term2
m	mask

Returns: a+b where mask is true, a otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::maskzFma	(	float	a,
		float	b,
		float	c,
		float	m
	)

inlinestatic

Float fused multiply-add, masked version.

Parameters

a	factor1
b	factor2
c	term
m	mask

Returns: a*b+c where mask is true, 0.0 otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::maskzFma	(	double	a,
		double	b,
		double	c,
		double	m
	)

inlinestatic

double fused multiply-add, masked version.

Parameters

a	factor1
b	factor2
c	term
m	mask

Returns: a*b+c where mask is true, 0.0 otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::maskzInv	(	float	x,
		bool	m
	)

inlinestatic

Calculate 1/x for masked entry of float.

This routine only evaluates 1/x if mask is true. Illegal values for a masked-out float will not lead to floating-point exceptions.

Parameters

x	Argument that must be nonzero if masked-in.
m	Mask

Returns: 1/x. Result is undefined if your argument was invalid or entry was not masked, and 0.0 for masked-out entries.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::maskzInv	(	double	x,
		bool	m
	)

inlinestatic

Calculate 1/x for masked entry of double.

This routine only evaluates 1/x if mask is true. Illegal values for a masked-out double will not lead to floating-point exceptions.

Parameters

x	Argument that must be nonzero if masked-in.
m	Mask

Returns: 1/x. Result is undefined if your argument was invalid or entry was not masked, and 0.0 for masked-out entries.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::maskzInvSingleAccuracy	(	double	x,
		bool	m
	)

inlinestatic

Calculate 1/x for masked entry of double, but with single accuracy.

This routine only evaluates 1/x if mask is true. Illegal values for a masked-out double will not lead to floating-point exceptions.

Parameters

x	Argument that must be nonzero if masked-in.
m	Mask

Returns: 1/x. Result is undefined if your argument was invalid or entry was not masked, and 0.0 for masked-out entries.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::maskzInvsqrt	(	float	x,
		bool	m
	)

inlinestatic

Calculate 1/sqrt(x) for masked entry of float.

This routine only evaluates 1/sqrt(x) if mask is true. Illegal values for a masked-out float will not lead to floating-point exceptions.

Parameters

x	Argument that must be >0 if masked-in.
m	Mask

Returns: 1/sqrt(x). Result is undefined if your argument was invalid or entry was not masked, and 0.0 for masked-out entries.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::maskzInvsqrt	(	double	x,
		bool	m
	)

inlinestatic

Calculate 1/sqrt(x) for masked entry of double.

This routine only evaluates 1/sqrt(x) if mask is true. Illegal values for a masked-out double will not lead to floating-point exceptions.

Parameters

x	Argument that must be >0 if masked-in.
m	Mask

Returns: 1/sqrt(x). Result is undefined if your argument was invalid or entry was not masked, and 0.0 for masked-out entries.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::maskzInvsqrtSingleAccuracy	(	double	x,
		bool	m
	)

inlinestatic

Calculate 1/sqrt(x) for masked entry of double, but with single accuracy.

This routine only evaluates 1/sqrt(x) if mask is true. Illegal values for a masked-out double will not lead to floating-point exceptions.

Parameters

x	Argument that must be >0 if masked-in.
m	Mask

Returns: 1/sqrt(x). Result is undefined if your argument was invalid or entry was not masked, and 0.0 for masked-out entries.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::maskzMul	(	float	a,
		float	b,
		float	m
	)

inlinestatic

Multiply two float variables, masked version.

Parameters

a	factor1
b	factor2
m	mask

Returns: a*b where mask is true, 0.0 otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::maskzMul	(	double	a,
		double	b,
		double	m
	)

inlinestatic

Multiply two double variables, masked version.

Parameters

a	factor1
b	factor2
m	mask

Returns: a*b where mask is true, 0.0 otherwise.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx_simdcall gmx::maskzRcp	(	float	x,
		float	m
	)

inlinestatic

Float 1.0/x, masked version.

Parameters

x	Argument, x>0 for entries where mask is true.
m	Mask

Returns: 1/x. The result for masked-out entries will be 0.0.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx_simdcall gmx::maskzRcp	(	double	x,
		double	m
	)

inlinestatic

Double 1.0/x, masked version.

Parameters

x	Argument, x>0 for entries where mask is true.
m	Mask

Returns: Approximation of 1/x. The result for masked-out entries will be 0.0.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::max	(	float	a,
		float	b
	)

inlinestatic

Set each float element to the largest from two variables.

Parameters

a	Any floating-point value
b	Any floating-point value

Returns: max(a,b) for each element.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::max	(	double	a,
		double	b
	)

inlinestatic

Set each double element to the largest from two variables.

Parameters

a	Any doubleing-point value
b	Any doubleing-point value

Returns: max(a,b) for each element.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

void gmx::mdAlgorithmsSetupAtomData	(	const t_commrec *	cr,
		const t_inputrec &	inputrec,
		const gmx_mtop_t &	top_global,
		gmx_localtop_t *	top,
		t_forcerec *	fr,
		ForceBuffers *	force,
		MDAtoms *	mdAtoms,
		Constraints *	constr,
		VirtualSitesHandler *	vsite,
		gmx_shellfc_t *	shellfc
	)

Sets atom data for several MD algorithms.

Most MD algorithms require two different setup calls: one for initialization and parameter setting and one for atom data setup. This routine sets the atom data for the (locally available) atoms. This is called at the start of serial runs and during domain decomposition.

Parameters

[in]	cr	Communication record
[in]	inputrec	Input parameter record
[in]	top_global	The global topology
[in,out]	top	The local topology
[in,out]	fr	The force calculation parameter/data record
[out]	force	The force buffer
[out]	mdAtoms	The MD atom data
[in,out]	constr	The constraints handler, can be NULL
[in,out]	vsite	The virtual site data, can be NULL
[in,out]	shellfc	The shell/flexible-constraint data, can be NULL

static void gmx::mdrunner_start_fn ( const void * arg )

static

The callback used for running on spawned threads.

Obtains the pointer to the main mdrunner object from the one argument permitted to the thread-launch API call, copies it to make a new runner for this thread, reinitializes necessary data, and proceeds to the simulation.

void gmx::mergeExclusions	(	ListOfLists< int > *	excl,
		gmx::ArrayRef< ExclusionBlock >	b2
	)

Merge the contents of b2 into excl.

Requires that b2 and excl describe the same number of particles, if b2 describes a non-zero number.

static float gmx::min	(	float	a,
		float	b
	)

inlinestatic

Set each float element to the smallest from two variables.

Parameters

a	Any floating-point value
b	Any floating-point value

Returns: min(a,b) for each element.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::min	(	double	a,
		double	b
	)

inlinestatic

Set each double element to the smallest from two variables.

Parameters

a	Any doubleing-point value
b	Any doubleing-point value

Returns: min(a,b) for each element.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

void gmx::MPI_Comm_free_wrapper ( MPI_Comm * comm )

Wrapper function for RAII-style cleanup.

This is needed to discard the return value so it can be used as a deleter by a smart pointer.

bool gmx::mrcHeaderIsSane ( const MrcDensityMapHeader & header )

Checks if the values in the header are sane.

Checks extents and numbers of columns, rows and sections, as well as unit cell angles for positivity and to be within bounds.

Bounds are set generously not to hamper future creative uses of mrc files.

Returns: true if all header values are within resonable albeit generous bounds

int gmx::multiDimArrayIndexToLinear	(	const awh_ivec	indexMulti,
		int	numDim,
		const awh_ivec	numPointsDim
	)

Convert multidimensional array index to a linear one.

Parameters

[in]	indexMulti	Multidimensional index to convert to a linear one.
[in]	numDim	Number of dimensions of the array.
[in]	numPointsDim	Number of points of the array.

Returns: the linear index.

Note: This function can be used without having an initialized grid.

int gmx::multiDimGridIndexToLinear	(	const BiasGrid &	grid,
		const awh_ivec	indexMulti
	)

Convert a multidimensional grid point index to a linear one.

Parameters

[in]	grid	The grid.
[in]	indexMulti	Multidimensional grid point index to convert to a linear one.

Returns: the linear index.

template<KernelLayout kernelLayout, KernelCoulombType coulombType, VdwCutoffCheck vdwCutoffCheck, LJCombinationRule ljCombinationRule, InteractionModifiers vdwModifier, LJEwald ljEwald, EnergyOutput energyOutput>

void gmx::nbnxmKernelSimd	(	const NbnxnPairlistCpu *	nbl,
		const nbnxn_atomdata_t *	nbat,
		const interaction_const_t *	ic,
		const rvec *	shift_vec,
		nbnxn_atomdata_output_t *	out
	)

The actual NBNxM SIMD kernel.

Template Parameters

kernelLayout	The kernel layout: either 2xMM or 4xM
coulombType	The type of Coulomb interaction
vdwCutoffCheck	Whether a separate check for the VdW cutoff is needed
ljCombinationRule	The combination rule for the LJ parameters
vdwModifier	The modifier for the LJ interactions
ljEwald	The type of LJ Ewald treatment, can be none
energyOutput	Which types of output are requested

Parameters

[in]	nbl	The cluster pair list
[in]	nbat	Input data for atoms, including charges and LJ parameters
[in]	ic	The interaction constants
[in]	shift_vec	A list of PBC shift vectors
[in,out]	out	Struct for accumulating forces, energies and virial

bool gmx::needStateGpu ( SimulationWorkload simulationWorkload )

inline

If StatePropagatorDataGpu object is needed.

Parameters

[in] simulationWorkload Simulation workload flags.

Returns: Whether the StatePropagatorDataGpu object is needed/was created for this run.

OptimisationResult gmx::nelderMead	(	const std::function< real(ArrayRef< const real >)> &	functionToMinimize,
		ArrayRef< const real >	initialGuess,
		real	minimumRelativeSimplexLength = `1e-8`,
		int	maxSteps = `10'000`
	)

Derivative-free downhill simplex optimisation.

Find a local minimum of an N-dimensional mapping $\mathbb{R}^N\to\mathbb{R}$ using the downhill simplex algorithm by Nelder and Mead as described in

  Saša Singer and John Nelder (2009), Scholarpedia, 4(7):2928.
  doi:10.4249/scholarpedia.2928

Stops when the oriented simplex length is less than a constant factor times the initial lengths or when a maximum step size is reached.

For best performance pre-condition problem magnitudes to 1.

The following algorithm is implemented in this function 1 Define the N+1 vertices of the initial simplex The inital simplex is constructed from the initial guess and N additional vertices by adding 0.05 to the initial guess (or 0.0025 if the initial guess is the null vector) from the initial vertex (in line with usual implementations).

1a Sort vertices according to function value with the lowest function value first in order to minimize the function.

2 Calculate the centroid of the simplex as arithmetic mean of all vertices except the worst, $x_c = \frac1n \sum_{i=1}{N} x_i$ .

3 Reflect the worst simplex vertex (the one with the highest function value) at the centroid to obtain a reflection point $x_r = x_c + \alpha (x_c - x_{N+1})$ which lies outside the vertex.

3a Replace worst point with reflection point if reflection point function value is better than second worst point, but not better than best and go to 1a.

4 If the reflection point is better than all other points so far, attempt an expansion by calculating the expansion point at $x_e = x_c + \gamma (x_r - x_c)$ . Swap out the worst point in the vertex with the expansion point if better than reflection point, otherwise use the reflection point and go to 1a.

5 Attempt contraction, because reflection was not successful; $x_t = x_c + \rho (x_{N+1} - x_c)$ . If the contraction point is better than the worst point, swap out worst point with contracted point and go to 1a.

6 Shrink the vertex. Replace all points except the best one with $x_i = x_1 + \sigma (x_i - x_1)$ and go to 1a.

Parameters

[in]	functionToMinimize	function to be minimized
[in]	initialGuess	of coordinates
[in]	minimumRelativeSimplexLength	minimal oriented simplex length with respect to initial simplex
[in]	maxSteps	to run algorithm for

Returns: the lowest found function value and corresponding coordinates.

void gmx::niceHeader	(	TextWriter *	writer,
		const char *	fn,
		char	commentChar
	)

Prints creation time stamp and user information into a string as comments, and returns it.

Parameters

[out]	writer	Where to print the information.
[in]	fn	Name of the file being written; if nullptr, described as "unknown".
[in]	commentChar	Character to use as the starting delimiter for comments.

Exceptions

std::bad_alloc if out of memory.

int gmx::nonbondedMtsFactor ( const t_inputrec & ir )

Returns the interval in steps at which the non-bonded pair forces are calculated.

Note: returns 1 when multiple time-stepping is not activated.

template<typename T >

std::remove_const_t<T> gmx::norm ( T * v )

Forward operations on C Array style vectors to C implementations.

Since vec.h and vectypes.h independently declare norm and norm2 in different namespaces, code that includes both headers but does not specify the namespace from which to use norm and norm2 cannot properly resolve overloads without the following helper templates.

Template Parameters

T	array element type (e.g. real, int, etc.)

Parameters

v	address of first vector element

Returns: magnitude or squared magnitude of vector

static void gmx::normalizeBlock	(	AwhEnergyBlock *	block,
		const Bias &	bias
	)

static

Normalizes block data for output.

Parameters

[in,out]	block	The block to normalize.
[in]	bias	The AWH bias.

static void gmx::normalizeFreeEnergyAndPmfSum ( std::vector< PointState > * pointState )

static

Normalizes the free energy and PMF sum.

Parameters

[in] pointState The state of the points.

void gmx::normalizeSumPositiveValuesToUnity ( ArrayRef< float > data )

Divide all values of a view by a constant so that the sum of all its positive values is one.

Note: Does nothing if there are no positive values

Parameters

[in,out] data the input data to be normalized

size_t gmx::numberOfExpectedDataItems ( const MrcDensityMapHeader & header )

Return the number of density data items that are expected to follow this header.

Exceptions

InternalError if the number of data items cannot be determined

Returns: the number of voxels

FilePtr gmx::openLibraryFile	(	const std::filesystem::path &	filename,
		bool	bAddCWD = `true`,
		bool	bFatal = `true`
	)

Opens a library file for reading in an RAII-style FILE handle.

Works as findLibraryFile(), except that it opens the file and returns a file handle.

LogFilePtr gmx::openLogFile	(	const char *	lognm,
		bool	appendFiles
	)

Open the log file for writing/appending.

Exceptions

FileIOError when the log file cannot be opened.

static t_trxstatus* gmx::openTNG	(	const std::string &	name,
		const Selection &	sel,
		const gmx_mtop_t *	mtop
	)

static

Method to open TNG file.

Only need extra method to open this kind of file as it may need access to a Selection sel, if it is valid. Otherwise atom indices will be taken from the topology mtop.

Parameters

[in]	name	Name of the output file.
[in]	sel	Reference to selection.
[in]	mtop	Pointer to topology, tested before that it is valid.

Todo:: Those should be methods in a replacement for t_trxstatus instead.

bool gmx::operator!=	(	const DensityFittingParameters &	lhs,
		const DensityFittingParameters &	rhs
	)

Check if two structs holding density fitting parameters are not equal.

Parameters

[in]	lhs	left hand side to be compared
[in]	rhs	right hand side to be compared

Returns: true if lhs is not equal rhs

template<std::ptrdiff_t... LHS, std::ptrdiff_t... RHS>

constexpr bool gmx::operator!=	(	const extents< LHS...> &	lhs,
		const extents< RHS...> &	rhs
	)

noexcept

Check for non-equality.

Returns: true if extents are unequal

bool gmx::operator==	(	const DensityFittingParameters &	lhs,
		const DensityFittingParameters &	rhs
	)

Check if two structs holding density fitting parameters are equal.

Parameters

[in]	lhs	left hand side to be compared
[in]	rhs	right hand side to be compared

Returns: true if all elements in DensityFittingParameters are equal, else false

template<std::ptrdiff_t... LHS, std::ptrdiff_t... RHS>

constexpr bool gmx::operator==	(	const extents< LHS...> &	lhs,
		const extents< RHS...> &	rhs
	)

noexcept

Comparison operator.

Returns: true if extents are equal

template<class T1 , class T2 >

bool gmx::operator==	(	const Allocator< T1, HostAllocationPolicy > &	a,
		const Allocator< T2, HostAllocationPolicy > &	b
	)

Return true if two allocators are identical.

True if pinning policy is the same.

std::size_t gmx::pageSize ( )

Return the memory page size on this system.

Implements the "construct on first use" idiom to avoid the static initialization order fiasco where a possible static page-aligned container would be initialized before the alignment variable was.

Note that thread-safety is guaranteed by the C++11 language standard.

template<typename ValueType , int NumExpectedValues>

static std::optional<std::array<ValueType, NumExpectedValues> > gmx::parsedArrayFromInputString ( const std::string & str )

inlinestatic

Convert a string into an array of values.

Template Parameters

ValueType	array element type to convert into
NumExpectedValues	number of values of the array

Returns: an array containing the converted string, optionally null if the white-space stripped string is empty

Exceptions

InvalidInputError	if splitting the string at whitespaces does not result in NumExpectedValues or zero substrings
InvalidInputError	if conversion of any of the NumExpectedValues substrings of the splitted input string fails

Converts a string into an array of type ValueType with exactly NumExpectedValues.

No result is returned if the string is empty or contains only whitespace .

static std::vector<int> gmx::parseGpuDeviceIdentifierList ( const std::string & gpuIdString )

static

Parse a GPU ID specifier string into a container.

Parameters

[in] gpuIdString String like "013" or "0,1,3" typically supplied by the user. Must contain only unique decimal digits, or only decimal digits separated by comma delimiters. A terminal comma is accceptable (and required to specify a single ID that is larger than 9).

Returns: A vector of numeric IDs extracted from gpuIdString.

Exceptions

std::bad_alloc If out of memory. InvalidInputError If an invalid character is found (ie not a digit or ',').

std::vector< int > gmx::parseUserGpuIdString ( const std::string & gpuIdString )

Parse a GPU ID specifier string into a container describing device IDs exposed to the run.

Parameters

[in] gpuIdString String like "013" or "0,1,3" typically supplied by the user to mdrun -gpu_id. Must contain only unique decimal digits, or only decimal digits separated by comma delimiters. A terminal comma is accceptable (and required to specify a single ID that is larger than 9).

Returns: A vector of unique GPU IDs.

Exceptions

std::bad_alloc If out of memory. InvalidInputError If an invalid character is found (ie not a digit or ',') or if identifiers are duplicated in the specifier list.

std::vector< int > gmx::parseUserTaskAssignmentString ( const std::string & gpuIdString )

Parse a GPU ID specifier string into a container describing device ID to task mapping.

Parameters

[in] gpuIdString String like "0011" or "0,0,1,1" typically supplied by the user to mdrun -gputasks. Must contain only decimal digits, or only decimal digits separated by comma delimiters. A terminal comma is accceptable (and required to specify a single ID that is larger than 9).

Returns: A vector of GPU IDs.

Exceptions

std::bad_alloc If out of memory. InvalidInputError If an invalid character is found (ie not a digit or ',').

void gmx::placeCoordinatesWithCOMInBox	(	const PbcType &	pbcType,
		UnitCellType	unitCellType,
		CenteringType	centerType,
		const matrix	box,
		ArrayRef< RVec >	x,
		const gmx_mtop_t &	mtop,
		COMShiftType	comShiftType
	)

Moves collection of atoms along the center of mass into a box.

This ensures that the centre of mass (COM) of a molecule is placed within a predefined coordinate space (usually a simulation box).

Parameters

[in]	pbcType	What kind of PBC are we handling today.
[in]	unitCellType	Kind of unitcell used for the box.
[in]	centerType	How atoms should be centered.
[in]	box	The currently available box to place things into.
[in,out]	x	View in coordinates to shift.
[in]	mtop	Topology with residue and molecule information.
[in]	comShiftType	Whether residues or molecules are shifted.

static float gmx::pmeForceCorrection ( float z2 )

inlinestatic

Calculate the force correction due to PME analytically in float.

See the SIMD version of this function for details.

Parameters

z2	input parameter

Returns: Correction to use on force

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::pmeForceCorrection ( double z2 )

inlinestatic

Calculate the force correction due to PME analytically in double.

See the SIMD version of this function for details.

Parameters

z2	input parameter

Returns: Correction to use on force

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::pmeForceCorrectionSingleAccuracy ( double z2 )

inlinestatic

Force correction due to PME in double, but with single accuracy.

See the SIMD version of this function for details.

Parameters

z2	input parameter

Returns: Correction to use on force

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::pmePotentialCorrection ( float z2 )

inlinestatic

Calculate the potential correction due to PME analytically in float.

See the SIMD version of this function for details.

Parameters

z2	input parameter

Returns: Correction to use on potential.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::pmePotentialCorrection ( double z2 )

inlinestatic

Calculate the potential correction due to PME analytically in double.

See the SIMD version of this function for details.

Parameters

z2	input parameter

Returns: Correction to use on potential.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::pmePotentialCorrectionSingleAccuracy ( double z2 )

inlinestatic

Potential correction due to PME in double, but with single accuracy.

See the SIMD version of this function for details.

Parameters

z2	input parameter

Returns: Correction to use on potential.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static int gmx::pointDistanceAlongAxis	(	const GridAxis &	axis,
		double	x,
		double	x0
	)

static

Returns the point distance between from value x to value x0 along the given axis.

Note that the returned distance may be negative or larger than the number of points in the axis. For a periodic axis, the distance is chosen to be in [0, period), i.e. always positive but not the shortest one.

Parameters

[in]	axis	BiasGrid axis.
[in]	x	From value.
[in]	x0	To value.

Returns: (x - x0) in number of points.

bool gmx::pointsAlongLambdaAxis	(	const BiasGrid &	grid,
		int	pointIndex1,
		int	pointIndex2
	)

Checks whether two points are along a free energy lambda state axis.

Parameters

[in]	grid	The grid.
[in]	pointIndex1	Grid point index of the first point.
[in]	pointIndex2	Grid point index of the second point.

Returns: true if the two points are along a free energy lambda state axis.

bool gmx::pointsHaveDifferentLambda	(	const BiasGrid &	grid,
		int	pointIndex1,
		int	pointIndex2
	)

Checks whether two points are different in the free energy lambda state dimension (if any).

Parameters

[in]	grid	The grid.
[in]	pointIndex1	Grid point index of the first point.
[in]	pointIndex2	Grid point index of the second point.

Returns: true if the two points have different lambda values.

template<typename T >

T gmx::power12 ( T x )

calculate x^12

Template Parameters

T	Type of argument and return value

Parameters

x argument

Returns: x^12

template<typename T >

T gmx::power3 ( T x )

calculate x^3

Template Parameters

T	Type of argument and return value

Parameters

x argument

Returns: x^3

template<typename T >

T gmx::power4 ( T x )

calculate x^4

Template Parameters

T	Type of argument and return value

Parameters

x argument

Returns: x^4

template<typename T >

T gmx::power5 ( T x )

calculate x^5

Template Parameters

T	Type of argument and return value

Parameters

x argument

Returns: x^5

template<typename T >

T gmx::power6 ( T x )

calculate x^6

Template Parameters

T	Type of argument and return value

Parameters

x argument

Returns: x^6

std::unique_ptr< Awh > gmx::prepareAwhModule	(	FILE *	fplog,
		const t_inputrec &	inputRecord,
		t_state *	stateGlobal,
		const t_commrec *	commRecord,
		const gmx_multisim_t *	multiSimRecord,
		bool	startingFromCheckpoint,
		bool	usingShellParticles,
		const std::string &	biasInitFilename,
		pull_t *	pull_work
	)

Makes an Awh and prepares to use it if the user input requests that.

Restores state from history in checkpoint if needed.

Parameters

[in,out]	fplog	General output file, normally md.log, can be nullptr.
[in]	inputRecord	General input parameters (as set up by grompp).
[in]	stateGlobal	A pointer to the global state structure.
[in]	commRecord	Struct for communication, can be nullptr.
[in]	multiSimRecord	Multi-sim handler
[in]	startingFromCheckpoint	Whether the simulation is starting from a checkpoint
[in]	usingShellParticles	Whether the user requested shell particles (which is unsupported)
[in]	biasInitFilename	Name of file to read PMF and target from.
[in,out]	pull_work	Pointer to a pull struct which AWH will couple to, has to be initialized, is assumed not to change during the lifetime of the Awh object.

Returns: An initialized Awh module, or nullptr if none was requested.

Exceptions

InvalidInputError If another active module is not supported.

void gmx::prepareLogAppending ( FILE * fplog )

Prepare to use the open log file when appending.

Does not throw.

void gmx::printBinaryInformation	(	FILE *	fp,
		const IProgramContext &	programContext
	)

Print basic information about the executable.

Parameters

	fp	Where to print the information to.
[in]	programContext	Program information object to use.

void gmx::printBinaryInformation	(	FILE *	fp,
		const IProgramContext &	programContext,
		const BinaryInformationSettings &	settings
	)

Print basic information about the executable with custom settings.

Parameters

	fp	Where to print the information to.
[in]	programContext	Program information object to use.
[in]	settings	Specifies what to print.

See Also: BinaryInformationSettings

void gmx::printBinaryInformation	(	TextWriter *	writer,
		const IProgramContext &	programContext,
		const BinaryInformationSettings &	settings
	)

Print basic information about the executable with custom settings.

Needed to read the members without otherwise unnecessary accessors.

Parameters

[out]	writer	Where to print the information.
[in]	programContext	Program information object to use.
[in]	settings	Specifies what to print.

Exceptions

std::bad_alloc if out of memory.

See Also: BinaryInformationSettings

static std::string gmx::printMissingInteractionsMolblock	(	const t_commrec *	cr,
		const gmx_reverse_top_t &	rt,
		const char *	moltypename,
		const reverse_ilist_t &	ril,
		const Range< int > &	atomRange,
		const int	numAtomsPerMolecule,
		const int	numMolecules,
		const InteractionDefinitions &	idef
	)

static

Help print error output when interactions are missing in a molblock.

Note: This function needs to be called on all ranks (contains a global summation)

int gmx::processExceptionAtExitForCommandLine ( const std::exception & ex )

Handles an exception and deinitializes after initForCommandLine.

Parameters

[in] ex Exception that is the cause for terminating the program.

Returns: Return code to return from main().

This method should be called as the last thing before terminating the program because of an exception. See processExceptionAtExit() for details. Additionally this method undoes the work done by initForCommandLine.

Does not throw.

template<typename ValueType >

void gmx::readKvtCheckpointValue	(	compat::not_null< ValueType * >	value,
		const std::string &	name,
		const std::string &	identifier,
		const KeyValueTreeObject &	kvt
	)

Read to a key-value-tree value used for checkpointing.

Template Parameters

ValueType

Parameters

[in]	value	the value to be checkpointed
[in]	name	name of the value to be checkpointed
[in]	identifier	uniquely identifies the module that is checkpointing typically the module name
[in]	kvt	the key value tree to read from

Exceptions

InternalError if kvt does not contain requested value.

Note: Triggers assertion if value type is not correct.

template void gmx::readKvtCheckpointValue	(	compat::not_null< std::int64_t * >	value,
		const std::string &	name,
		const std::string &	identifier,
		const KeyValueTreeObject &	kvt
	)

Read to a key-value-tree value used for checkpointing.

Template Parameters

ValueType

Parameters

[in]	value	the value to be checkpointed
[in]	name	name of the value to be checkpointed
[in]	identifier	uniquely identifies the module that is checkpointing typically the module name
[in]	kvt	the key value tree to read from

Exceptions

InternalError if kvt does not contain requested value.

Note: Triggers assertion if value type is not correct.

template void gmx::readKvtCheckpointValue	(	compat::not_null< real * >	value,
		const std::string &	name,
		const std::string &	identifier,
		const KeyValueTreeObject &	kvt
	)

Read to a key-value-tree value used for checkpointing.

Template Parameters

ValueType

Parameters

[in]	value	the value to be checkpointed
[in]	name	name of the value to be checkpointed
[in]	identifier	uniquely identifies the module that is checkpointing typically the module name
[in]	kvt	the key value tree to read from

Exceptions

InternalError if kvt does not contain requested value.

Note: Triggers assertion if value type is not correct.

static void gmx::readUserPmfAndTargetDistribution	(	ArrayRef< const DimParams >	dimParams,
		const BiasGrid &	grid,
		const std::string &	filename,
		int	numBias,
		int	biasIndex,
		std::vector< PointState > *	pointState
	)

static

Initializes the PMF and target with data read from an input table.

Parameters

[in]	dimParams	The dimension parameters.
[in]	grid	The grid.
[in]	filename	The filename to read PMF and target from.
[in]	numBias	Number of biases.
[in]	biasIndex	The index of the bias.
[in,out]	pointState	The state of the points in this bias.

static float gmx::reduce ( float a )

inlinestatic

Return sum of all elements in float variable (i.e., the variable itself).

Parameters

a	variable to reduce/sum.

Returns: The argument variable itself.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::reduce ( double a )

inlinestatic

Return sum of all elements in double variable (i.e., the variable itself).

Parameters

a	variable to reduce/sum.

Returns: The argument variable itself.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::reduceIncr4ReturnSum	(	float *	m,
		float	v0,
		float	v1,
		float	v2,
		float	v3
	)

inlinestatic

Add each float to four consecutive memory locations, return sum.

Parameters

m	Pointer to memory where four floats should be incremented
v0	float to be added to m[0]
v1	float to be added to m[1]
v2	float to be added to m[2]
v3	float to be added to m[3]

Returns: v0+v1+v2+v3.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::reduceIncr4ReturnSum	(	double *	m,
		double	v0,
		double	v1,
		double	v2,
		double	v3
	)

inlinestatic

Add each double to four consecutive memory locations, return sum.

Parameters

m	Pointer to memory where four floats should be incremented
v0	double to be added to m[0]
v1	double to be added to m[1]
v2	double to be added to m[2]
v3	double to be added to m[3]

Returns: v0+v1+v2+v3.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

void gmx::repartitionAtomMasses	(	gmx_mtop_t *	mtop,
		bool	useFep,
		real	massFactor,
		WarningHandler *	wi
	)

Scales the smallest masses in the system by up to massFactor.

First finds the smallest atom mass. Then sets all masses that are smaller than the smallest mass time massFactor to the smallest mass time massFactor. The additional mass is taken away from the atom bound to the light atom. A warning is generated when light atoms are present that are unbound. An error is generated when perturbed masses are affected or when a light atom is bound to multiple other atoms or when a bound atom does becomes lighter than the smallest mass times massFactor.

Parameters

[in,out]	mtop	The topology to modify
[in]	useFep	Whether free-energy perturbation is active
[in]	massFactor	The factor to scale the smallest mass by
[in,out]	wi	Warning handler

void gmx::reportGpuUsage	(	const MDLogger &	mdlog,
		ArrayRef< const GpuTaskAssignment >	gpuTaskAssignmentOnRanksOfThisNode,
		size_t	numGpuTasksOnThisNode,
		size_t	numPpRanks,
		bool	printHostName,
		PmeRunMode	pmeRunMode,
		const SimulationWorkload &	simulationWork
	)

Log a report on how GPUs are being used on the ranks of the physical node of rank 0 of the simulation.

Todo:: It could be useful to report also whether any nodes differed, and in what way.

Parameters

[in]	mdlog	Logging object.
[in]	gpuTaskAssignmentOnRanksOfThisNode	The selected GPU IDs.
[in]	numGpuTasksOnThisNode	The number of GPU tasks on this node.
[in]	numPpRanks	Number of PP ranks on this node
[in]	printHostName	Print the hostname in the usage information
[in]	pmeRunMode	Describes the execution of PME tasks
[in]	simulationWork	Simulation workload descriptor

Exceptions

std::bad_alloc if out of memory

void gmx::restoreCorrelationGridStateFromHistory	(	const CorrelationGridHistory &	corrGridHist,
		CorrelationGrid *	corrGrid
	)

Restores the correlation grid state from the correlation grid history.

Parameters

[in]	corrGridHist	Correlation grid history to read.
[in,out]	corrGrid	Correlation grid state to set.

static float gmx::round ( float a )

inlinestatic

Float round to nearest integer value (in floating-point format).

Parameters

a	Any floating-point value

Returns: The nearest integer, represented in floating-point format.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::round ( double a )

inlinestatic

double round to nearest integer value (in doubleing-point format).

Parameters

a	Any doubleing-point value

Returns: The nearest integer, represented in doubleing-point format.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static int gmx::roundToInt ( float x )

inlinestatic

Round float to int.

Rounding behavior is round to nearest. Rounding of halfway cases is implementation defined (either halfway to even or halfway away from zero).

int gmx::runCommandLineModule	(	int	argc,
		char *	argv[],
		ICommandLineModule *	module
	)

Implements a main() method that runs a single module.

Parameters

argc	`argc` passed to main().
argv	`argv` passed to main().
module	Module to run.

This method allows for uniform behavior for binaries that only contain a single module without duplicating any of the implementation from CommandLineModuleManager (startup headers, common options etc.).

The signature assumes that module construction does not throw (because otherwise the caller would need to duplicate all the exception handling code). It is possible to move the construction inside the try/catch in this method using an indirection similar to TrajectoryAnalysisCommandLineRunner::runAsMain(), but until that is necessary, the current approach leads to simpler code.

Usage:

int main(int argc, char *argv[])
{
    CustomCommandLineModule module;
    return gmx::runCommandLineModule(argc, argv, &module);
}

Does not throw. All exceptions are caught and handled internally.

int gmx::runCommandLineModule	(	int	argc,
		char *	argv[],
		const char *	name,
		const char *	description,
		std::function< std::unique_ptr< ICommandLineOptionsModule >()>	factory
	)

Implements a main() method that runs a single module.

Parameters

	argc	`argc` passed to main().
	argv	`argv` passed to main().
[in]	name	Name for the module.
[in]	description	Short description for the module.
	factory	Factory method that creates the module to run.

This method allows for uniform behavior for binaries that only contain a single module without duplicating any of the implementation from CommandLineModuleManager (startup headers, common options etc.).

Usage:

class CustomCommandLineOptionsModule : public ICommandLineOptionsModule
{
    // <...>
};
static ICommandLineOptionsModule *create()
{
    return new CustomCommandLineOptionsModule();
}
int main(int argc, char *argv[])
{
    return gmx::runCommandLineModule(
            argc, argv, "mymodule", "short description", &create);
}

Does not throw. All exceptions are caught and handled internally.

static bool gmx::runningOnCompatibleHWForAmd ( const DeviceInformation & deviceInfo )

static

Return true if executing on compatible GPU for AMD OpenCL.

There are known issues with OpenCL when running on 32-wide AMD hardware, such as desktop GPUs with RDNA and RDNA2 architectures (gfx10xx).

Returns: true if running on 64-wide hardware (GCN, CDNA).

static bool gmx::runningOnCompatibleHWForNvidia ( const DeviceInformation & deviceInfo )

static

Return true if executing on compatible GPU for NVIDIA OpenCL.

There are known issues with OpenCL when running on NVIDIA Volta or newer (CC 7+). As a workaround, we recommend using CUDA on such hardware.

This function relies on cl_nv_device_attribute_query. In case it's not functioning properly, we trust the user and mark the device as compatible.

Returns: true if running on Pascal (CC 6.x) or older, or if we can not determine device generation.

static bool gmx::runningOnCompatibleOSForAmd ( )

static

Return true if executing on compatible OS for AMD OpenCL.

This is assumed to be true for OS X version of at least 10.10.4 and all other OS flavors.

Uses the BSD sysctl() interfaces to extract the kernel version.

Returns: true if version is 14.4 or later (= OS X version 10.10.4), or OS is not Darwin.

static float gmx::selectByMask	(	float	a,
		bool	mask
	)

inlinestatic

Select from single precision variable where boolean is true.

Parameters

a	Floating-point variable to select from
mask	Boolean selector

Returns: a is selected for true, 0 for false.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::selectByMask	(	double	a,
		bool	mask
	)

inlinestatic

Select from double precision variable where boolean is true.

Parameters

a	double variable to select from
mask	Boolean selector

Returns: a is selected for true, 0 for false.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::selectByMask	(	std::int32_t	a,
		bool	mask
	)

inlinestatic

Select from integer variable where boolean is true.

Parameters

a	Integer variable to select from
mask	Boolean selector

Returns: a is selected for true, 0 for false.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::selectByNotMask	(	float	a,
		bool	mask
	)

inlinestatic

Select from single precision variable where boolean is false.

Parameters

a	Floating-point variable to select from
mask	Boolean selector

Returns: a is selected for false, 0 for true.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::selectByNotMask	(	double	a,
		bool	mask
	)

inlinestatic

Select from double precision variable where boolean is false.

Parameters

a	double variable to select from
mask	Boolean selector

Returns: a is selected for false, 0 for true.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static std::int32_t gmx::selectByNotMask	(	std::int32_t	a,
		bool	mask
	)

inlinestatic

Select from integer variable where boolean is false.

Parameters

a	Integer variable to select from
mask	Boolean selector

Returns: a is selected for false, 0 for true.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

void gmx::serializeMrcDensityMapHeader	(	ISerializer *	serializer,
		const MrcDensityMapHeader &	mrcHeader
	)

Serializes an MrcDensityMapHeader from a given serializer.

Parameters

[in]	serializer	the serializer
[in]	mrcHeader	file header to be serialized

static real gmx::series_sinhx ( real x )

inlinestatic

Maclaurin series for sinh(x)/x.

Used for NH chains and MTTK pressure control. Here, we compute it to 10th order, which might be an overkill. 8th is probably enough, but it's not very much more expensive.

void gmx::setBoxDeformationFlowMatrix	(	const matrix	boxDeformationVelocity,
		const matrix	box,
		matrix	flowMatrix
	)

Set a matrix for computing the flow velocity at coordinates.

Used with continuous box deformation for calculating the flow profile. Sets a matrix which can be used to multiply with coordinates to obtain the flow velocity at that coordinate.

Parameters

[in]	boxDeformationVelocity	The velocity of the box in nm/ps
[in]	box	The box in nm
[out]	flowMatrix	The deformation rate in ps^-1

void gmx::setLibraryFileFinder ( const DataFileFinder * finder )

Sets a finder for location data files from share/top/.

Parameters

[in] finder finder to set (can be NULL to restore the default finder).

The library does not take ownership of finder. The provided object must remain valid until the global instance is changed by another call to setLibraryFileFinder().

The global instance is used by findLibraryFile() and openLibraryFile().

This method is not thread-safe. See setProgramContext(); the same constraints apply here as well.

Does not throw.

void gmx::setStateDependentAwhParams	(	AwhParams *	awhParams,
		const pull_params_t &	pull_params,
		pull_t *	pull_work,
		const matrix	box,
		PbcType	pbcType,
		const tensor &	compressibility,
		const t_inputrec &	inputrec,
		real	initLambda,
		const gmx_mtop_t &	mtop,
		WarningHandler *	wi
	)

Sets AWH parameters that need state parameters such as the box vectors.

Parameters

[in,out]	awhParams	AWH parameters.
[in]	pull_params	Pull parameters.
[in,out]	pull_work	Pull working struct to register AWH bias in.
[in]	box	Box vectors.
[in]	pbcType	Periodic boundary conditions enum.
[in]	compressibility	Compressibility matrix for pressure coupling, pass all 0 without pressure coupling
[in]	inputrec	Input record, for checking the reference temperature
[in]	initLambda	The starting lambda, to allow using free energy lambda as reaction coordinate provider in any dimension.
[in]	mtop	The system topology.
[in,out]	wi	Struct for bookeeping warnings.

Note: This function currently relies on the function set_pull_init to have been called.

static void gmx::setStateDependentAwhPullDimParams	(	AwhDimParams *	dimParams,
		const int	biasIndex,
		const int	dimIndex,
		const pull_params_t &	pull_params,
		pull_t *	pull_work,
		const t_pbc &	pbc,
		const tensor &	compressibility,
		WarningHandler *	wi
	)

static

Sets AWH parameters, for one AWH pull dimension.

Parameters

[in,out]	dimParams	AWH dimension parameters.
[in]	biasIndex	The index of the bias containing this AWH pull dimension.
[in]	dimIndex	The index of this AWH pull dimension.
[in]	pull_params	Pull parameters.
[in,out]	pull_work	Pull working struct to register AWH bias in.
[in]	pbc	A pbc information structure.
[in]	compressibility	Compressibility matrix for pressure coupling, pass all 0 without pressure coupling.
[in,out]	wi	Struct for bookeeping warnings.

SettleParameters gmx::settleParameters	(	real	mO,
		real	mH,
		real	invmO,
		real	invmH,
		real	dOH,
		real	dHH
	)

Computes and returns settle parameters.

Parameters

[in]	mO	Mass of oxygen atom
[in]	mH	Mass of hydrogen atom
[in]	invmO	Reciprocal mass of oxygen atom
[in]	invmH	Reciprocal mass of hydrogen atom
[in]	dOH	Target O-H bond length
[in]	dHH	Target H-H bond length

DomainLifetimeWorkload gmx::setupDomainLifetimeWorkload	(	const t_inputrec &	inputrec,
		const t_forcerec &	fr,
		const pull_t *	pull_work,
		const gmx_edsam *	ed,
		const t_mdatoms &	mdatoms,
		const SimulationWorkload &	simulationWork
	)

Set up workload flags that have the lifetime of the PP domain decomposition.

This function should be called every time after domain decomposition happens. Also note that fr->listedForcesGpu->updateHaveInteractions() should be called before this function anytime a change in listed forces assignment after repartitioning can be expected.

Parameters

[in]	inputrec	The input record
[in]	fr	The force record
[in]	pull_work	Pull data
[in]	ed	Essential dynamics data
[in]	mdatoms	Atom parameter data
[in]	simulationWork	Simulation workload flags

std::vector< MtsLevel > gmx::setupMtsLevels	(	const GromppMtsOpts &	mtsOpts,
		std::vector< std::string > *	errorMessages
	)

Sets up and returns the MTS levels and checks requirements of MTS.

Appends errors about allowed input values ir to errorMessages, when not nullptr.

Parameters

[in]	mtsOpts	Options for setting the MTS levels
[in,out]	errorMessages	List of error messages, can be nullptr

StepWorkload gmx::setupStepWorkload	(	const int	legacyFlags,
		ArrayRef< const gmx::MtsLevel >	mtsLevels,
		const int64_t	step,
		const DomainLifetimeWorkload &	domainWork,
		const SimulationWorkload &	simulationWork
	)

Set up force flag struct from the force bitmask.

Parameters

[in]	legacyFlags	Force bitmask flags used to construct the new flags
[in]	mtsLevels	The multiple time-stepping levels, either empty or 2 levels
[in]	step	The current MD step
[in]	domainWork	Domain lifetime workload description.
[in]	simulationWork	Simulation workload description.

Returns: New Stepworkload description.

void gmx::shiftAtoms	(	const RVec &	shift,
		ArrayRef< RVec >	x
	)

Shift all coordinates.

Shift coordinates by a previously calculated value.

Can be used to e.g. place particles in a box.

Parameters

[in]	shift	Translation that should be applied.
[in]	x	Coordinates to translate.

static void gmx_unused gmx::simdPrefetch ( void gmx_unused * m )

inlinestatic

Prefetch memory at address m.

This typically prefetches one cache line of memory from address m, usually 64bytes or more, but the exact amount will depend on the implementation. On many platforms this is simply a no-op. Technically it might not be part of the SIMD instruction set, but since it is a hardware-specific function that is normally only used in tight loops where we also apply SIMD, it fits well here.

There are no guarantees about the level of cache or temporality, but usually we expect stuff to end up in level 2, and be used in a few hundred clock cycles, after which it stays in cache until evicted (normal caching).

Parameters

m	Pointer to location prefetch. There are no alignment requirements, but if the pointer is not aligned the prefetch might start at the lower cache line boundary (meaning fewer bytes are prefetched).

static float gmx::sin ( float x )

inlinestatic

Float sin.

Parameters

x	The argument to evaluate sin for

Returns: Sin(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::sin ( double x )

inlinestatic

Double sin.

Parameters

x	The argument to evaluate sin for

Returns: Sin(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::sincos	(	float	x,
		float *	sinval,
		float *	cosval
	)

inlinestatic

Float sin & cos.

Parameters

	x	The argument to evaluate sin/cos for
[out]	sinval	Sin(x)
[out]	cosval	Cos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::sincos	(	double	x,
		double *	sinval,
		double *	cosval
	)

inlinestatic

Double sin & cos.

Parameters

	x	The argument to evaluate sin/cos for
[out]	sinval	Sin(x)
[out]	cosval	Cos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::sincosSingleAccuracy	(	double	x,
		double *	sinval,
		double *	cosval
	)

inlinestatic

Double sin & cos, but with single accuracy.

Parameters

	x	The argument to evaluate sin/cos for
[out]	sinval	Sin(x)
[out]	cosval	Cos(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::sinSingleAccuracy ( double x )

inlinestatic

Double sin, but with single accuracy.

Parameters

x	The argument to evaluate sin for

Returns: Sin(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::sixthroot ( float x )

inlinestatic

Calculate sixth root of x in single precision.

Parameters

x	Argument, must be greater than or equal to zero.

Returns: x^(1/6)

This routine is typically faster than using std::pow().

static double gmx::sixthroot ( double x )

inlinestatic

Calculate sixth root of x in double precision.

Parameters

x	Argument, must be greater than or equal to zero.

Returns: x^(1/6)

This routine is typically faster than using std::pow().

static double gmx::sixthroot ( int x )

inlinestatic

Calculate sixth root of integer x, return double.

Parameters

x	Argument, must be greater than or equal to zero.

Returns: x^(1/6)

This routine is typically faster than using std::pow().

std::vector< std::filesystem::path > gmx::splitPathEnvironment ( const std::string & pathEnv )

Split PATH environment variable into search paths.

Parameters

[in] pathEnv String to split.

Returns: vector of filesystem paths to search.

IntegerBox gmx::spreadRangeWithinLattice	(	const IVec &	center,
		dynamicExtents3D	extent,
		IVec	range
	)

Construct a box that holds all indices that are not more than a given range remote from center coordinates and still within a given lattice extent.

Parameters

[in]	center	the coordinates of the center of the spread range
[in]	extent	the end of the lattice, number of lattice points in each dimension
[in]	range	the distance from the center

Returns: box describing the range of indices

template<MathOptimization opt = MathOptimization::Safe>

static float gmx::sqrt ( float x )

inlinestatic

Float sqrt(x). This is the square root.

Parameters

x	Argument, should be >= 0.

Returns: The square root of x. Undefined if argument is invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<MathOptimization opt = MathOptimization::Safe>

static double gmx::sqrt ( double x )

inlinestatic

Double sqrt(x). This is the square root.

Parameters

x	Argument, should be >= 0.

Returns: The square root of x. Undefined if argument is invalid.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::sqrtSingleAccuracy ( double x )

inlinestatic

Calculate sqrt(x) for double, but with single accuracy.

Parameters

x	Argument that must be >=0.

Returns: sqrt(x).

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<typename T >

T gmx::square ( T x )

calculate x^2

Template Parameters

T	Type of argument and return value

Parameters

x argument

Returns: x^2

static void gmx::store	(	float *	m,
		float	a
	)

inlinestatic

Store contents of float variable to aligned memory m.

Parameters

[out]	m	Pointer to memory.
	a	float variable to store

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::store	(	double *	m,
		double	a
	)

inlinestatic

Store contents of double variable to aligned memory m.

Parameters

[out]	m	Pointer to memory.
	a	double variable to store

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::store	(	std::int32_t *	m,
		std::int32_t	a
	)

inlinestatic

Store contents of integer variable to aligned memory m.

Parameters

[out]	m	Pointer to memory.
	a	integer variable to store

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::storeU	(	float *	m,
		float	a
	)

inlinestatic

Store contents of float variable to unaligned memory m.

Parameters

[out]	m	Pointer to memory, no alignment requirement.
	a	float variable to store.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::storeU	(	double *	m,
		double	a
	)

inlinestatic

Store contents of double variable to unaligned memory m.

Parameters

[out]	m	Pointer to memory, no alignment requirement.
	a	double variable to store.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::storeU	(	std::int32_t *	m,
		std::int32_t	a
	)

inlinestatic

Store contents of integer variable to unaligned memory m.

Parameters

[out]	m	Pointer to memory, no alignment requirement.
	a	integer variable to store.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<typename ValueType , int NumExpectedValues>

static std::string gmx::stringIdentityTransformWithArrayCheck	(	const std::string &	toConvert,
		const std::string &	errorContextMessage
	)

inlinestatic

Returns the input string, throwing an exception if the demanded conversion to an array will not succeed.

Template Parameters

ValueType	array element type to convert into
NumExpectedValues	number of values of the array

Parameters

[in]	toConvert	the string to convert
[in]	errorContextMessage	the message to add to the thrown exceptions if conversion of the string is bound to fail at some point

Returns: the input string

Exceptions

InvalidInputError	if splitting the string at whitespaces does not result in NumExpectedValues or zero substrings
InvalidInputError	if conversion of any of the NumExpectedValues substrings of the splitted input string fails

A typical use of this function would be in .mdp string option parsing where information in the .mdp file is transformed into the data that is stored in the .tpr file.

template<typename T >

void gmx::sumOverSimulations	(	ArrayRef< T >	data,
		MPI_Comm	multiSimComm,
		const bool	broadcastWithinSimulation,
		const t_commrec &	commRecord
	)

Sum an array over all simulations on main ranks or all ranks of each simulation.

This assumes the data is identical on all ranks within each simulation.

Parameters

[in,out]	data	The data to sum.
[in]	multiSimComm	Communicator for the main ranks of sharing simulations.
[in]	broadcastWithinSimulation	Broadcast the result to all ranks within the simulation
[in]	commRecord	Struct for intra-simulation communication.

bool gmx::systemHasConstraintsOrVsites ( const gmx_mtop_t & mtop )

Returns whether mtop contains any constraints and/or vsites.

When we have constraints and/or vsites, it is beneficial to use update groups (when possible) to allow independent update of groups.

static float gmx::tan ( float x )

inlinestatic

Float tan.

Parameters

x	The argument to evaluate tan for

Returns: Tan(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::tan ( double x )

inlinestatic

Double tan.

Parameters

x	The argument to evaluate tan for

Returns: Tan(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::tanSingleAccuracy ( double x )

inlinestatic

Double tan, but with single accuracy.

Parameters

x	The argument to evaluate tan for

Returns: Tan(x)

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static bool gmx::testBits ( float a )

inlinestatic

Return true if any bits are set in the float variable.

This function is used to handle bitmasks, mainly for exclusions in the inner kernels. Note that it will return true even for -0.0f (sign bit set), so it is not identical to not-equal.

Parameters

a value

Returns: True if any bit in a is nonzero.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static bool gmx::testBits ( double a )

inlinestatic

Return true if any bits are set in the double variable.

This function is used to handle bitmasks, mainly for exclusions in the inner kernels. Note that it will return true even for -0.0 (sign bit set), so it is not identical to not-equal.

Parameters

a value

Returns: True if any bit in a is nonzero.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static bool gmx::testBits ( std::int32_t a )

inlinestatic

Return true if any bits are set in the integer variable.

This function is used to handle bitmasks, mainly for exclusions in the inner kernels.

Parameters

a value

Returns: True if any bit in a is nonzero.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static void gmx::threadMpiMdrunnerAccessBarrier ( )

static

Barrier for safe simultaneous thread access to mdrunner data.

Used to ensure that the main thread does not modify mdrunner during copy on the spawned threads.

bool gmx::timesClose	(	Time	time,
		Time	referenceTime
	)

inline

Check whether two times are nearly equal.

Times are considered close if their absolute difference is smaller than c_timePrecision.

Parameters

time	The test time
referenceTime	The reference time

Returns: bool Whether the absolute difference is < c_timePrecision

template<int align>

static void gmx::transposeScatterDecrU	(	float *	base,
		const std::int32_t	offset[],
		float	v0,
		float	v1,
		float	v2
	)

inlinestatic

Subtract 3 floats from base/offset.

Template Parameters

align Alignment of the memory to which we write, i.e. distance (measured in elements, not bytes) between index points.

Parameters

[out]	base	Pointer to the start of the memory area
	offset	Offset to the start of triplet.
	v0	1st value, subtracted from base[align*offset[0]].
	v1	2nd value, subtracted from base[align*offset[0] + 1].
	v2	3rd value, subtracted from base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::transposeScatterDecrU	(	double *	base,
		const std::int32_t	offset[],
		double	v0,
		double	v1,
		double	v2
	)

inlinestatic

Subtract 3 doubles from base/offset.

Template Parameters

align Alignment of the memory to which we write, i.e. distance (measured in elements, not bytes) between index points.

Parameters

[out]	base	Pointer to the start of the memory area
	offset	Offset to the start of triplet.
	v0	1st value, subtracted from base[align*offset[0]].
	v1	2nd value, subtracted from base[align*offset[0] + 1].
	v2	3rd value, subtracted from base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::transposeScatterIncrU	(	float *	base,
		const std::int32_t	offset[],
		float	v0,
		float	v1,
		float	v2
	)

inlinestatic

Add 3 floats to base/offset.

Template Parameters

align Alignment of the memory to which we write, i.e. distance (measured in elements, not bytes) between index points.

Parameters

[out]	base	Pointer to the start of the memory area
	offset	Offset to the start of triplet.
	v0	1st value, added to base[align*offset[0]].
	v1	2nd value, added to base[align*offset[0] + 1].
	v2	3rd value, added to base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::transposeScatterIncrU	(	double *	base,
		const std::int32_t	offset[],
		double	v0,
		double	v1,
		double	v2
	)

inlinestatic

Add 3 doubles to base/offset.

Template Parameters

align Alignment of the memory to which we write, i.e. distance (measured in elements, not bytes) between index points.

Parameters

[out]	base	Pointer to the start of the memory area
	offset	Offset to the start of triplet.
	v0	1st value, added to base[align*offset[0]].
	v1	2nd value, added to base[align*offset[0] + 1].
	v2	3rd value, added to base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::transposeScatterStoreU	(	float *	base,
		const std::int32_t	offset[],
		float	v0,
		float	v1,
		float	v2
	)

inlinestatic

Store 3 floats to 3 to base/offset.

Template Parameters

align Alignment of the memory to which we write, i.e. distance (measured in elements, not bytes) between index points.

Parameters

[out]	base	Pointer to the start of the memory area
	offset	Offset to the start of triplet.
	v0	1st value, written to base[align*offset[0]].
	v1	2nd value, written to base[align*offset[0] + 1].
	v2	3rd value, written to base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

template<int align>

static void gmx::transposeScatterStoreU	(	double *	base,
		const std::int32_t	offset[],
		double	v0,
		double	v1,
		double	v2
	)

inlinestatic

Store 3 doubles to 3 to base/offset.

Template Parameters

align Alignment of the memory to which we write, i.e. distance (measured in elements, not bytes) between index points.

Parameters

[out]	base	Pointer to the start of the memory area
	offset	Offset to the start of triplet.
	v0	1st value, written to base[align*offset[0]].
	v1	2nd value, written to base[align*offset[0] + 1].
	v2	3rd value, written to base[align*offset[0] + 2].

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static float gmx::trunc ( float a )

inlinestatic

Truncate float, i.e. round towards zero - common hardware instruction.

Parameters

a	Any floating-point value

Returns: Integer rounded towards zero, represented in floating-point format.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

static double gmx::trunc ( double a )

inlinestatic

Truncate double, i.e. round towards zero - common hardware instruction.

Parameters

a	Any doubleing-point value

Returns: Integer rounded towards zero, represented in doubleing-point format.

Note: This function might be superficially meaningless, but it helps us to write templated SIMD/non-SIMD code. For clarity it should not be used outside such code.

const char * gmx::unitCellTypeNames ( UnitCellType type )

Get names for the different unit cell representation types.

Parameters

[in] type What name needs to be provided.

template<bool accumulate>

static auto gmx::unpackRecvBufKernel	(	Float3 *__restrict__	gm_data,
		const Float3 *__restrict__	gm_dataPacked,
		const int *__restrict__	gm_map,
		int	mapSize
	)

static

unpack non-local force data buffer on the GPU using pre-populated "map" containing index information.

Parameters

[out]	gm_data	full array of force values
[in]	gm_dataPacked	packed array of force values to be transferred
[in]	gm_map	array of indices defining mapping from full to packed array
[in]	mapSize	number of elements in map array

void gmx::updateCorrelationGridHistory	(	CorrelationGridHistory *	corrGridHist,
		const CorrelationGrid &	corrGrid
	)

Update the correlation grid history for checkpointing.

Parameters

[in,out]	corrGridHist	Correlation grid history to set.
[in]	corrGrid	Correlation grid state to read.

static void gmx::updateGlobalState	(	t_state *	globalState,
		const PaddedHostVector< RVec > &	x,
		const PaddedHostVector< RVec > &	v,
		const tensor	box,
		int	ddpCount,
		int	ddpCountCgGl,
		const std::vector< int > &	cgGl
	)

static

Update the legacy global state.

When restoring from checkpoint, data will be distributed during domain decomposition at setup stage. Domain decomposition still uses the legacy global t_state object so make sure it's up-to-date.

static bool gmx::valueIsInGrid	(	const awh_dvec	value,
		ArrayRef< const GridAxis >	axis
	)

static

Query if a value is in range of the grid.

Parameters

[in]	value	Value to check.
[in]	axis	The grid axes.

Returns: true if the value is in the grid.

static bool gmx::valueIsInInterval	(	double	origin,
		double	end,
		double	period,
		double	value
	)

static

Checks if a value is within an interval.

Parameters

[in]	origin	Start value of interval.
[in]	end	End value of interval.
[in]	period	Period (or 0 if not periodic).
[in]	value	Value to check.

Returns: true if the value is within the interval.

static int gmx::vsiteIlistNrCount ( ArrayRef< const InteractionList > ilist )

static

Returns the sum of the vsite ilist sizes over all vsite types.

Parameters

[in] ilist The interaction list

void gmx::write_IMDgroup_to_file	(	bool	bIMD,
		t_inputrec *	ir,
		const t_state *	state,
		const gmx_mtop_t &	sys,
		int	nfile,
		const t_filenm	fnm[]
	)

Writes out the group of atoms selected for interactive manipulation.

Called by grompp. The resulting file has to be read in by VMD if one wants it to connect to mdrun.

Parameters

bIMD	Only springs into action if bIMD is TRUE. Otherwise returns directly.
ir	Structure containing MD input parameters, among those the IMD data structure.
state	The current state of the MD system.
sys	The global, complete system topology.
nfile	Number of files.
fnm	Filename struct.

void gmx::writeHeader	(	TextWriter *	writer,
		const std::string &	text,
		const std::string &	section,
		bool	writeFormattedText
	)

Write appropiate Header to output stream.

Parameters

[in]	writer	TextWriter object for writing information.
[in]	text	String with the header before writing.
[in]	section	String with section text for header.
[in]	writeFormattedText	If we need to format the text for LaTeX output or not

void gmx::writeInformation	(	TextOutputFile *	outputStream,
		const t_inputrec &	ir,
		const gmx_mtop_t &	top,
		bool	writeFormattedText,
		bool	notStdout
	)

Wrapper for writing out information.

This function is actual called from within the run method to write the information to the terminal or to file. New write out methods should be added to it instead of adding them in run.

Parameters

[in]	outputStream	The filestream used to write the information to.
[in]	ir	Reference to inputrec of the run input.
[in]	top	Local topology used to derive the information to write out.
[in]	writeFormattedText	Decide if we want formatted text output or not.
[in]	notStdout	Bool to see if we can close the file after writing or not in case of stdout.

void gmx::writeKeyValueTreeAsMdp	(	TextWriter *	writer,
		const KeyValueTreeObject &	tree
	)

Write a flat key-value tree to writer in mdp style.

Sub-objects will output nothing, so they can be used to contain a special key-value pair to create a comment, as well as the normal key and value. The comment pair will have a key of "comment", and the value will be used as a comment (if non-empty).

template<typename ValueType >

void gmx::writeKvtCheckpointValue	(	const ValueType &	value,
		const std::string &	name,
		const std::string &	identifier,
		KeyValueTreeObjectBuilder	kvtBuilder
	)

Write to a key-value-tree used for checkpointing.

Template Parameters

ValueType

Parameters

[in]	value	name of the value to be checkpointed
[in]	name	the value to be checkpointed
[in]	identifier	uniquely identifies the module that is checkpointing typically the module name
[in]	kvtBuilder	the key-value-tree builder used to store the checkpoint values

template void gmx::writeKvtCheckpointValue	(	const std::int64_t &	value,
		const std::string &	name,
		const std::string &	identifier,
		KeyValueTreeObjectBuilder	kvtBuilder
	)

Write to a key-value-tree used for checkpointing.

Template Parameters

ValueType

Parameters

[in]	value	name of the value to be checkpointed
[in]	name	the value to be checkpointed
[in]	identifier	uniquely identifies the module that is checkpointing typically the module name
[in]	kvtBuilder	the key-value-tree builder used to store the checkpoint values

template void gmx::writeKvtCheckpointValue	(	const real &	value,
		const std::string &	name,
		const std::string &	identifier,
		KeyValueTreeObjectBuilder	kvtBuilder
	)

Write to a key-value-tree used for checkpointing.

Template Parameters

ValueType

Parameters

[in]	value	name of the value to be checkpointed
[in]	name	the value to be checkpointed
[in]	identifier	uniquely identifies the module that is checkpointing typically the module name
[in]	kvtBuilder	the key-value-tree builder used to store the checkpoint values

void gmx::writeParameterInformation	(	TextWriter *	writer,
		const t_inputrec &	ir,
		bool	writeFormattedText
	)

Write information about system parameters.

This method writes the basic information for the system parameters and simulation settings as reported in the ir.

Parameters

[in]	writer	TextWriter object for writing information.
[in]	ir	Reference to inputrec of the run input.
[in]	writeFormattedText	Decide if we want formatted text output or not.

void gmx::writeSystemInformation	(	TextWriter *	writer,
		const gmx_mtop_t &	top,
		bool	writeFormattedText
	)

Write information about the molecules in the system.

This method should write all possible information about the molecular composition of the system.

Parameters

[in]	writer	TextWriter object for writing information.
[in]	top	Local topology used to derive the information to write out.
[in]	writeFormattedText	Decide if we want formatted text output or not.

Variable Documentation

constexpr Architecture gmx::c_architecture

static

Initial value:

=
        Architecture::Unknown

Constant that tells what the architecture is.

const EnumerationArray<ChangeAtomsType, const char*> gmx::c_changeAtomsTypeNames

static

Initial value:

= {
    { "preserved-if-present", "always-from-structure", "never", "always" }
}

Mapping for enums from ChangeAtomsType.

const EnumerationArray<ChangeSettingType, const char*> gmx::c_changeSettingTypeNames

static

Initial value:

= {
    { "preserved-if-present", "always", "never" }
}

Mapping for enums from ChangeSettingType.

const EnumerationArray<DensityFittingAmplitudeMethod, const char*> gmx::c_densityFittingAmplitudeMethodNames

static

Initial value:

= {
    { "unity", "mass", "charge" }
}

The names of the methods to determine the amplitude of the atoms to be spread on a grid.

const EnumerationArray<DensitySimilarityMeasureMethod, const char*> gmx::c_densitySimilarityMeasureMethodNames

static

Initial value:

= {
    { "inner-product", "relative-entropy", "cross-correlation" }
}

Name the methods that may be used to evaluate similarity between densities.

constexpr double gmx::c_epsilon0

Initial value:

=

((c_epsilon0Si * c_nano * c_kilo) / (c_electronCharge * c_electronCharge * c_avogadro))

constexpr int gmx::c_ftypeVsiteStart = F_VSITE1

static

The start value of the vsite indices in the ftype enum.

The validity of the start and end values is checked in makeVirtualSitesHandler(). This is used to avoid loops over all ftypes just to get the vsite entries. (We should replace the fixed ilist array by only the used entries.)

constexpr bool gmx::c_gpuBuildSyclWithoutGpuFft

Initial value:

=
        
        (GMX_GPU_SYCL != 0) && (GMX_GPU_FFT_MKL == 0) && (GMX_GPU_FFT_ROCFFT == 0)
        && (GMX_GPU_FFT_VKFFT == 0) && (GMX_GPU_FFT_BBFFT == 0)

const EnumerationArray<QMMMQMMethod, const char*> gmx::c_qmmmQMMethodNames

static

Initial value:

= {
    { "PBE", "BLYP", "INPUT" }
}

The names of the supported QM methods.

constexpr double gmx::c_speedOfLight

Initial value:

=

2.99792458e05

const gmx::EnumerationArray<XvgFormat, const char*> gmx::c_xvgFormatNames

Initial value:

= {
    { "xmgrace", "xmgr", "none" }
}

Names for XvgFormat.

Technically this duplicates a definition in pargs.cpp for legacy support code, but as the latter will go away and the alternatives are ugly, the duplication is acceptable.

constexpr std::array<int, numFTypesOnGpu> gmx::fTypesOnGpu

Initial value:

= { F_BONDS,  F_ANGLES, F_UREY_BRADLEY,
                                                          F_PDIHS,  F_RBDIHS, F_IDIHS,
                                                          F_PIDIHS, F_LJ14 }

List of all bonded function types supported on GPUs.

Note: This list should be in sync with the actual GPU code.; Perturbed interactions are not supported on GPUs.; The function types in the list are ordered on increasing value.; Currently bonded are only supported with CUDA and SYCL, not with OpenCL.

const char gmx::IMDstr[] = "IMD:"

static

Tag output from the IMD module with this string.

const gmx::EnumerationArray<MtsForceGroups, std::string> gmx::mtsForceGroupNames

static

Initial value:

= {
    "longrange-nonbonded", "nonbonded", "pair", "dihedral", "angle", "pull", "awh"
}

Names for the MTS force groups.

const std::vector<std::string> gmx::periodic_system

Initial value:

= {
    "X  ", "H  ", "He ", "Li ", "Be ", "B  ", "C  ", "N  ", "O  ", "F  ", "Ne ", "Na ",
    "Mg ", "Al ", "Si ", "P  ", "S  ", "Cl ", "Ar ", "K  ", "Ca ", "Sc ", "Ti ", "V  ",
    "Cr ", "Mn ", "Fe ", "Co ", "Ni ", "Cu ", "Zn ", "Ga ", "Ge ", "As ", "Se ", "Br ",
    "Kr ", "Rb ", "Sr ", "Y  ", "Zr ", "Nb ", "Mo ", "Tc ", "Ru ", "Rh ", "Pd ", "Ag ",
    "Cd ", "In ", "Sn ", "Sb ", "Te ", "I  ", "Xe ", "Cs ", "Ba ", "La ", "Ce ", "Pr ",
    "Nd ", "Pm ", "Sm ", "Eu ", "Gd ", "Tb ", "Dy ", "Ho ", "Er ", "Tm ", "Yb ", "Lu ",
    "Hf ", "Ta ", "W  ", "Re ", "Os ", "Ir ", "Pt ", "Au ", "Hg ", "Tl ", "Pb ", "Bi ",
    "Po ", "At ", "Rn ", "Fr ", "Ra ", "Ac ", "Th ", "Pa ", "U  ", "Np ", "Pu ", "Am ",
    "Cm ", "Bk ", "Cf ", "Es ", "Fm ", "Md ", "No ", "Lr ", "Rf ", "Db ", "Sg ", "Bh ",
    "Hs ", "Mt ", "Ds ", "Rg ", "Cn ", "Nh ", "Fl ", "Mc ", "Lv ", "Ts ", "Og "
}

symbols of the elements in periodic table

const EnumerationArray<IncompatibilityReasons, std::string> gmx::reasonStrings

static

Initial value:

= {
    "flexible constraints are present",
    "an incompatible virtual site type is used",
    "the construction atoms of a virtual site are only partly with a group of constrained atoms",
    "atoms that are (in)directly constrained together are interdispersed with other atoms",
    "there are three or more consecutively coupled constraints"
}

Strings explaining why the system is incompatible with update groups.

constexpr int64_t gmx::sc_atomInfo_FreeEnergyPerturbation = 1 << 15

static

Constants whose bit describes a property of an atom in AtomInfoWithinMoleculeBlock.atomInfo.

No bit should exceed 1 << 63, so that it fits into a 64-bit integer.

Since the tpx format support max 256 energy groups, we do the same here, reserving bits 0-7 for the energy-group ID.

Description

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation