md_enums.h File Reference

This graph shows which files directly or indirectly include this file:

Description

Declares enumerated types used throughout the code.

Author

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

Macros
#define	ETC_ANDERSEN(e)   (((e) == TemperatureCoupling::AndersenMassive) || ((e) == TemperatureCoupling::Andersen))
	Return whether this is andersen coupling.
#define	EEL_RF(e)
	Macro telling us whether we use reaction field. More...
#define	EEL_PME(e)
	Macro telling us whether we use PME. More...
#define	EEL_PME_EWALD(e)   (EEL_PME(e) || (e) == CoulombInteractionType::Ewald)
	Macro telling us whether we use PME or full Ewald.
#define	EEL_FULL(e)   (EEL_PME_EWALD(e) || (e) == CoulombInteractionType::Poisson)
	Macro telling us whether we use full electrostatics of any sort.
#define	EEL_USER(e)
	Macro telling us whether we use user defined electrostatics. More...
#define	EVDW_PME(e)   ((e) == VanDerWaalsType::Pme)
	Macro to tell us whether we use LJPME.
#define	EI_MIMIC(e)   ((e) == IntegrationAlgorithm::Mimic)
	Do we use MiMiC QM/MM?
#define	EI_VV(e)   ((e) == IntegrationAlgorithm::VV || (e) == IntegrationAlgorithm::VVAK)
	Do we use velocity Verlet.
#define	EI_MD(e)   ((e) == IntegrationAlgorithm::MD || EI_VV(e) || EI_MIMIC(e))
	Do we use molecular dynamics.
#define	EI_SD(e)   ((e) == IntegrationAlgorithm::SD1)
	Do we use stochastic dynamics.
#define	EI_RANDOM(e)   (EI_SD(e) || (e) == IntegrationAlgorithm::BD)
	Do we use any stochastic integrator.
#define	EI_DYNAMICS(e)   (EI_MD(e) || EI_RANDOM(e))
	Do we use any type of dynamics.
#define	EI_ENERGY_MINIMIZATION(e)
	Or do we use minimization. More...
#define	EI_TPI(e)   ((e) == IntegrationAlgorithm::TPI || (e) == IntegrationAlgorithm::TPIC)
	Do we apply test particle insertion.
#define	EI_STATE_VELOCITY(e)   (EI_MD(e) || EI_SD(e))
	Do we deal with particle velocities.
#define	ELAMSTATS_EXPANDED(e)   ((e) > LambdaWeightCalculation::No)
	Macro telling us whether we use expanded ensemble.
#define	EWL(e)   ((e) == LambdaWeightCalculation::WL || (e) == LambdaWeightCalculation::WWL)
	Macro telling us whether we use some kind of Wang-Landau.

Enumerations
enum	Boolean : int { No, Yes, Count, Default = No }
	Enum for setting answer to yes or no.
enum	Compartment : int { A, B, Count }
	The two compartments for CompEL setups.
enum	Channel : int { Zero, One, Count }
	The channels that define with their COM the compartment boundaries in CompEL setups. More...
enum	TemperatureCoupling : int {   No, Berendsen, NoseHoover, Yes,   Andersen, AndersenMassive, VRescale, Count,   Default = No }
	Temperature coupling type. More...
enum	PressureCoupling : int {   No, Berendsen, ParrinelloRahman, Isotropic,   Mttk, CRescale, Count, Default = No }
	Pressure coupling types. More...
enum	{   efbposresZERO, efbposresSPHERE, efbposresCYLINDER, efbposresX,   efbposresY, efbposresZ, efbposresCYLINDERX, efbposresCYLINDERY,   efbposresCYLINDERZ, efbposresNR }
	Flat-bottom posres geometries.
enum	RefCoordScaling : int {   No, All, Com, Count,   Default = No }
	Relative coordinate scaling type for position restraints.
enum	{   etrtNONE, etrtNHC, etrtBAROV, etrtBARONHC,   etrtNHC2, etrtBAROV2, etrtBARONHC2, etrtVELOCITY1,   etrtVELOCITY2, etrtPOSITION, etrtSKIPALL, etrtNR }
	Trotter decomposition extended variable parts.
enum	TrotterSequence : int {   Zero, One, Two, Three,   Four, Count }
	Sequenced parts of the trotter decomposition.
enum	PressureCouplingType : int {   Isotropic, SemiIsotropic, Anisotropic, SurfaceTension,   Count, Default = Isotropic }
	Pressure coupling type.
enum	CutoffScheme : int { Verlet, Group, Count, Default = Verlet }
	\brief Cutoff scheme
