energy_enumerators.h

// -*-c++-*-
#ifndef STORMM_ENERGY_ENUMERATORS_H
#define STORMM_ENERGY_ENUMERATORS_H
 
#include <string>
#include "copyright.h"
 
namespace stormm {
namespace energy {

enum class EvaluateEnergy {
  NO, YES
};

enum class EvaluateForce {
  NO, YES
};

enum class EvaluateVirial {
  NO, YES
};

enum class DihedralStyle {
  COSINE, HARMONIC
};

enum class StateVariable {
  BOND = 0,               
  ANGLE,                  
  PROPER_DIHEDRAL,        
  IMPROPER_DIHEDRAL,      
  UREY_BRADLEY,           
  CHARMM_IMPROPER,        
  CMAP,                   
  VDW,                    
  VDW_ONE_FOUR,           
  ELECTROSTATIC,          
  ELEC_ONE_FOUR,          
  GENERALIZED_BORN,       
  RESTRAINT,              
  SURFACE_AREA,           
  KINETIC,                
  PRESSURE,               
  VIRIAL_11,              
  VIRIAL_12,              
  VIRIAL_22,              
  VIRIAL_13,              
  VIRIAL_23,              
  VIRIAL_33,              
  VOLUME,                 
  TEMPERATURE_ALL,        
  TEMPERATURE_PROTEIN,    
  TEMPERATURE_LIGAND,     
  TEMPERATURE_SOLVENT,    
  DU_DLAMBDA,             
  POTENTIAL_ENERGY,       
  TOTAL_ENERGY,           
  ALL_STATES              
};

enum class NonbondedPotential {
  ELECTROSTATIC,  
  VAN_DER_WAALS,  
  CLASH           
};

enum class NonbondedTask {
  PME_PARTICLE_PARTICLE, 
  PARTICLE_TO_MESH,      
  CONVOLUTION,           
  MESH_TO_PARTICLE,      
  GB_PARTICLE_PARTICLE,  
  GB_RADII,              
  GB_RADII_DERIVATIVES   
};
  
enum class NonbondedTheme {
  ELECTROSTATIC,  
  VAN_DER_WAALS,  
  ALL             
};

enum class DecomposablePotential {
  ELECTROSTATIC,   
  DISPERSION,      
  ELEC_PME_DIRECT  
};
  
enum class VdwCombiningRule {
  LORENTZ_BERTHELOT,  
  GEOMETRIC,          
  NBFIX               
};

enum class VdwSumMethod {
  CUTOFF,  
  SMOOTH,  
  PME      
};

enum class ClashResponse {
  NONE,    
  FORGIVE  
};

enum class EnergySample {
  TIME_SERIES,  
  FINAL,        
  TIME_AVERAGE  
};

enum class SplineScaffold {
  LINEAR,           
  SIGMOIDAL,        
  QUADRATIC_HILL,   
  QUADRATIC_VALLEY  
};

enum class CellGridAction {
  INIT_FORCES,       
  XFER_FORCES        
};

enum class QMapMethod {
  ACC_SHARED,       
  GENERAL_PURPOSE,  
  AUTOMATIC         
};

enum class PMIStrategy {
  RECOMMENDED,           
  TIGHT,                 
  VERY_TIGHT,            
  RECOMMENDED_PM_HEAVY,  
  RECOMMENDED_PP_HEAVY,  
  TIGHT_PM_HEAVY,        
  TIGHT_PP_HEAVY,        
  NO_AUTOMATION          
};

enum class NeighborListKind {
  MONO,  
  DUAL   
};

enum class TinyBoxPresence {
  YES,  
  NO    
};
  
enum class ValenceKernelSize {
  XL = 0,  
  LG,      
  MD,      
  SM       
};

enum class SasaReference {
  LENNARD_JONES_SIGMA,  
  BORN_RADII            
};
  
std::string getEnumerationName(EvaluateForce input);
std::string getEnumerationName(EvaluateEnergy input);
std::string getEnumerationName(EvaluateVirial input);
std::string getEnumerationName(DihedralStyle input);
std::string getEnumerationName(StateVariable input);
std::string getEnumerationName(NonbondedPotential input);
std::string getEnumerationName(NonbondedTask input);
std::string getEnumerationName(NonbondedTheme input);
std::string getEnumerationName(DecomposablePotential input);
std::string getEnumerationName(VdwCombiningRule input);
std::string getEnumerationName(VdwSumMethod input);
std::string getEnumerationName(ClashResponse input);
std::string getEnumerationName(EnergySample input);
std::string getEnumerationName(SplineScaffold input);
std::string getEnumerationName(CellGridAction input);
std::string getEnumerationName(QMapMethod input);
std::string getEnumerationName(PMIStrategy input);
std::string getEnumerationName(NeighborListKind input);
std::string getEnumerationName(TinyBoxPresence input);
std::string getEnumerationName(ValenceKernelSize input);
std::string getEnumerationName(SasaReference input);

NonbondedPotential translateNonbondedPotential(const std::string &input);

NonbondedTheme translateNonbondedTheme(const std::string &input);

EnergySample translateEnergySample(const std::string &input);
  
PMIStrategy translatePMIStrategy(const std::string &input);

VdwSumMethod translateVdwSumMethod(const std::string &input);
 
} // namespace energy
} // namespace stormm
 
#endif