Gromacs  2022.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Enumerations | Functions
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)

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]indexThe index in the array
[in]max_indexThe length of the array
[in]namesThe array
Returns
the correct string or "no name defined"