enum	InteractionModifiers : int {   PotShiftVerletUnsupported, PotShift, None, PotSwitch,   ExactCutoff, ForceSwitch, Count, Default = PotShiftVerletUnsupported }
	Coulomb / VdW interaction modifiers. More...
enum	CoulombInteractionType : int {   Cut, RF, GRFNotused, Pme,   Ewald, P3mAD, Poisson, Switch,   Shift, User, GBNotused, RFNecUnsupported,   EncadShiftNotused, PmeUser, PmeSwitch, PmeUserSwitch,   RFZero, Count, Default = Cut }
	Cut-off treatment for Coulomb.
enum	EwaldGeometry : int { ThreeD, ThreeDC, Count, Default = ThreeD }
	Ewald geometry.
enum	VanDerWaalsType : int {   Cut, Switch, Shift, User,   EncadShiftUnused, Pme, Count, Default = Cut }
	Van der Waals interaction treatment.
enum	LongRangeVdW : int { Geom, LB, Count, Default = Geom }
	Type of long-range VdW treatment of combination rules.
enum	IntegrationAlgorithm : int {   MD, Steep, CG, BD,   SD2Removed, NM, LBFGS, TPI,   TPIC, SD1, VV, VVAK,   Mimic, Count, Default = MD }
	Integrator algorithm. More...
enum	ConstraintAlgorithm : int { Lincs, Shake, Count, Default = Lincs }
	Constraint algorithm.
enum	DistanceRestraintRefinement : int {   None, Simple, Ensemble, Count,   Default = None }
	Distance restraint refinement algorithm.
enum	DistanceRestraintWeighting : int { Conservative, Equal, Count, Default = Conservative }
	Distance restraints weighting type.
enum	CombinationRule : int {   None, Geometric, Arithmetic, GeomSigEps,   Count, Default = Geometric }
	Combination rule algorithm.
enum	VanDerWaalsPotential : int {   None, LJ, Buckingham, Count,   Default = LJ }
	Van der Waals potential.
enum	SimulatedTempering : int {   Geometric, Exponential, Linear, Count,   Default = Geometric }
	Simulated tempering methods.
enum	FreeEnergyPerturbationType : int {   FreeEnergyPerturbationType::No, FreeEnergyPerturbationType::Yes, FreeEnergyPerturbationType::Static, FreeEnergyPerturbationType::SlowGrowth,   FreeEnergyPerturbationType::Expanded, Count, Default = No }
	Free energy perturbation type. More...
enum	FreeEnergyPerturbationCouplingType : int {   Fep, Mass, Coul, Vdw,   Bonded, Restraint, Temperature, Count,   Default = Fep }
	Free energy perturbation coupling types.
enum	FreeEnergyPrintEnergy : int {   No, Total, Potential, Yes,   Count, Default = No }
	What to print for free energy calculations. More...
enum	LambdaWeightCalculation : int {   LambdaWeightCalculation::No, LambdaWeightCalculation::Metropolis, LambdaWeightCalculation::Barker, LambdaWeightCalculation::Minvar,   LambdaWeightCalculation::WL, LambdaWeightCalculation::WWL, Count, Default = No }
	How the lambda weights are calculated. More...
enum	LambdaMoveCalculation : int {   LambdaMoveCalculation::No, LambdaMoveCalculation::Metropolis, LambdaMoveCalculation::Barker, LambdaMoveCalculation::Gibbs,   LambdaMoveCalculation::MetropolisGibbs, Count, Default = No }
	How moves in lambda are calculated. More...
enum	LambdaWeightWillReachEquilibrium : int {   LambdaWeightWillReachEquilibrium::No, LambdaWeightWillReachEquilibrium::Yes, LambdaWeightWillReachEquilibrium::WLDelta, LambdaWeightWillReachEquilibrium::NumAtLambda,   LambdaWeightWillReachEquilibrium::Steps, LambdaWeightWillReachEquilibrium::Samples, LambdaWeightWillReachEquilibrium::Ratio, Count,   Default = No }
	How we decide whether weights have reached equilibrium. More...
enum	SeparateDhdlFile : int { Yes, No, Count, Default = Yes }
	separate_dhdl_file selection More...
enum	DhDlDerivativeCalculation : int { Yes, No, Count, Default = Yes }
	dhdl_derivatives selection \ More...
enum	SoftcoreType : int { Beutler, Gapsys, Count, Default = Beutler }
	soft-core function \ More...
enum	KernelSoftcoreType : int {   Beutler, Gapsys, None, Count,   Default = Beutler }
	soft-core function as parameter to the nb-fep kernel/14-interaction.\ More...
