src/gromacs/mdtypes/md_enums.cpp

   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 #include "gmxpre.h"
  39
  40 #include "md_enums.h"
  41
  42 #include "gromacs/utility/enumerationhelpers.h"
  43
  44 const char* enum_name(int index, int max_index, const char* const names[])
  45 {
  46     if (index < 0 || index >= max_index)
  47     {
  48         static const char* undef = "no name defined";
  49         return undef;
  50     }
  51     else
  52     {
  53         return names[index];
  54     }
  55 }
  56
  57 const char* enumValueToString(IntegrationAlgorithm enumValue)
  58 {
  59     static constexpr gmx::EnumerationArray<IntegrationAlgorithm, const char*> interationAlgorithmNames = {
  60         "md",  "steep", "cg", "bd",    "sd2 - removed", "nm",   "l-bfgs",
  61         "tpi", "tpic",  "sd", "md-vv", "md-vv-avek",    "mimic"
  62     };
  63     return interationAlgorithmNames[enumValue];
  64 }
  65
  66 const char* enumValueToString(CoulombInteractionType enumValue)
  67 {
  68     static constexpr gmx::EnumerationArray<CoulombInteractionType, const char*> coloumbTreatmentNames = {
  69         "Cut-off",
  70         "Reaction-Field",
  71         "Generalized-Reaction-Field (unused)",
  72         "PME",
  73         "Ewald",
  74         "P3M-AD",
  75         "Poisson",
  76         "Switch",
  77         "Shift",
  78         "User",
  79         "Generalized-Born (unused)",
  80         "Reaction-Field-nec (unsupported)",
  81         "Encad-shift (unused)",
  82         "PME-User",
  83         "PME-Switch",
  84         "PME-User-Switch",
  85         "Reaction-Field-zero"
  86     };
  87     return coloumbTreatmentNames[enumValue];
  88 }
  89
  90 const char* enumValueToString(EwaldGeometry enumValue)
  91 {
  92     static constexpr gmx::EnumerationArray<EwaldGeometry, const char*> ewaldGeometryNames = {
  93         "3d", "3dc"
  94     };
  95     return ewaldGeometryNames[enumValue];
  96 }
  97
  98 const char* enumValueToString(LongRangeVdW enumValue)
  99 {
 100     static constexpr gmx::EnumerationArray<LongRangeVdW, const char*> longRangeVdWNames = {
 101         "Geometric", "Lorentz-Berthelot"
 102     };
 103     return longRangeVdWNames[enumValue];
 104 }
 105
 106 const char* enumValueToString(VanDerWaalsType enumValue)
 107 {
 108     static constexpr gmx::EnumerationArray<VanDerWaalsType, const char*> vanDerWaalsTypeNames = {
 109         "Cut-off", "Switch", "Shift", "User", "Encad-shift (unused)", "PME"
 110     };
 111     return vanDerWaalsTypeNames[enumValue];
 112 }
 113
 114 const char* enumValueToString(ConstraintAlgorithm enumValue)
 115 {
 116     static constexpr gmx::EnumerationArray<ConstraintAlgorithm, const char*> constraintAlgorithmNames = {
 117         "Lincs", "Shake"
 118     };
 119     return constraintAlgorithmNames[enumValue];
 120 }
 121
 122 const char* enumValueToString(InteractionModifiers enumValue)
 123 {
 124     static constexpr gmx::EnumerationArray<InteractionModifiers, const char*> interactionModifierNames = {
 125         "Potential-shift-Verlet", "Potential-shift", "None",
 126         "Potential-switch",       "Exact-cutoff",    "Force-switch"
 127     };
 128     return interactionModifierNames[enumValue];
 129 }
 130
 131 const char* enumValueToString(TemperatureCoupling enumValue)
 132 {
 133     static constexpr gmx::EnumerationArray<TemperatureCoupling, const char*> temperatureCouplingNames = {
 134         "No", "Berendsen", "Nose-Hoover", "yes", "Andersen", "Andersen-massive", "V-rescale"
 135     }; /* yes is alias for berendsen */
 136     return temperatureCouplingNames[enumValue];
 137 }
 138
 139 const char* enumValueToString(PressureCoupling enumValue)
 140 {
 141     static constexpr gmx::EnumerationArray<PressureCoupling, const char*> pressureCouplingNames = {
 142         "No", "Berendsen", "Parrinello-Rahman", "Isotropic", "MTTK", "C-rescale"
 143     }; /* isotropic is alias for berendsen */
 144     return pressureCouplingNames[enumValue];
 145 }
 146
 147 const char* enumValueToString(Boolean enumValue)
 148 {
 149     static constexpr gmx::EnumerationArray<Boolean, const char*> booleanNames = { "no", "yes" };
 150     return booleanNames[enumValue];
 151 }
 152
 153 const char* booleanValueToString(bool value)
 154 {
 155     Boolean enumValue = value ? Boolean::Yes : Boolean::No;
 156     return enumValueToString(enumValue);
 157 }
 158
 159 const char* enumValueToString(RefCoordScaling enumValue)
 160 {
 161     static constexpr gmx::EnumerationArray<RefCoordScaling, const char*> refCoordScalingNames = {
 162         "No", "All", "COM"
 163     };
 164     return refCoordScalingNames[enumValue];
 165 }
 166
 167 const char* enumValueToString(CutoffScheme enumValue)
 168 {
 169     static constexpr gmx::EnumerationArray<CutoffScheme, const char*> cutoffSchemeNames = {
 170         "Verlet", "Group"
 171     };
 172     return cutoffSchemeNames[enumValue];
 173 }
 174
 175 const char* enumValueToString(PressureCouplingType enumValue)
 176 {
 177     static constexpr gmx::EnumerationArray<PressureCouplingType, const char*> pressureCouplingTypeNames = {
 178         "Isotropic", "Semiisotropic", "Anisotropic", "Surface-Tension"
 179     };
 180     return pressureCouplingTypeNames[enumValue];
 181 }
 182
 183 const char* enumValueToString(DistanceRestraintRefinement enumValue)
 184 {
 185     static constexpr gmx::EnumerationArray<DistanceRestraintRefinement, const char*> distanceRestraintRefinementNames = {
 186         "No", "Simple", "Ensemble"
 187     };
 188     return distanceRestraintRefinementNames[enumValue];
 189 }
 190
 191 const char* enumValueToString(DistanceRestraintWeighting enumValue)
 192 {
 193     static constexpr gmx::EnumerationArray<DistanceRestraintWeighting, const char*> distanceRestraintWeightingNames = {
 194         "Conservative", "Equal"
 195     };
 196     return distanceRestraintWeightingNames[enumValue];
 197 }
 198
 199 const char* enumValueToString(VanDerWaalsPotential enumValue)
 200 {
 201     static constexpr gmx::EnumerationArray<VanDerWaalsPotential, const char*> vanDerWaalsPotentialNames = {
 202         "None", "LJ", "Buckingham"
 203     };
 204     return vanDerWaalsPotentialNames[enumValue];
 205 }
 206
 207 const char* enumValueToString(CombinationRule enumValue)
 208 {
 209     static constexpr gmx::EnumerationArray<CombinationRule, const char*> combinationRuleNames = {
 210         "None", "Geometric", "Arithmetic", "GeomSigEps"
 211     };
 212     return combinationRuleNames[enumValue];
 213 }
 214
 215 const char* enumValueToString(SimulatedTempering enumValue)
 216 {
 217     static constexpr gmx::EnumerationArray<SimulatedTempering, const char*> simulatedTemperingNames = {
 218         "geometric", "exponential", "linear"
 219     };
 220     return simulatedTemperingNames[enumValue];
 221 }
 222
 223 const char* enumValueToString(FreeEnergyPerturbationType enumValue)
 224 {
 225     static constexpr gmx::EnumerationArray<FreeEnergyPerturbationType, const char*> freeEnergyPerturbationTypeNames = {
 226         "no", "yes", "static", "slow-growth", "expanded"
 227     };
 228     return freeEnergyPerturbationTypeNames[enumValue];
 229 }
 230
 231 const char* enumValueToString(FreeEnergyPerturbationCouplingType enumValue)
 232 {
 233     static constexpr gmx::EnumerationArray<FreeEnergyPerturbationCouplingType, const char*> freeEnergyPerturbationCouplingTypeNames = {
 234         "fep-lambdas",    "mass-lambdas",      "coul-lambdas",       "vdw-lambdas",
 235         "bonded-lambdas", "restraint-lambdas", "temperature-lambdas"
 236     };
 237     return freeEnergyPerturbationCouplingTypeNames[enumValue];
 238 }
 239
 240 const char* enumValueToStringSingular(FreeEnergyPerturbationCouplingType enumValue)
 241 {
 242     static constexpr gmx::EnumerationArray<FreeEnergyPerturbationCouplingType, const char*> freeEnergyPerturbationCouplingTypeNames = {
 243         "fep-lambda",    "mass-lambda",      "coul-lambda",       "vdw-lambda",
 244         "bonded-lambda", "restraint-lambda", "temperature-lambda"
 245     };
 246     return freeEnergyPerturbationCouplingTypeNames[enumValue];
 247 }
 248
 249 const char* enumValueToString(FreeEnergyPrintEnergy enumValue)
 250 {
 251     static constexpr gmx::EnumerationArray<FreeEnergyPrintEnergy, const char*> freeEnergyPrintNames = {
 252         "no", "total", "potential", "yes"
 253     };
 254     return freeEnergyPrintNames[enumValue];
 255 }
 256
 257 const char* enumValueToString(LambdaWeightCalculation enumValue)
 258 {
 259     static constexpr gmx::EnumerationArray<LambdaWeightCalculation, const char*> lambdaWeightCalculationNames = {
 260         "no",     "metropolis-transition", "barker-transition",
 261         "minvar", "wang-landau",           "weighted-wang-landau"
 262     };
 263     return lambdaWeightCalculationNames[enumValue];
 264 }
 265
 266 const char* enumValueToString(LambdaMoveCalculation enumValue)
 267 {
 268     static constexpr gmx::EnumerationArray<LambdaMoveCalculation, const char*> lambdaMoveCalculationNames = {
 269         "no", "metropolis", "barker", "gibbs", "metropolized-gibbs"
 270     };
 271     return lambdaMoveCalculationNames[enumValue];
 272 }
 273
 274 const char* enumValueToString(LambdaWeightWillReachEquilibrium enumValue)
 275 {
 276     static constexpr gmx::EnumerationArray<LambdaWeightWillReachEquilibrium, const char*> lambdaWeightEquilibriumNames = {
 277         "no",         "yes", "wl-delta", "number-all-lambda", "number-steps", "number-samples",
 278         "count-ratio"
 279     };
 280     return lambdaWeightEquilibriumNames[enumValue];
 281 }
 282
 283 const char* enumValueToString(SeparateDhdlFile enumValue)
 284 {
 285     static constexpr gmx::EnumerationArray<SeparateDhdlFile, const char*> separateDhdlFileNames = {
 286         "yes", "no"
 287     };
 288     return separateDhdlFileNames[enumValue];
 289 }
 290
 291 const char* enumValueToString(SoftcoreType enumValue)
 292 {
 293     static constexpr gmx::EnumerationArray<SoftcoreType, const char*> softcoreTypeNames = {
 294         "beutler", "gapsys"
 295     };
 296     return softcoreTypeNames[enumValue];
 297 }
 298
 299 const char* enumValueToString(KernelSoftcoreType enumValue)
 300 {
 301     static constexpr gmx::EnumerationArray<KernelSoftcoreType, const char*> softcoreTypeNames = {
 302         "beutler", "gapsys", "none"
 303     };
 304     return softcoreTypeNames[enumValue];
 305 }
 306
 307 const char* enumValueToString(DhDlDerivativeCalculation enumValue)
 308 {
 309     static constexpr gmx::EnumerationArray<DhDlDerivativeCalculation, const char*> dhdlDerivativeCalculationNames = {
 310         "yes", "no"
 311     };
 312     return dhdlDerivativeCalculationNames[enumValue];
 313 }
 314
 315 const char* enumValueToString(SolventModel enumValue)
 316 {
 317     static constexpr gmx::EnumerationArray<SolventModel, const char*> solventModelNames = {
 318         "No", "SPC", "TIP4p"
 319     };
 320     return solventModelNames[enumValue];
 321 }
 322
 323 const char* enumValueToString(DispersionCorrectionType enumValue)
 324 {
 325     static constexpr gmx::EnumerationArray<DispersionCorrectionType, const char*> dispersionCorrectionTypeNames = {
 326         "No", "EnerPres", "Ener", "AllEnerPres", "AllEner"
 327     };
 328     return dispersionCorrectionTypeNames[enumValue];
 329 }
 330
 331 const char* enumValueToString(SimulatedAnnealing enumValue)
 332 {
 333     static constexpr gmx::EnumerationArray<SimulatedAnnealing, const char*> simulatedAnnealingNames = {
 334         "No", "Single", "Periodic"
 335     };
 336     return simulatedAnnealingNames[enumValue];
 337 }
 338
 339 const char* enumValueToString(WallType enumValue)
 340 {
 341     static constexpr gmx::EnumerationArray<WallType, const char*> wallTypeNames = {
 342         "9-3", "10-4", "table", "12-6"
 343     };
 344     return wallTypeNames[enumValue];
 345 }
 346
 347 const char* enumValueToString(PullingAlgorithm enumValue)
 348 {
 349     static constexpr gmx::EnumerationArray<PullingAlgorithm, const char*> pullAlgorithmNames = {
 350         "umbrella",    "constraint",       "constant-force",
 351         "flat-bottom", "flat-bottom-high", "external-potential"
 352     };
 353     return pullAlgorithmNames[enumValue];
 354 }
 355
 356 const char* enumValueToString(PullGroupGeometry enumValue)
 357 {
 358     static constexpr gmx::EnumerationArray<PullGroupGeometry, const char*> pullGroupControlNames = {
 359         "distance", "direction", "cylinder",   "direction-periodic", "direction-relative",
 360         "angle",    "dihedral",  "angle-axis", "transformation"
 361     };
 362     return pullGroupControlNames[enumValue];
 363 }
 364
 365 const char* enumValueToString(EnforcedRotationGroupType enumValue)
 366 {
 367     static constexpr gmx::EnumerationArray<EnforcedRotationGroupType, const char*> enforcedRotationGroupNames = {
 368         "iso", "iso-pf", "pm",   "pm-pf",  "rm",    "rm-pf",
 369         "rm2", "rm2-pf", "flex", "flex-t", "flex2", "flex2-t"
 370     };
 371     return enforcedRotationGroupNames[enumValue];
 372 }
 373
 374 const char* enumValueToString(RotationGroupFitting enumValue)
 375 {
 376     static constexpr gmx::EnumerationArray<RotationGroupFitting, const char*> rotationGroupFittingNames = {
 377         "rmsd", "norm", "potential"
 378     };
 379     return rotationGroupFittingNames[enumValue];
 380 }
 381
 382 const char* enumValueToString(SwapType enumValue)
 383 {
 384     static constexpr gmx::EnumerationArray<SwapType, const char*> swapTypeNames = {
 385         "no", "X", "Y", "Z"
 386     };
 387     return swapTypeNames[enumValue];
 388 }
 389
 390 const char* enumValueToString(SwapGroupSplittingType enumValue)
 391 {
 392     static constexpr gmx::EnumerationArray<SwapGroupSplittingType, const char*> swapGroupSplittingTypeNames = {
 393         "Split0", "Split1", "Solvent"
 394     };
 395     return swapGroupSplittingTypeNames[enumValue];
 396 }
 397
 398 const char* enumValueToString(NbkernelElecType enumValue)
 399 {
 400     static constexpr gmx::EnumerationArray<NbkernelElecType, const char*> nbkernelElecTypeNames = {
 401         "None", "Coulomb", "Reaction-Field", "Cubic-Spline-Table", "Ewald"
 402     };
 403     return nbkernelElecTypeNames[enumValue];
 404 }
 405
 406 const char* enumValueToString(NbkernelVdwType enumValue)
 407 {
 408     static constexpr gmx::EnumerationArray<NbkernelVdwType, const char*> nbkernelVdwTypeNames = {
 409         "None", "Lennard-Jones", "Buckingham", "Cubic-Spline-Table", "LJEwald"
 410     };
 411     return nbkernelVdwTypeNames[enumValue];
 412 }