src/gromacs/mdtypes/md_enums.h

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
   5  * Copyright (c) 2001-2004, The GROMACS development team.
   6  * Copyright (c) 2013,2014,2015,2016,2017 by the GROMACS development team.
   7  * Copyright (c) 2018,2019,2020,2021, by the GROMACS development team, led by
   8  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   9  * and including many others, as listed in the AUTHORS file in the
  10  * top-level source directory and at http://www.gromacs.org.
  11  *
  12  * GROMACS is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public License
  14  * as published by the Free Software Foundation; either version 2.1
  15  * of the License, or (at your option) any later version.
  16  *
  17  * GROMACS is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with GROMACS; if not, see
  24  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  25  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  26  *
  27  * If you want to redistribute modifications to GROMACS, please
  28  * consider that scientific software is very special. Version
  29  * control is crucial - bugs must be traceable. We will be happy to
  30  * consider code for inclusion in the official distribution, but
  31  * derived work must not be called official GROMACS. Details are found
  32  * in the README & COPYING files - if they are missing, get the
  33  * official version at http://www.gromacs.org.
  34  *
  35  * To help us fund GROMACS development, we humbly ask that you cite
  36  * the research papers on the package. Check out http://www.gromacs.org.
  37  */
  38 /*! \file
  39  * \brief
  40  * Declares enumerated types used throughout the code.
  41  *
  42  * \author David van der Spoel <david.vanderspoel@icm.uu.se>
  43  * \inpublicapi
  44  * \ingroup module_mdtypes
  45  */
  46 #ifndef GMX_MDTYPES_MD_ENUMS_H
  47 #define GMX_MDTYPES_MD_ENUMS_H
  48
  49 #include "gromacs/utility/basedefinitions.h"
  50
  51 /*! \brief Return a string from a list of strings
  52  *
  53  * If index if within 0 .. max_index-1 returns the corresponding string
  54  * or "no name defined" otherwise, in other words this is a range-check that does
  55  * not crash.
  56  * \param[in] index     The index in the array
  57  * \param[in] max_index The length of the array
  58  * \param[in] names     The array
  59  * \return the correct string or "no name defined"
  60  */
  61 const char* enum_name(int index, int max_index, const char* const names[]);
  62
  63 /*! \brief Enum for setting answer to yes or no
  64  */
  65 enum class Boolean : int
  66 {
  67     No,
  68     Yes,
  69     Count,
  70     Default = No
  71 };
  72
  73 //! Return name of boolean selection.
  74 const char* enumValueToString(Boolean enumValue);
  75 //! Return name of boolean selection for actual bool.
  76 const char* booleanValueToString(bool value);
  77
  78 //! \brief The two compartments for CompEL setups.
  79 enum eCompartment
  80 {
  81     eCompA,
  82     eCompB,
  83     eCompNR
  84 };
  85
  86 /*! \brief The channels that define with their COM the compartment boundaries in CompEL setups.
  87  *
  88  * In principle one could also use modified setups with more than two channels.
  89  */
  90 enum eChannel
  91 {
  92     eChan0,
  93     eChan1,
  94     eChanNR
  95 };
  96
  97 /*! \brief Temperature coupling type
  98  *
  99  * yes is an alias for berendsen
 100  *
 101  * Note: Keep `Count` as the second-to-last entry, and `Default` as the last entry -
 102  *       this is needed to keep EnumerationWrapper, EnumerationArray and (de)serialization
 103  *       working.
 104  */
 105 enum class TemperatureCoupling : int
 106 {
 107     No,
 108     Berendsen,
 109     NoseHoover,
 110     Yes,
 111     Andersen,
 112     AndersenMassive,
 113     VRescale,
 114     Count,
 115     Default = No
 116 };
 117 //! Return names of temperature coupling schemes
 118 const char* enumValueToString(TemperatureCoupling enumValue);
 119 //! Return whether this is andersen coupling
 120 #define ETC_ANDERSEN(e) \
 121     (((e) == TemperatureCoupling::AndersenMassive) || ((e) == TemperatureCoupling::Andersen))
 122
 123 /*! \brief Pressure coupling types
 124  *
 125  * isotropic is an alias for berendsen
 126  *
 127  * Note: Keep `Count` as the second-to-last entry, and `Default` as the last entry -
 128  *       this is needed to keep EnumerationWrapper, EnumerationArray and (de)serialization
 129  *       working.
 130  */
 131 enum class PressureCoupling : int
 132 {
 133     No,
 134     Berendsen,
 135     ParrinelloRahman,
 136     Isotropic,
 137     Mttk,
 138     CRescale,
 139     Count,
 140     Default = No
 141 };
 142 //! Return names of pressure coupling schemes
 143 const char* enumValueToString(PressureCoupling enumValue);
 144
 145 //! Flat-bottom posres geometries
 146 enum
 147 {
 148     efbposresZERO,
 149     efbposresSPHERE,
 150     efbposresCYLINDER,
 151     efbposresX,
 152     efbposresY,
 153     efbposresZ,
 154     efbposresCYLINDERX,
 155     efbposresCYLINDERY,
 156     efbposresCYLINDERZ,
 157     efbposresNR
 158 };
 159
 160 //! Relative coordinate scaling type for position restraints.
 161 enum class RefCoordScaling : int
 162 {
 163     No,
 164     All,
 165     Com,
 166     Count,
 167     Default = No
 168 };
 169
 170 //! String corresponding to relative coordinate scaling.
 171 const char* enumValueToString(RefCoordScaling enumValue);
 172
 173 //! Trotter decomposition extended variable parts.
 174 enum
 175 {
 176     etrtNONE,
 177     etrtNHC,
 178     etrtBAROV,
 179     etrtBARONHC,
 180     etrtNHC2,
 181     etrtBAROV2,
 182     etrtBARONHC2,
 183     etrtVELOCITY1,
 184     etrtVELOCITY2,
 185     etrtPOSITION,
 186     etrtSKIPALL,
 187     etrtNR
 188 };
 189
 190 //! Sequenced parts of the trotter decomposition.
 191 enum
 192 {
 193     ettTSEQ0,
 194     ettTSEQ1,
 195     ettTSEQ2,
 196     ettTSEQ3,
 197     ettTSEQ4,
 198     ettTSEQMAX
 199 };
 200
 201 //! Pressure coupling type
 202 enum class PressureCouplingType : int
 203 {
 204     Isotropic,
 205     SemiIsotropic,
 206     Anisotropic,
 207     SurfaceTension,
 208     Count,
 209     Default = Isotropic
 210 };
 211 //! String corresponding to pressure coupling type
 212 const char* enumValueToString(PressureCouplingType enumValue);
 213
 214 //! \\brief Cutoff scheme
 215 enum class CutoffScheme : int
 216 {
 217     Verlet,
 218     Group,
 219     Count,
 220     Default = Verlet
 221 };
 222 //! String corresponding to cutoff scheme
 223 const char* enumValueToString(CutoffScheme enumValue);
 224
 225 /*! \brief Coulomb / VdW interaction modifiers.
 226  *
 227  * grompp replaces eintmodPOTSHIFT_VERLET_UNSUPPORTED by eintmodPOTSHIFT.
 228  * Exactcutoff is only used by Reaction-field-zero, and is not user-selectable.
 229  */
 230 enum class InteractionModifiers : int
 231 {
 232     PotShiftVerletUnsupported,
 233     PotShift,
 234     None,
 235     PotSwitch,
 236     ExactCutoff,
 237     ForceSwitch,
 238     Count,
 239     Default = PotShiftVerletUnsupported
 240 };
 241 //! String corresponding to interaction modifiers
 242 const char* enumValueToString(InteractionModifiers enumValue);
 243
 244 /*! \brief Cut-off treatment for Coulomb */
 245 enum class CoulombInteractionType : int
 246 {
 247     Cut,
 248     RF,
 249     GRFNotused,
 250     Pme,
 251     Ewald,
 252     P3mAD,
 253     Poisson,
 254     Switch,
 255     Shift,
 256     User,
 257     GBNotused,
 258     RFNecUnsupported,
 259     EncadShiftNotused,
 260     PmeUser,
 261     PmeSwitch,
 262     PmeUserSwitch,
 263     RFZero,
 264     Count,
 265     Default = Cut
 266 };
 267 //! String corresponding to Coulomb treatment
 268 const char* enumValueToString(CoulombInteractionType enumValue);
 269
 270 //! Ewald geometry.
 271 enum class EwaldGeometry : int
 272 {
 273     ThreeD,
 274     ThreeDC,
 275     Count,
 276     Default = ThreeD
 277 };
 278 //! String corresponding to Ewald geometry
 279 const char* enumValueToString(EwaldGeometry enumValue);
 280
 281 //! Macro telling us whether we use reaction field
 282 #define EEL_RF(e)                                                                   \
 283     ((e) == CoulombInteractionType::RF || (e) == CoulombInteractionType::GRFNotused \
 284      || (e) == CoulombInteractionType::RFNecUnsupported || (e) == CoulombInteractionType::RFZero)
 285
 286 //! Macro telling us whether we use PME
 287 #define EEL_PME(e)                                                                             \
 288     ((e) == CoulombInteractionType::Pme || (e) == CoulombInteractionType::PmeSwitch            \
 289      || (e) == CoulombInteractionType::PmeUser || (e) == CoulombInteractionType::PmeUserSwitch \
 290      || (e) == CoulombInteractionType::P3mAD)
 291 //! Macro telling us whether we use PME or full Ewald
 292 #define EEL_PME_EWALD(e) (EEL_PME(e) || (e) == CoulombInteractionType::Ewald)
 293 //! Macro telling us whether we use full electrostatics of any sort
 294 #define EEL_FULL(e) (EEL_PME_EWALD(e) || (e) == CoulombInteractionType::Poisson)
 295 //! Macro telling us whether we use user defined electrostatics
 296 #define EEL_USER(e)                                                                \
 297     ((e) == CoulombInteractionType::User || (e) == CoulombInteractionType::PmeUser \
 298      || (e) == (CoulombInteractionType::PmeUserSwitch))
 299
 300 //! Van der Waals interaction treatment
 301 enum class VanDerWaalsType : int
 302 {
 303     Cut,
 304     Switch,
 305     Shift,
 306     User,
 307     EncadShiftUnused,
 308     Pme,
 309     Count,
 310     Default = Cut
 311 };
 312 //! String corresponding to Van der Waals treatment
 313 const char* enumValueToString(VanDerWaalsType enumValue);
 314
 315 //! Type of long-range VdW treatment of combination rules
 316 enum class LongRangeVdW : int
 317 {
 318     Geom,
 319     LB,
 320     Count,
 321     Default = Geom
 322 };
 323 //! String for LJPME combination rule treatment
 324 const char* enumValueToString(LongRangeVdW enumValue);
 325
 326 //! Macro to tell us whether we use LJPME
 327 #define EVDW_PME(e) ((e) == VanDerWaalsType::Pme)
 328
 329 /*! \brief Integrator algorithm
 330  *
 331  * eiSD2 has been removed, but we keep a renamed enum entry,
 332  * so we can refuse to do MD with such .tpr files.
 333  * eiVV is normal velocity verlet
 334  * eiVVAK uses 1/2*(KE(t-dt/2)+KE(t+dt/2)) as the kinetic energy,
 335  * and the half step kinetic energy for temperature control
 336  */
 337 enum class IntegrationAlgorithm : int
 338 {
 339     MD,
 340     Steep,
 341     CG,
 342     BD,
 343     SD2Removed,
 344     NM,
 345     LBFGS,
 346     TPI,
 347     TPIC,
 348     SD1,
 349     VV,
 350     VVAK,
 351     Mimic,
 352     Count,
 353     Default = MD
 354 };
 355 //! Name of the integrator algorithm
 356 const char* enumValueToString(IntegrationAlgorithm enumValue);
 357 //! Do we use MiMiC QM/MM?
 358 #define EI_MIMIC(e) ((e) == IntegrationAlgorithm::Mimic)
 359 //! Do we use velocity Verlet
 360 #define EI_VV(e) ((e) == IntegrationAlgorithm::VV || (e) == IntegrationAlgorithm::VVAK)
 361 //! Do we use molecular dynamics
 362 #define EI_MD(e) ((e) == IntegrationAlgorithm::MD || EI_VV(e) || EI_MIMIC(e))
 363 //! Do we use stochastic dynamics
 364 #define EI_SD(e) ((e) == IntegrationAlgorithm::SD1)
 365 //! Do we use any stochastic integrator
 366 #define EI_RANDOM(e) (EI_SD(e) || (e) == IntegrationAlgorithm::BD)
 367 /*above integrators may not conserve momenta*/
 368 //! Do we use any type of dynamics
 369 #define EI_DYNAMICS(e) (EI_MD(e) || EI_RANDOM(e))
 370 //! Or do we use minimization
 371 #define EI_ENERGY_MINIMIZATION(e)                                          \
 372     ((e) == IntegrationAlgorithm::Steep || (e) == IntegrationAlgorithm::CG \
 373      || (e) == IntegrationAlgorithm::LBFGS)
 374 //! Do we apply test particle insertion
 375 #define EI_TPI(e) ((e) == IntegrationAlgorithm::TPI || (e) == IntegrationAlgorithm::TPIC)
 376 //! Do we deal with particle velocities
 377 #define EI_STATE_VELOCITY(e) (EI_MD(e) || EI_SD(e))
 378
 379 //! Constraint algorithm
 380 enum class ConstraintAlgorithm : int
 381 {
 382     Lincs,
 383     Shake,
 384     Count,
 385     Default = Lincs
 386 };
 387 //! String corresponding to constraint algorithm
 388 const char* enumValueToString(ConstraintAlgorithm enumValue);
 389
 390 //! Distance restraint refinement algorithm
 391 enum class DistanceRestraintRefinement : int
 392 {
 393     None,
 394     Simple,
 395     Ensemble,
 396     Count,
 397     Default = None
 398 };
 399 //! String corresponding to distance restraint algorithm
 400 const char* enumValueToString(DistanceRestraintRefinement enumValue);
 401
 402 //! Distance restraints weighting type
 403 enum class DistanceRestraintWeighting : int
 404 {
 405     Conservative,
 406     Equal,
 407     Count,
 408     Default = Conservative
 409 };
 410 //! String corresponding to distance restraint weighting
 411 const char* enumValueToString(DistanceRestraintWeighting enumValue);
 412
 413 //! Combination rule algorithm.
 414 enum class CombinationRule : int
 415 {
 416     None,
 417     Geometric,
 418     Arithmetic,
 419     GeomSigEps,
 420     Count,
 421     Default = Geometric
 422 };
 423 //! String for combination rule algorithm
 424 const char* enumValueToString(CombinationRule enumValue);
 425
 426 //! Van der Waals potential.
 427 enum class VanDerWaalsPotential : int
 428 {
 429     None,
 430     LJ,
 431     Buckingham,
 432     Count,
 433     Default = LJ
 434 };
 435 //! String corresponding to Van der Waals potential
 436 const char* enumValueToString(VanDerWaalsPotential enumValue);
 437
 438 //! Simulated tempering methods.
 439 enum class SimulatedTempering : int
 440 {
 441     Geometric,
 442     Exponential,
 443     Linear,
 444     Count,
 445     Default = Geometric
 446 };
 447 //! String corresponding to simulated tempering
 448 const char* enumValueToString(SimulatedTempering enumValue);
 449
 450 /*! \brief Free energy perturbation type
 451  */
 452 enum class FreeEnergyPerturbationType : int
 453 {
 454     //! there are no evaluations at other states
 455     No,
 456     //! treated equivalently to Static
 457     Yes,
 458     //! then lambdas do not change during the simulation
 459     Static,
 460     //! then the states change monotonically throughout the simulation
 461     SlowGrowth,
 462     //! then expanded ensemble simulations are occuring
 463     Expanded,
 464     Count,
 465     Default = No
 466 };
 467 //! String corresponding to FEP type.
 468 const char* enumValueToString(FreeEnergyPerturbationType enumValue);
 469
 470 //! Free energy pertubation coupling types.
 471 enum class FreeEnergyPerturbationCouplingType : int
 472 {
 473     Fep,
 474     Mass,
 475     Coul,
 476     Vdw,
 477     Bonded,
 478     Restraint,
 479     Temperature,
 480     Count,
 481     Default = Fep
 482 };
 483 //! String for FEP coupling type
 484 const char* enumValueToString(FreeEnergyPerturbationCouplingType enumValue);
 485 //! String for FEP coupling type, singular mention.
 486 const char* enumValueToStringSingular(FreeEnergyPerturbationCouplingType enumValue);
 487
 488 /*! \brief What to print for free energy calculations
 489  *
 490  * Printing the energy to the free energy dhdl file.
 491  * Yes is an alias to Total, and
 492  * will be converted in readir, so we never have to account for it in code.
 493  */
 494 enum class FreeEnergyPrintEnergy : int
 495 {
 496     No,
 497     Total,
 498     Potential,
 499     Yes,
 500     Count,
 501     Default = No
 502 };
 503 //! String corresponding to printing of free energy
 504 const char* enumValueToString(FreeEnergyPrintEnergy enumValue);
 505
 506 /*! \brief How the lambda weights are calculated
 507  */
 508 enum class LambdaWeightCalculation : int
 509 {
 510     //! don't calculate
 511     No,
 512     //! using the metropolis criteria
 513     Metropolis,
 514     //! using the Barker critera for transition weights, also called unoptimized Bennett
 515     Barker,
 516     //! using Barker + minimum variance for weights
 517     Minvar,
 518     //! Wang-Landu (using visitation counts)
 519     WL,
 520     //! Weighted Wang-Landau (using optimized Gibbs weighted visitation counts)
 521     WWL,
 522     Count,
 523     Default = No
 524 };
 525 //! String corresponding to lambda weights
 526 const char* enumValueToString(LambdaWeightCalculation enumValue);
 527 //! Macro telling us whether we use expanded ensemble
 528 #define ELAMSTATS_EXPANDED(e) ((e) > LambdaWeightCalculation::No)
 529 //! Macro telling us whether we use some kind of Wang-Landau
 530 #define EWL(e) ((e) == LambdaWeightCalculation::WL || (e) == LambdaWeightCalculation::WWL)
 531
 532 /*! \brief How moves in lambda are calculated
 533  */
 534 enum class LambdaMoveCalculation : int
 535 {
 536     //! don't calculate move
 537     No,
 538     //! using the Metropolis criteria, and 50% up and down
 539     Metropolis,
 540     //! using the Barker criteria, and 50% up and down
 541     Barker,
 542     //! computing the transition using the marginalized probabilities of the lambdas
 543     Gibbs,
 544     /*! \brief
 545      * using the metropolized version of Gibbs
 546      *
 547      * Monte Carlo Strategies in Scientific computing, Liu, p. 134
 548      */
 549     MetropolisGibbs,
 550     Count,
 551     Default = No
 552 };
 553 //! String corresponding to lambda moves
 554 const char* enumValueToString(LambdaMoveCalculation enumValue);
 555
 556 /*! \brief How we decide whether weights have reached equilibrium
 557  */
 558 enum class LambdaWeightWillReachEquilibrium : int
 559 {
 560     //! never stop, weights keep going
 561     No,
 562     //! fix the weights from the beginning; no movement
 563     Yes,
 564     //! stop when the WL-delta falls below a certain level
 565     WLDelta,
 566     //! stop when we have a certain number of samples at every step
 567     NumAtLambda,
 568     //! stop when we've run a certain total number of steps
 569     Steps,
 570     //! stop when we've run a certain total number of samples
 571     Samples,
 572     //! stop when the ratio of samples (lowest to highest) is sufficiently large
 573     Ratio,
 574     Count,
 575     Default = No
 576 };
 577 //! String corresponding to equilibrium algorithm
 578 const char* enumValueToString(LambdaWeightWillReachEquilibrium enumValue);
 579
 580 /*! \brief separate_dhdl_file selection
 581  *
 582  * NOTE: YES is the first one. Do NOT interpret this one as a gmx_bool
 583  * Why was this done this way, just .........
 584  */
 585 enum class SeparateDhdlFile : int
 586 {
 587     Yes,
 588     No,
 589     Count,
 590     Default = Yes
 591 };
 592 //! String corresponding to separate DHDL file selection
 593 const char* enumValueToString(SeparateDhdlFile enumValue);
 594
 595 /*! \brief dhdl_derivatives selection \
 596  *
 597  * NOTE: YES is the first one. Do NOT interpret this one as a gmx_bool
 598  * Why was this done this way, just .........
 599  */
 600 enum class DhDlDerivativeCalculation : int
 601 {
 602     Yes,
 603     No,
 604     Count,
 605     Default = Yes
 606 };
 607 //! String for DHDL derivatives
 608 const char* enumValueToString(DhDlDerivativeCalculation enumValue);
 609
 610 /*! \brief Solvent model
 611  *
 612  * Distinguishes classical water types with 3 or 4 particles
 613  */
 614 enum class SolventModel : int
 615 {
 616     No,
 617     Spc,
 618     Tip4p,
 619     Count,
 620     Default = Spc
 621 };
 622 //! String corresponding to solvent type
 623 const char* enumValueToString(SolventModel enumValue);
 624
 625 //! Dispersion correction.
 626 enum class DispersionCorrectionType : int
 627 {
 628     No,
 629     EnerPres,
 630     Ener,
 631     AllEnerPres,
 632     AllEner,
 633     Count,
 634     Default = No
 635 };
 636 //! String corresponding to dispersion corrections
 637 const char* enumValueToString(DispersionCorrectionType enumValue);
 638
 639 //! Center of mass motion removal algorithm.
 640 enum class ComRemovalAlgorithm : int
 641 {
 642     Linear,
 643     Angular,
 644     No,
 645     LinearAccelerationCorrection,
 646     Count,
 647     Default = Linear
 648 };
 649 //! String corresponding to COM removal
 650 const char* enumValueToString(ComRemovalAlgorithm enumValue);
 651
 652 //! Algorithm for simulated annealing.
 653 enum class SimulatedAnnealing : int
 654 {
 655     No,
 656     Single,
 657     Periodic,
 658     Count,
 659     Default = No
 660 };
 661 //! String for simulated annealing
 662 const char* enumValueToString(SimulatedAnnealing enumValue);
 663
 664 //! Wall types.
 665 enum class WallType : int
 666 {
 667     NineThree,
 668     TenFour,
 669     Table,
 670     TwelveSix,
 671     Count,
 672     Default = NineThree
 673 };
 674 //! String corresponding to wall type
 675 const char* enumValueToString(WallType enumValue);
 676
 677 //! Pulling algorithm.
 678 enum class PullingAlgorithm : int
 679 {
 680     Umbrella,
 681     Constraint,
 682     ConstantForce,
 683     FlatBottom,
 684     FlatBottomHigh,
 685     External,
 686     Count,
 687     Default = Umbrella
 688 };
 689 //! String for pulling algorithm
 690 const char* enumValueToString(PullingAlgorithm enumValue);
 691
 692 //! Control of pull groups
 693 enum class PullGroupGeometry : int
 694 {
 695     Distance,
 696     Direction,
 697     Cylinder,
 698     DirectionPBC,
 699     DirectionRelative,
 700     Angle,
 701     Dihedral,
 702     AngleAxis,
 703     Count,
 704     Default = Distance
 705 };
 706 //! String for pull groups
 707 const char* enumValueToString(PullGroupGeometry enumValue);
 708
 709 //! Enforced rotation groups.
 710 enum class EnforcedRotationGroupType : int
 711 {
 712     Iso,
 713     Isopf,
 714     Pm,
 715     Pmpf,
 716     Rm,
 717     Rmpf,
 718     Rm2,
 719     Rm2pf,
 720     Flex,
 721     Flext,
 722     Flex2,
 723     Flex2t,
 724     Count,
 725     Default = Iso
 726 };
 727 //! Rotation group names
 728 const char* enumValueToString(EnforcedRotationGroupType enumValue);
 729 //! String for rotation group origin names
 730 const char* enumValueToLongString(EnforcedRotationGroupType enumValue);
 731
 732 //! Rotation group fitting type
 733 enum class RotationGroupFitting : int
 734 {
 735     Rmsd,
 736     Norm,
 737     Pot,
 738     Count,
 739     Default = Rmsd
 740 };
 741 //! String corresponding to rotation group fitting
 742 const char* enumValueToString(RotationGroupFitting enumValue);
 743
 744 /*! \brief Direction along which ion/water swaps happen
 745  *
 746  * Part of "Computational Electrophysiology" (CompEL) setups
 747  */
 748 enum class SwapType : int
 749 {
 750     No,
 751     X,
 752     Y,
 753     Z,
 754     Count,
 755     Default = No
 756 };
 757 //! Names for swapping
 758 const char* enumValueToString(SwapType enumValue);
 759
 760 /*! \brief Swap group splitting type
 761  *
 762  * These are just the fixed groups we need for any setup. In t_swap's grp
 763  * entry after that follows the variable number of swap groups.
 764  */
 765 enum class SwapGroupSplittingType : int
 766 {
 767     Split0,
 768     Split1,
 769     Solvent,
 770     Count,
 771     Default = Solvent
 772 };
 773 //! String for swap group splitting
 774 const char* enumValueToString(SwapGroupSplittingType enumValue);
 775
 776 /*! \brief Types of electrostatics calculations
 777  *
 778  * Types of electrostatics calculations available inside nonbonded kernels.
 779  * Note that these do NOT necessarily correspond to the user selections
 780  * in the MDP file; many interactions for instance map to tabulated kernels.
 781  */
 782 enum class NbkernelElecType : int
 783 {
 784     None,
 785     Coulomb,
 786     ReactionField,
 787     CubicSplineTable,
 788     Ewald,
 789     Count,
 790     Default = None
 791 };
 792 //! String corresponding to electrostatics kernels
 793 const char* enumValueToString(NbkernelElecType enumValue);
 794
 795 /*! \brief Types of vdw calculations available
 796  *
 797  * Types of vdw calculations available inside nonbonded kernels.
 798  * Note that these do NOT necessarily correspond to the user selections
 799  * in the MDP file; many interactions for instance map to tabulated kernels.
 800  */
 801 enum class NbkernelVdwType : int
 802 {
 803     None,
 804     LennardJones,
 805     Buckingham,
 806     CubicSplineTable,
 807     LJEwald,
 808     Count,
 809     Default = None
 810 };
 811 //! String corresponding to VdW kernels
 812 const char* enumValueToString(NbkernelVdwType enumValue);
 813
 814 #endif /* GMX_MDTYPES_MD_ENUMS_H */