enum	SolventModel : int {   No, Spc, Tip4p, Count,   Default = Spc }
	Solvent model. More...
enum	DispersionCorrectionType : int {   No, EnerPres, Ener, AllEnerPres,   AllEner, Count, Default = No }
	Dispersion correction.
enum	SimulatedAnnealing : int {   No, Single, Periodic, Count,   Default = No }
	Algorithm for simulated annealing.
enum	WallType : int {   NineThree, TenFour, Table, TwelveSix,   Count, Default = NineThree }
	Wall types.
enum	PullingAlgorithm : int {   Umbrella, Constraint, ConstantForce, FlatBottom,   FlatBottomHigh, External, Count, Default = Umbrella }
	Pulling algorithm.
enum	PullGroupGeometry : int {   Distance, Direction, Cylinder, DirectionPBC,   DirectionRelative, Angle, Dihedral, AngleAxis,   Transformation, Count, Default = Distance }
	Control of pull groups.
enum	EnforcedRotationGroupType : int {   Iso, Isopf, Pm, Pmpf,   Rm, Rmpf, Rm2, Rm2pf,   Flex, Flext, Flex2, Flex2t,   Count, Default = Iso }
	Enforced rotation groups.
enum	RotationGroupFitting : int {   Rmsd, Norm, Pot, Count,   Default = Rmsd }
	Rotation group fitting type.
enum	SwapType : int {   No, X, Y, Z,   Count, Default = No }
	Direction along which ion/water swaps happen. More...
enum	SwapGroupSplittingType : int {   Split0, Split1, Solvent, Count,   Default = Solvent }
	Swap group splitting type. More...
enum	NbkernelElecType : int {   None, Coulomb, ReactionField, CubicSplineTable,   Ewald, Count, Default = None }
	Types of electrostatics calculations. More...
enum	NbkernelVdwType : int {   None, LennardJones, Buckingham, CubicSplineTable,   LJEwald, Count, Default = None }
	Types of vdw calculations available. More...
enum	ComRemovalAlgorithm : int {   Linear, Angular, No, LinearAccelerationCorrection,   Count, Default = Linear }
	Center of mass motion removal algorithm.
enum	PbcType : int {   PbcType::Xyz = 0, PbcType::No = 1, PbcType::XY = 2, PbcType::Screw = 3,   PbcType::Unset = 4, Count = 5, Default = Xyz }
	Enumeration that contains all supported periodic boundary setups. More...

Functions
const char *	enum_name (int index, int max_index, const char *const names[])
	Return a string from a list of strings. More...
const char *	enumValueToString (Boolean enumValue)
	Return name of boolean selection.
const char *	booleanValueToString (bool value)
	Return name of boolean selection for actual bool.
const char *	enumValueToString (TemperatureCoupling enumValue)
	Return names of temperature coupling schemes.
const char *	enumValueToString (PressureCoupling enumValue)
	Return names of pressure coupling schemes.
const char *	enumValueToString (RefCoordScaling enumValue)
	String corresponding to relative coordinate scaling.
const char *	enumValueToString (PressureCouplingType enumValue)
	String corresponding to pressure coupling type.
const char *	enumValueToString (CutoffScheme enumValue)
	String corresponding to cutoff scheme.
const char *	enumValueToString (InteractionModifiers enumValue)
	String corresponding to interaction modifiers.
const char *	enumValueToString (CoulombInteractionType enumValue)
	String corresponding to Coulomb treatment.
const char *	enumValueToString (EwaldGeometry enumValue)
	String corresponding to Ewald geometry.
const char *	enumValueToString (VanDerWaalsType enumValue)
	String corresponding to Van der Waals treatment.
const char *	enumValueToString (LongRangeVdW enumValue)
	String for LJPME combination rule treatment.
const char *	enumValueToString (IntegrationAlgorithm enumValue)
	Name of the integrator algorithm.
const char *	enumValueToString (ConstraintAlgorithm enumValue)
	String corresponding to constraint algorithm.
const char *	enumValueToString (DistanceRestraintRefinement enumValue)
	String corresponding to distance restraint algorithm.
const char *	enumValueToString (DistanceRestraintWeighting enumValue)
	String corresponding to distance restraint weighting.
const char *	enumValueToString (CombinationRule enumValue)
	String for combination rule algorithm.
const char *	enumValueToString (VanDerWaalsPotential enumValue)
	String corresponding to Van der Waals potential.
const char *	enumValueToString (SimulatedTempering enumValue)
	String corresponding to simulated tempering.
const char *	enumValueToString (FreeEnergyPerturbationType enumValue)
	String corresponding to FEP type.
