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