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,2018,2019, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37 /*! \file
  38  * \brief
  39  * Declares enumerated types used throughout the code.
  40  *
  41  * \author David van der Spoel <david.vanderspoel@icm.uu.se>
  42  * \inpublicapi
  43  * \ingroup module_mdtypes
  44  */
  45 #ifndef GMX_MDTYPES_MD_ENUMS_H
  46 #define GMX_MDTYPES_MD_ENUMS_H
  47
  48 #include "gromacs/utility/basedefinitions.h"
  49
  50 /*! \brief Return a string from a list of strings
  51  *
  52  * If index if within 0 .. max_index-1 returns the corresponding string
  53  * or "no name defined" otherwise, in other words this is a range-check that does
  54  * not crash.
  55  * \param[in] index     The index in the array
  56  * \param[in] max_index The length of the array
  57  * \param[in] names     The array
  58  * \return the correct string or "no name defined"
  59  */
  60 const char* enum_name(int index, int max_index, const char* names[]);
  61
  62 //! Boolean strings no or yes
  63 extern const char* yesno_names[BOOL_NR + 1];
  64
  65 //! \brief The two compartments for CompEL setups.
  66 enum eCompartment
  67 {
  68     eCompA,
  69     eCompB,
  70     eCompNR
  71 };
  72
  73 /*! \brief The channels that define with their COM the compartment boundaries in CompEL setups.
  74  *
  75  * In principle one could also use modified setups with more than two channels.
  76  */
  77 enum eChannel
  78 {
  79     eChan0,
  80     eChan1,
  81     eChanNR
  82 };
  83
  84 /*! \brief Temperature coupling type
  85  *
  86  * yes is an alias for berendsen
  87  */
  88 enum
  89 {
  90     etcNO,
  91     etcBERENDSEN,
  92     etcNOSEHOOVER,
  93     etcYES,
  94     etcANDERSEN,
  95     etcANDERSENMASSIVE,
  96     etcVRESCALE,
  97     etcNR
  98 };
  99 //! Strings corresponding to temperatyre coupling types
 100 extern const char* etcoupl_names[etcNR + 1];
 101 //! Macro for selecting t coupling string
 102 #define ETCOUPLTYPE(e) enum_name(e, etcNR, etcoupl_names)
 103 //! Return whether this is andersen coupling
 104 #define ETC_ANDERSEN(e) (((e) == etcANDERSENMASSIVE) || ((e) == etcANDERSEN))
 105
 106 /*! \brief Pressure coupling types
 107  *
 108  * isotropic is an alias for berendsen
 109  */
 110 enum
 111 {
 112     epcNO,
 113     epcBERENDSEN,
 114     epcPARRINELLORAHMAN,
 115     epcISOTROPIC,
 116     epcMTTK,
 117     epcNR
 118 };
 119 //! String corresponding to pressure coupling algorithm
 120 extern const char* epcoupl_names[epcNR + 1];
 121 //! Macro to return the correct pcoupling string
 122 #define EPCOUPLTYPE(e) enum_name(e, epcNR, epcoupl_names)
 123
 124 //! Flat-bottom posres geometries
 125 enum
 126 {
 127     efbposresZERO,
 128     efbposresSPHERE,
 129     efbposresCYLINDER,
 130     efbposresX,
 131     efbposresY,
 132     efbposresZ,
 133     efbposresCYLINDERX,
 134     efbposresCYLINDERY,
 135     efbposresCYLINDERZ,
 136     efbposresNR
 137 };
 138
 139 //! Relative coordinate scaling type for position restraints.
 140 enum
 141 {
 142     erscNO,
 143     erscALL,
 144     erscCOM,
 145     erscNR
 146 };
 147 //! String corresponding to relativ coordinate scaling.
 148 extern const char* erefscaling_names[erscNR + 1];
 149 //! Macro to select correct coordinate scaling string.
 150 #define EREFSCALINGTYPE(e) enum_name(e, erscNR, erefscaling_names)
 151
 152 //! Trotter decomposition extended variable parts.
 153 enum
 154 {
 155     etrtNONE,
 156     etrtNHC,
 157     etrtBAROV,
 158     etrtBARONHC,
 159     etrtNHC2,
 160     etrtBAROV2,
 161     etrtBARONHC2,
 162     etrtVELOCITY1,
 163     etrtVELOCITY2,
 164     etrtPOSITION,
 165     etrtSKIPALL,
 166     etrtNR
 167 };
 168
 169 //! Sequenced parts of the trotter decomposition.
 170 enum
 171 {
 172     ettTSEQ0,
 173     ettTSEQ1,
 174     ettTSEQ2,
 175     ettTSEQ3,
 176     ettTSEQ4,
 177     ettTSEQMAX
 178 };
 179
 180 //! Pressure coupling type
 181 enum
 182 {
 183     epctISOTROPIC,
 184     epctSEMIISOTROPIC,
 185     epctANISOTROPIC,
 186     epctSURFACETENSION,
 187     epctNR
 188 };
 189 //! String corresponding to pressure coupling type
 190 extern const char* epcoupltype_names[epctNR + 1];
 191 //! Macro to select the right string for pcoupl type
 192 #define EPCOUPLTYPETYPE(e) enum_name(e, epctNR, epcoupltype_names)
 193
 194 //! \\brief Cutoff scheme
 195 enum
 196 {
 197     ecutsVERLET,
 198     ecutsGROUP,
 199     ecutsNR
 200 };
 201 //! String corresponding to cutoff scheme
 202 extern const char* ecutscheme_names[ecutsNR + 1];
 203 //! Macro to select the right string for cutoff scheme
 204 #define ECUTSCHEME(e) enum_name(e, ecutsNR, ecutscheme_names)
 205
 206 /*! \brief Coulomb / VdW interaction modifiers.
 207  *
 208  * grompp replaces eintmodPOTSHIFT_VERLET_UNSUPPORTED by eintmodPOTSHIFT.
 209  * Exactcutoff is only used by Reaction-field-zero, and is not user-selectable.
 210  */
 211 enum eintmod
 212 {
 213     eintmodPOTSHIFT_VERLET_UNSUPPORTED,
 214     eintmodPOTSHIFT,
 215     eintmodNONE,
 216     eintmodPOTSWITCH,
 217     eintmodEXACTCUTOFF,
 218     eintmodFORCESWITCH,
 219     eintmodNR
 220 };
 221 //! String corresponding to interaction modifiers
 222 extern const char* eintmod_names[eintmodNR + 1];
 223 //! Macro to select the correct string for modifiers
 224 #define INTMODIFIER(e) enum_name(e, eintmodNR, eintmod_names)
 225
 226 /*! \brief Cut-off treatment for Coulomb */
 227 enum
 228 {
 229     eelCUT,
 230     eelRF,
 231     eelGRF_NOTUSED,
 232     eelPME,
 233     eelEWALD,
 234     eelP3M_AD,
 235     eelPOISSON,
 236     eelSWITCH,
 237     eelSHIFT,
 238     eelUSER,
 239     eelGB_NOTUSED,
 240     eelRF_NEC_UNSUPPORTED,
 241     eelENCADSHIFT,
 242     eelPMEUSER,
 243     eelPMESWITCH,
 244     eelPMEUSERSWITCH,
 245     eelRF_ZERO,
 246     eelNR
 247 };
 248 //! String corresponding to Coulomb treatment
 249 extern const char* eel_names[eelNR + 1];
 250 //! Macro for correct string for Coulomb treatment
 251 #define EELTYPE(e) enum_name(e, eelNR, eel_names)
 252
 253 //! Ewald geometry.
 254 enum
 255 {
 256     eewg3D,
 257     eewg3DC,
 258     eewgNR
 259 };
 260 //! String corresponding to Ewald geometry
 261 extern const char* eewg_names[eewgNR + 1];
 262
 263 //! Macro telling us whether we use reaction field
 264 #define EEL_RF(e) \
 265     ((e) == eelRF || (e) == eelGRF_NOTUSED || (e) == eelRF_NEC_UNSUPPORTED || (e) == eelRF_ZERO)
 266
 267 //! Macro telling us whether we use PME
 268 #define EEL_PME(e) \
 269     ((e) == eelPME || (e) == eelPMESWITCH || (e) == eelPMEUSER || (e) == eelPMEUSERSWITCH || (e) == eelP3M_AD)
 270 //! Macro telling us whether we use PME or full Ewald
 271 #define EEL_PME_EWALD(e) (EEL_PME(e) || (e) == eelEWALD)
 272 //! Macro telling us whether we use full electrostatics of any sort
 273 #define EEL_FULL(e) (EEL_PME_EWALD(e) || (e) == eelPOISSON)
 274 //! Macro telling us whether we use user defined electrostatics
 275 #define EEL_USER(e) ((e) == eelUSER || (e) == eelPMEUSER || (e) == (eelPMEUSERSWITCH))
 276
 277 //! Van der Waals interaction treatment
 278 enum
 279 {
 280     evdwCUT,
 281     evdwSWITCH,
 282     evdwSHIFT,
 283     evdwUSER,
 284     evdwENCADSHIFT,
 285     evdwPME,
 286     evdwNR
 287 };
 288 //! String corresponding to Van der Waals treatment
 289 extern const char* evdw_names[evdwNR + 1];
 290 //! Macro for selecting correct string for VdW treatment
 291 #define EVDWTYPE(e) enum_name(e, evdwNR, evdw_names)
 292
 293 //! Type of long-range VdW treatment of combination rules
 294 enum
 295 {
 296     eljpmeGEOM,
 297     eljpmeLB,
 298     eljpmeNR
 299 };
 300 //! String for LJPME combination rule treatment
 301 extern const char* eljpme_names[eljpmeNR + 1];
 302 //! Macro for correct LJPME comb rule name
 303 #define ELJPMECOMBNAMES(e) enum_name(e, eljpmeNR, eljpme_names)
 304
 305 //! Macro to tell us whether we use LJPME
 306 #define EVDW_PME(e) ((e) == evdwPME)
 307
 308 /*! \brief Integrator algorithm
 309  *
 310  * eiSD2 has been removed, but we keep a renamed enum entry,
 311  * so we can refuse to do MD with such .tpr files.
 312  * eiVV is normal velocity verlet
 313  * eiVVAK uses 1/2*(KE(t-dt/2)+KE(t+dt/2)) as the kinetic energy,
 314  * and the half step kinetic energy for temperature control
 315  */
 316 enum
 317 {
 318     eiMD,
 319     eiSteep,
 320     eiCG,
 321     eiBD,
 322     eiSD2_REMOVED,
 323     eiNM,
 324     eiLBFGS,
 325     eiTPI,
 326     eiTPIC,
 327     eiSD1,
 328     eiVV,
 329     eiVVAK,
 330     eiMimic,
 331     eiNR
 332 };
 333 //! Name of the integrator algorithm
 334 extern const char* ei_names[eiNR + 1];
 335 //! Macro returning integrator string
 336 #define EI(e) enum_name(e, eiNR, ei_names)
 337 //! Do we use MiMiC QM/MM?
 338 #define EI_MIMIC(e) ((e) == eiMimic)
 339 //! Do we use velocity Verlet
 340 #define EI_VV(e) ((e) == eiVV || (e) == eiVVAK)
 341 //! Do we use molecular dynamics
 342 #define EI_MD(e) ((e) == eiMD || EI_VV(e) || EI_MIMIC(e))
 343 //! Do we use stochastic dynamics
 344 #define EI_SD(e) ((e) == eiSD1)
 345 //! Do we use any stochastic integrator
 346 #define EI_RANDOM(e) (EI_SD(e) || (e) == eiBD)
 347 /*above integrators may not conserve momenta*/
 348 //! Do we use any type of dynamics
 349 #define EI_DYNAMICS(e) (EI_MD(e) || EI_RANDOM(e))
 350 //! Or do we use minimization
 351 #define EI_ENERGY_MINIMIZATION(e) ((e) == eiSteep || (e) == eiCG || (e) == eiLBFGS)
 352 //! Do we apply test particle insertion
 353 #define EI_TPI(e) ((e) == eiTPI || (e) == eiTPIC)
 354 //! Do we deal with particle velocities
 355 #define EI_STATE_VELOCITY(e) (EI_MD(e) || EI_SD(e))
 356
 357 //! Constraint algorithm
 358 enum
 359 {
 360     econtLINCS,
 361     econtSHAKE,
 362     econtNR
 363 };
 364 //! String corresponding to constraint algorithm
 365 extern const char* econstr_names[econtNR + 1];
 366 //! Macro to select the correct string
 367 #define ECONSTRTYPE(e) enum_name(e, econtNR, econstr_names)
 368
 369 //! Distance restraint refinement algorithm
 370 enum
 371 {
 372     edrNone,
 373     edrSimple,
 374     edrEnsemble,
 375     edrNR
 376 };
 377 //! String corresponding to distance restraint algorithm
 378 extern const char* edisre_names[edrNR + 1];
 379 //! Macro to select the right disre algorithm string
 380 #define EDISRETYPE(e) enum_name(e, edrNR, edisre_names)
 381
 382 //! Distance restraints weighting type
 383 enum
 384 {
 385     edrwConservative,
 386     edrwEqual,
 387     edrwNR
 388 };
 389 //! String corresponding to distance restraint weighting
 390 extern const char* edisreweighting_names[edrwNR + 1];
 391 //! Macro corresponding to dr weighting
 392 #define EDISREWEIGHTING(e) enum_name(e, edrwNR, edisreweighting_names)
 393
 394 //! Combination rule algorithm.
 395 enum
 396 {
 397     eCOMB_NONE,
 398     eCOMB_GEOMETRIC,
 399     eCOMB_ARITHMETIC,
 400     eCOMB_GEOM_SIG_EPS,
 401     eCOMB_NR
 402 };
 403 //! String for combination rule algorithm
 404 extern const char* ecomb_names[eCOMB_NR + 1];
 405 //! Macro to select the comb rule string
 406 #define ECOMBNAME(e) enum_name(e, eCOMB_NR, ecomb_names)
 407
 408 //! Van der Waals potential.
 409 enum
 410 {
 411     eNBF_NONE,
 412     eNBF_LJ,
 413     eNBF_BHAM,
 414     eNBF_NR
 415 };
 416 //! String corresponding to Van der Waals potential
 417 extern const char* enbf_names[eNBF_NR + 1];
 418 //! Macro for correct VdW potential string
 419 #define ENBFNAME(e) enum_name(e, eNBF_NR, enbf_names)
 420
 421 //! Simulated tempering methods.
 422 enum
 423 {
 424     esimtempGEOMETRIC,
 425     esimtempEXPONENTIAL,
 426     esimtempLINEAR,
 427     esimtempNR
 428 };
 429 //! String corresponding to simulated tempering
 430 extern const char* esimtemp_names[esimtempNR + 1];
 431 //! Macro for correct tempering string
 432 #define ESIMTEMP(e) enum_name(e, esimtempNR, esimtemp_names)
 433
 434 /*! \brief Free energy perturbation type
 435  *
 436  * efepNO, there are no evaluations at other states.
 437  * efepYES, treated equivalently to efepSTATIC.
 438  * efepSTATIC, then lambdas do not change during the simulation.
 439  * efepSLOWGROWTH, then the states change monotonically
 440  * throughout the simulation.
 441  * efepEXPANDED, then expanded ensemble simulations are occuring.
 442  */
 443 enum
 444 {
 445     efepNO,
 446     efepYES,
 447     efepSTATIC,
 448     efepSLOWGROWTH,
 449     efepEXPANDED,
 450     efepNR
 451 };
 452 //! String corresponding to FEP type.
 453 extern const char* efep_names[efepNR + 1];
 454 //! Macro corresponding to FEP string.
 455 #define EFEPTYPE(e) enum_name(e, efepNR, efep_names)
 456
 457 //! Free energy pertubation coupling types.
 458 enum
 459 {
 460     efptFEP,
 461     efptMASS,
 462     efptCOUL,
 463     efptVDW,
 464     efptBONDED,
 465     efptRESTRAINT,
 466     efptTEMPERATURE,
 467     efptNR
 468 };
 469 //! String for FEP coupling type
 470 extern const char* efpt_names[efptNR + 1];
 471 //! Long names for FEP coupling type
 472 extern const char* efpt_singular_names[efptNR + 1];
 473
 474 /*! \brief What to print for free energy calculations
 475  *
 476  * Printing the energy to the free energy dhdl file.
 477  * YES is an alias to TOTAL, and
 478  * will be converted in readir, so we never have to account for it in code.
 479  */
 480 enum
 481 {
 482     edHdLPrintEnergyNO,
 483     edHdLPrintEnergyTOTAL,
 484     edHdLPrintEnergyPOTENTIAL,
 485     edHdLPrintEnergyYES,
 486     edHdLPrintEnergyNR
 487 };
 488 //! String corresponding to printing of free energy
 489 extern const char* edHdLPrintEnergy_names[edHdLPrintEnergyNR + 1];
 490
 491 /*! \brief How the lambda weights are calculated
 492  *
 493  * elamstatsMETROPOLIS - using the metropolis criteria
 494  * elamstatsBARKER     - using the Barker critera for transition weights,
 495  *                       also called unoptimized Bennett
 496  * elamstatsMINVAR     - using Barker + minimum variance for weights
 497  * elamstatsWL         - Wang-Landu (using visitation counts)
 498  * elamstatsWWL        - Weighted Wang-Landau (using optimized Gibbs
 499  *                       weighted visitation counts)
 500  */
 501 enum
 502 {
 503     elamstatsNO,
 504     elamstatsMETROPOLIS,
 505     elamstatsBARKER,
 506     elamstatsMINVAR,
 507     elamstatsWL,
 508     elamstatsWWL,
 509     elamstatsNR
 510 };
 511 //! String corresponding to lambda weights
 512 extern const char* elamstats_names[elamstatsNR + 1];
 513 //! Macro telling us whether we use expanded ensemble
 514 #define ELAMSTATS_EXPANDED(e) ((e) > elamstatsNO)
 515 //! Macro telling us whether we use some kind of Wang-Landau
 516 #define EWL(e) ((e) == elamstatsWL || (e) == elamstatsWWL)
 517
 518 /*! \brief How moves in lambda are calculated
 519  *
 520  * elmovemcMETROPOLIS - using the Metropolis criteria, and 50% up and down
 521  * elmovemcBARKER     - using the Barker criteria, and 50% up and down
 522  * elmovemcGIBBS      - computing the transition using the marginalized
 523  *                      probabilities of the lambdas
 524  * elmovemcMETGIBBS   - computing the transition using the metropolized
 525  *                      version of Gibbs (Monte Carlo Strategies in
 526  *                      Scientific computing, Liu, p. 134)
 527  */
 528 enum
 529 {
 530     elmcmoveNO,
 531     elmcmoveMETROPOLIS,
 532     elmcmoveBARKER,
 533     elmcmoveGIBBS,
 534     elmcmoveMETGIBBS,
 535     elmcmoveNR
 536 };
 537 //! String corresponding to lambda moves
 538 extern const char* elmcmove_names[elmcmoveNR + 1];
 539
 540 /*! \brief How we decide whether weights have reached equilibrium
 541  *
 542  * elmceqNO       - never stop, weights keep going
 543  * elmceqYES      - fix the weights from the beginning; no movement
 544  * elmceqWLDELTA  - stop when the WL-delta falls below a certain level
 545  * elmceqNUMATLAM - stop when we have a certain number of samples at
 546  *                  every step
 547  * elmceqSTEPS    - stop when we've run a certain total number of steps
 548  * elmceqSAMPLES  - stop when we've run a certain total number of samples
 549  * elmceqRATIO    - stop when the ratio of samples (lowest to highest)
 550  *                  is sufficiently large
 551  */
 552 enum
 553 {
 554     elmceqNO,
 555     elmceqYES,
 556     elmceqWLDELTA,
 557     elmceqNUMATLAM,
 558     elmceqSTEPS,
 559     elmceqSAMPLES,
 560     elmceqRATIO,
 561     elmceqNR
 562 };
 563 //! String corresponding to equilibrium algorithm
 564 extern const char* elmceq_names[elmceqNR + 1];
 565
 566 /*! \brief separate_dhdl_file selection
 567  *
 568  * NOTE: YES is the first one. Do NOT interpret this one as a gmx_bool
 569  */
 570 enum
 571 {
 572     esepdhdlfileYES,
 573     esepdhdlfileNO,
 574     esepdhdlfileNR
 575 };
 576 //! String corresponding to separate DHDL file selection
 577 extern const char* separate_dhdl_file_names[esepdhdlfileNR + 1];
 578 //! Monster macro for DHDL file selection
 579 #define SEPDHDLFILETYPE(e) enum_name(e, esepdhdlfileNR, separate_dhdl_file_names)
 580
 581 /*! \brief dhdl_derivatives selection \
 582  *
 583  * NOTE: YES is the first one. Do NOT interpret this one as a gmx_bool
 584  */
 585 enum
 586 {
 587     edhdlderivativesYES,
 588     edhdlderivativesNO,
 589     edhdlderivativesNR
 590 };
 591 //! String for DHDL derivatives
 592 extern const char* dhdl_derivatives_names[edhdlderivativesNR + 1];
 593 //! YAMM (Yet another monster macro)
 594 #define DHDLDERIVATIVESTYPE(e) enum_name(e, edhdlderivativesNR, dhdl_derivatives_names)
 595
 596 /*! \brief Solvent model
 597  *
 598  * Distinguishes classical water types with 3 or 4 particles
 599  */
 600 enum
 601 {
 602     esolNO,
 603     esolSPC,
 604     esolTIP4P,
 605     esolNR
 606 };
 607 //! String corresponding to solvent type
 608 extern const char* esol_names[esolNR + 1];
 609 //! Macro lest we print the wrong solvent model string
 610 #define ESOLTYPE(e) enum_name(e, esolNR, esol_names)
 611
 612 //! Dispersion correction.
 613 enum
 614 {
 615     edispcNO,
 616     edispcEnerPres,
 617     edispcEner,
 618     edispcAllEnerPres,
 619     edispcAllEner,
 620     edispcNR
 621 };
 622 //! String corresponding to dispersion corrections
 623 extern const char* edispc_names[edispcNR + 1];
 624 //! Macro for dispcorr string
 625 #define EDISPCORR(e) enum_name(e, edispcNR, edispc_names)
 626
 627 //! Center of mass motion removal algorithm.
 628 enum
 629 {
 630     ecmLINEAR,
 631     ecmANGULAR,
 632     ecmNO,
 633     ecmLINEAR_ACCELERATION_CORRECTION,
 634     ecmNR
 635 };
 636 //! String corresponding to COM removal
 637 extern const char* ecm_names[ecmNR + 1];
 638 //! Macro for COM removal string
 639 #define ECOM(e) enum_name(e, ecmNR, ecm_names)
 640
 641 //! Algorithm for simulated annealing.
 642 enum
 643 {
 644     eannNO,
 645     eannSINGLE,
 646     eannPERIODIC,
 647     eannNR
 648 };
 649 //! String for simulated annealing
 650 extern const char* eann_names[eannNR + 1];
 651 //! And macro for simulated annealing string
 652 #define EANNEAL(e) enum_name(e, eannNR, eann_names)
 653
 654 //! Wall types.
 655 enum
 656 {
 657     ewt93,
 658     ewt104,
 659     ewtTABLE,
 660     ewt126,
 661     ewtNR
 662 };
 663 //! String corresponding to wall type
 664 extern const char* ewt_names[ewtNR + 1];
 665 //! Macro for wall type string
 666 #define EWALLTYPE(e) enum_name(e, ewtNR, ewt_names)
 667
 668 //! Pulling algorithm.
 669 enum
 670 {
 671     epullUMBRELLA,
 672     epullCONSTRAINT,
 673     epullCONST_F,
 674     epullFLATBOTTOM,
 675     epullFLATBOTTOMHIGH,
 676     epullEXTERNAL,
 677     epullNR
 678 };
 679 //! String for pulling algorithm
 680 extern const char* epull_names[epullNR + 1];
 681 //! Macro for pulling string
 682 #define EPULLTYPE(e) enum_name(e, epullNR, epull_names)
 683
 684 //! Control of pull groups
 685 enum
 686 {
 687     epullgDIST,
 688     epullgDIR,
 689     epullgCYL,
 690     epullgDIRPBC,
 691     epullgDIRRELATIVE,
 692     epullgANGLE,
 693     epullgDIHEDRAL,
 694     epullgANGLEAXIS,
 695     epullgNR
 696 };
 697 //! String for pull groups
 698 extern const char* epullg_names[epullgNR + 1];
 699 //! Macro for pull group string
 700 #define EPULLGEOM(e) enum_name(e, epullgNR, epullg_names)
 701
 702 //! Enforced rotation groups.
 703 enum
 704 {
 705     erotgISO,
 706     erotgISOPF,
 707     erotgPM,
 708     erotgPMPF,
 709     erotgRM,
 710     erotgRMPF,
 711     erotgRM2,
 712     erotgRM2PF,
 713     erotgFLEX,
 714     erotgFLEXT,
 715     erotgFLEX2,
 716     erotgFLEX2T,
 717     erotgNR
 718 };
 719 //! Rotation group names
 720 extern const char* erotg_names[erotgNR + 1];
 721 //! Macro for rot group names
 722 #define EROTGEOM(e) enum_name(e, erotgNR, erotg_names)
 723 //! String for rotation group origin names
 724 extern const char* erotg_originnames[erotgNR + 1];
 725 //! Macro for rot group origin names
 726 #define EROTORIGIN(e) enum_name(e, erotgOriginNR, erotg_originnames)
 727
 728 //! Rotation group fitting type
 729 enum
 730 {
 731     erotgFitRMSD,
 732     erotgFitNORM,
 733     erotgFitPOT,
 734     erotgFitNR
 735 };
 736 //! String corresponding to rotation group fitting
 737 extern const char* erotg_fitnames[erotgFitNR + 1];
 738 //! Macro for rot group fit names
 739 #define EROTFIT(e) enum_name(e, erotgFitNR, erotg_fitnames)
 740
 741 /*! \brief Direction along which ion/water swaps happen
 742  *
 743  * Part of "Computational Electrophysiology" (CompEL) setups
 744  */
 745 enum eSwaptype
 746 {
 747     eswapNO,
 748     eswapX,
 749     eswapY,
 750     eswapZ,
 751     eSwapTypesNR
 752 };
 753 //! Names for swapping
 754 extern const char* eSwapTypes_names[eSwapTypesNR + 1];
 755 //! Macro for swapping string
 756 #define ESWAPTYPE(e) enum_name(e, eSwapTypesNR, eSwapTypes_names)
 757
 758 /*! \brief Swap group splitting type
 759  *
 760  * These are just the fixed groups we need for any setup. In t_swap's grp
 761  * entry after that follows the variable number of swap groups.
 762  */
 763 enum
 764 {
 765     eGrpSplit0,
 766     eGrpSplit1,
 767     eGrpSolvent,
 768     eSwapFixedGrpNR
 769 };
 770 //! String for swap group splitting
 771 extern const char* eSwapFixedGrp_names[eSwapFixedGrpNR + 1];
 772
 773 //! QMMM methods.
 774 enum
 775 {
 776     eQMmethodAM1,
 777     eQMmethodPM3,
 778     eQMmethodRHF,
 779     eQMmethodUHF,
 780     eQMmethodDFT,
 781     eQMmethodB3LYP,
 782     eQMmethodMP2,
 783     eQMmethodCASSCF,
 784     eQMmethodB3LYPLAN,
 785     eQMmethodDIRECT,
 786     eQMmethodNR
 787 };
 788 //! String corresponding to QMMM methods
 789 extern const char* eQMmethod_names[eQMmethodNR + 1];
 790 //! Macro to pick QMMM method name
 791 #define EQMMETHOD(e) enum_name(e, eQMmethodNR, eQMmethod_names)
 792
 793 //! QMMM basis function for QM part
 794 enum
 795 {
 796     eQMbasisSTO3G,
 797     eQMbasisSTO3G2,
 798     eQMbasis321G,
 799     eQMbasis321Gp,
 800     eQMbasis321dGp,
 801     eQMbasis621G,
 802     eQMbasis631G,
 803     eQMbasis631Gp,
 804     eQMbasis631dGp,
 805     eQMbasis6311G,
 806     eQMbasisNR
 807 };
 808 //! Name for QMMM basis function
 809 extern const char* eQMbasis_names[eQMbasisNR + 1];
 810 //! Macro to pick right basis function string
 811 #define EQMBASIS(e) enum_name(e, eQMbasisNR, eQMbasis_names)
 812
 813 //! QMMM scheme
 814 enum
 815 {
 816     eQMMMschemenormal,
 817     eQMMMschemeoniom,
 818     eQMMMschemeNR
 819 };
 820 //! QMMMM scheme names
 821 extern const char* eQMMMscheme_names[eQMMMschemeNR + 1];
 822 //! Macro to pick QMMMM scheme name
 823 #define EQMMMSCHEME(e) enum_name(e, eQMMMschemeNR, eQMMMscheme_names)
 824
 825 /*! \brief Neighborlist geometry type.
 826  *
 827  * Kernels will compute interactions between two particles,
 828  * 3-center water, 4-center water or coarse-grained beads.
 829  */
 830 enum gmx_nblist_kernel_geometry
 831 {
 832     GMX_NBLIST_GEOMETRY_PARTICLE_PARTICLE,
 833     GMX_NBLIST_GEOMETRY_WATER3_PARTICLE,
 834     GMX_NBLIST_GEOMETRY_WATER3_WATER3,
 835     GMX_NBLIST_GEOMETRY_WATER4_PARTICLE,
 836     GMX_NBLIST_GEOMETRY_WATER4_WATER4,
 837     GMX_NBLIST_GEOMETRY_CG_CG,
 838     GMX_NBLIST_GEOMETRY_NR
 839 };
 840 //! String corresponding to nblist geometry names
 841 extern const char* gmx_nblist_geometry_names[GMX_NBLIST_GEOMETRY_NR + 1];
 842
 843 /*! \brief Types of electrostatics calculations
 844  *
 845  * Types of electrostatics calculations available inside nonbonded kernels.
 846  * Note that these do NOT necessarily correspond to the user selections
 847  * in the MDP file; many interactions for instance map to tabulated kernels.
 848  */
 849 enum gmx_nbkernel_elec
 850 {
 851     GMX_NBKERNEL_ELEC_NONE,
 852     GMX_NBKERNEL_ELEC_COULOMB,
 853     GMX_NBKERNEL_ELEC_REACTIONFIELD,
 854     GMX_NBKERNEL_ELEC_CUBICSPLINETABLE,
 855     GMX_NBKERNEL_ELEC_EWALD,
 856     GMX_NBKERNEL_ELEC_NR
 857 };
 858 //! String corresponding to electrostatics kernels
 859 extern const char* gmx_nbkernel_elec_names[GMX_NBKERNEL_ELEC_NR + 1];
 860
 861 /*! \brief Types of vdw calculations available
 862  *
 863  * Types of vdw calculations available inside nonbonded kernels.
 864  * Note that these do NOT necessarily correspond to the user selections
 865  * in the MDP file; many interactions for instance map to tabulated kernels.
 866  */
 867 enum gmx_nbkernel_vdw
 868 {
 869     GMX_NBKERNEL_VDW_NONE,
 870     GMX_NBKERNEL_VDW_LENNARDJONES,
 871     GMX_NBKERNEL_VDW_BUCKINGHAM,
 872     GMX_NBKERNEL_VDW_CUBICSPLINETABLE,
 873     GMX_NBKERNEL_VDW_LJEWALD,
 874     GMX_NBKERNEL_VDW_NR
 875 };
 876 //! String corresponding to VdW kernels
 877 extern const char* gmx_nbkernel_vdw_names[GMX_NBKERNEL_VDW_NR + 1];
 878
 879 //! \brief Types of interactions inside the neighborlist
 880 enum gmx_nblist_interaction_type
 881 {
 882     GMX_NBLIST_INTERACTION_STANDARD,
 883     GMX_NBLIST_INTERACTION_FREE_ENERGY,
 884     GMX_NBLIST_INTERACTION_NR
 885 };
 886 //! String corresponding to interactions in neighborlist code
 887 extern const char* gmx_nblist_interaction_names[GMX_NBLIST_INTERACTION_NR + 1];
 888
 889
 890 //! \brief QM/MM mode
 891 enum struct GmxQmmmMode
 892 {
 893     GMX_QMMM_ORIGINAL,
 894     GMX_QMMM_MIMIC
 895 };
 896 #endif /* GMX_MDTYPES_MD_ENUMS_H */