const char *	enumValueToString (FreeEnergyPerturbationCouplingType enumValue)
	String for FEP coupling type.
const char *	enumValueToStringSingular (FreeEnergyPerturbationCouplingType enumValue)
	String for FEP coupling type, singular mention.
const char *	enumValueToString (FreeEnergyPrintEnergy enumValue)
	String corresponding to printing of free energy.
const char *	enumValueToString (LambdaWeightCalculation enumValue)
	String corresponding to lambda weights.
const char *	enumValueToString (LambdaMoveCalculation enumValue)
	String corresponding to lambda moves.
const char *	enumValueToString (LambdaWeightWillReachEquilibrium enumValue)
	String corresponding to equilibrium algorithm.
const char *	enumValueToString (SeparateDhdlFile enumValue)
	String corresponding to separate DHDL file selection.
const char *	enumValueToString (DhDlDerivativeCalculation enumValue)
	String for DHDL derivatives.
const char *	enumValueToString (SoftcoreType enumValue)
	Strings for softcore function names.
const char *	enumValueToString (KernelSoftcoreType enumValue)
	Strings for softcore function names.
const char *	enumValueToString (SolventModel enumValue)
	String corresponding to solvent type.
const char *	enumValueToString (DispersionCorrectionType enumValue)
	String corresponding to dispersion corrections.
const char *	enumValueToString (SimulatedAnnealing enumValue)
	String for simulated annealing.
const char *	enumValueToString (WallType enumValue)
	String corresponding to wall type.
const char *	enumValueToString (PullingAlgorithm enumValue)
	String for pulling algorithm.
const char *	enumValueToString (PullGroupGeometry enumValue)
	String for pull groups.
const char *	enumValueToString (EnforcedRotationGroupType enumValue)
	Rotation group names.
const char *	enumValueToLongString (EnforcedRotationGroupType enumValue)
	String for rotation group origin names.
const char *	enumValueToString (RotationGroupFitting enumValue)
	String corresponding to rotation group fitting.
const char *	enumValueToString (SwapType enumValue)
	Names for swapping.
const char *	enumValueToString (SwapGroupSplittingType enumValue)
	String for swap group splitting.
const char *	enumValueToString (NbkernelElecType enumValue)
	String corresponding to electrostatics kernels.
const char *	enumValueToString (NbkernelVdwType enumValue)
	String corresponding to VdW kernels.
const char *	enumValueToString (ComRemovalAlgorithm enumValue)
	String corresponding to COM removal.

Macro Definition Documentation

#define EEL_PME

(

e

)

Value:

((e) == CoulombInteractionType::Pme || (e) == CoulombInteractionType::PmeSwitch            \
     || (e) == CoulombInteractionType::PmeUser || (e) == CoulombInteractionType::PmeUserSwitch \
     || (e) == CoulombInteractionType::P3mAD)

Macro telling us whether we use PME.

#define EEL_RF

(

e

)

Value:

((e) == CoulombInteractionType::RF || (e) == CoulombInteractionType::GRFNotused \
     || (e) == CoulombInteractionType::RFNecUnsupported || (e) == CoulombInteractionType::RFZero)

Macro telling us whether we use reaction field.

#define EEL_USER

(

e

)

Value:

((e) == CoulombInteractionType::User || (e) == CoulombInteractionType::PmeUser \
     || (e) == (CoulombInteractionType::PmeUserSwitch))

Macro telling us whether we use user defined electrostatics.

#define EI_ENERGY_MINIMIZATION

(

e

)

Value:

((e) == IntegrationAlgorithm::Steep || (e) == IntegrationAlgorithm::CG \
     || (e) == IntegrationAlgorithm::LBFGS)

Or do we use minimization.

Enumeration Type Documentation

enum Channel : int

strong

The channels that define with their COM the compartment boundaries in CompEL setups.

In principle one could also use modified setups with more than two channels.

enum DhDlDerivativeCalculation : int

strong

dhdl_derivatives selection \

NOTE: YES is the first one. Do NOT interpret this one as a gmx_bool Why was this done this way, just .........

enum FreeEnergyPerturbationType : int

strong

Free energy perturbation type.

Enumerator
No	there are no evaluations at other states
Yes	treated equivalently to Static
Static	then lambdas do not change during the simulation
SlowGrowth	then the states change monotonically throughout the simulation
Expanded	then expanded ensemble simulations are occurring

enum FreeEnergyPrintEnergy : int

strong

What to print for free energy calculations.

Printing the energy to the free energy dhdl file. Yes is an alias to Total, and will be converted in readir, so we never have to account for it in code.

enum IntegrationAlgorithm : int

strong

Integrator algorithm.

eiSD2 has been removed, but we keep a renamed enum entry, so we can refuse to do MD with such .tpr files. eiVV is normal velocity verlet eiVVAK uses 1/2*(KE(t-dt/2)+KE(t+dt/2)) as the kinetic energy, and the half step kinetic energy for temperature control

enum InteractionModifiers : int

strong

Coulomb / VdW interaction modifiers.

grompp replaces eintmodPOTSHIFT_VERLET_UNSUPPORTED by eintmodPOTSHIFT. Exactcutoff is only used by Reaction-field-zero, and is not user-selectable.

enum KernelSoftcoreType : int

strong

soft-core function as parameter to the nb-fep kernel/14-interaction.\

Distinguishes between soft-core functions internally. This is different from SoftcoreType in that it offers 'None' which is not exposed to the user.

enum LambdaMoveCalculation : int

strong

How moves in lambda are calculated.

Enumerator
No	don't calculate move
Metropolis	using the Metropolis criteria, and 50% up and down
Barker	using the Barker criteria, and 50% up and down
Gibbs	computing the transition using the marginalized probabilities of the lambdas
MetropolisGibbs	using the metropolized version of Gibbs Monte Carlo Strategies in Scientific computing, Liu, p. 134

enum LambdaWeightCalculation : int

strong

How the lambda weights are calculated.

Enumerator
No	don't calculate
Metropolis	using the metropolis criteria
Barker	using the Barker critera for transition weights, also called unoptimized Bennett
Minvar	using Barker + minimum variance for weights
WL	Wang-Landu (using visitation counts)
WWL	Weighted Wang-Landau (using optimized Gibbs weighted visitation counts)

enum LambdaWeightWillReachEquilibrium : int

strong

How we decide whether weights have reached equilibrium.

Enumerator
No	never stop, weights keep going
Yes	fix the weights from the beginning; no movement
WLDelta	stop when the WL-delta falls below a certain level
NumAtLambda	stop when we have a certain number of samples at every step
Steps	stop when we've run a certain total number of steps
Samples	stop when we've run a certain total number of samples
Ratio	stop when the ratio of samples (lowest to highest) is sufficiently large

enum NbkernelElecType : int

strong

Types of electrostatics calculations.

Types of electrostatics calculations available inside nonbonded kernels. Note that these do NOT necessarily correspond to the user selections in the MDP file; many interactions for instance map to tabulated kernels.

enum NbkernelVdwType : int

strong

Types of vdw calculations available.

Types of vdw calculations available inside nonbonded kernels. Note that these do NOT necessarily correspond to the user selections in the MDP file; many interactions for instance map to tabulated kernels.

enum PbcType : int

strong

Enumeration that contains all supported periodic boundary setups.

Enumerator
Xyz	Periodic boundaries in all dimensions.
No	No periodic boundaries.
XY	Only two dimensions are periodic.
Screw	Screw.
Unset	The type of PBC is not set or invalid.

enum PressureCoupling : int

strong

Pressure coupling types.

isotropic is an alias for berendsen

Note: Keep Count as the second-to-last entry, and Default as the last entry - this is needed to keep EnumerationWrapper, EnumerationArray and (de)serialization working.

enum SeparateDhdlFile : int

strong

separate_dhdl_file selection

NOTE: YES is the first one. Do NOT interpret this one as a gmx_bool Why was this done this way, just .........

enum SoftcoreType : int

strong

soft-core function \

Distinguishes between soft-core functions in the input.

enum SolventModel : int

strong

Solvent model.

Distinguishes classical water types with 3 or 4 particles

enum SwapGroupSplittingType : int

strong

Swap group splitting type.

These are just the fixed groups we need for any setup. In t_swap's grp entry after that follows the variable number of swap groups.

enum SwapType : int

strong

Direction along which ion/water swaps happen.

Part of "Computational Electrophysiology" (CompEL) setups

enum TemperatureCoupling : int

strong

Temperature coupling type.

yes is an alias for berendsen

Note: Keep Count as the second-to-last entry, and Default as the last entry - this is needed to keep EnumerationWrapper, EnumerationArray and (de)serialization working.

Function Documentation

const char* enum_name	(	int	index,
		int	max_index,
		const char *const	names[]
	)

Return a string from a list of strings.

If index if within 0 .. max_index-1 returns the corresponding string or "no name defined" otherwise, in other words this is a range-check that does not crash.

Parameters

[in]	index	The index in the array
[in]	max_index	The length of the array
[in]	names	The array

Returns

the correct string or "no name defined"