nml_dynamics.h

// -*-c++-*-
#ifndef STORMM_NML_DYNAMICS_H
#define STORMM_NML_DYNAMICS_H
 
#include "copyright.h"
#include "Constants/behavior.h"
#include "Parsing/textfile.h"
#include "Potential/energy_enumerators.h"
#include "Structure/structure_enumerators.h"
#include "Trajectory/trajectory_enumerators.h"
#include "input.h"
#include "namelist_common.h"
#include "namelist_emulator.h"
 
namespace stormm {
namespace namelist {
 
using constants::PrecisionModel;
using energy::VdwSumMethod;
using parse::WrapTextSearch;
using structure::ApplyConstraints;
using structure::RattleMethod;
using trajectory::ThermostatKind;
  
constexpr int default_dynamics_nstlim = 100;

constexpr int default_dynamics_ntpr = 0;
constexpr int default_dynamics_ntwx = 0;

constexpr int default_dynamics_nscm = 10000;
  
constexpr double default_dynamics_time_step = 1.0;

constexpr double default_rattle_tolerance = 1.0e-6;

constexpr int default_rattle_max_iter = 20;

constexpr char default_geometry_constraint_behavior[] = "off";
  
constexpr char default_rattle_protocol[] = "sequential";
  
constexpr double minimum_dynamics_time_step = 0.0009765625;

constexpr double minimum_rattle_tolerance = 1.0e-9;

constexpr int maximum_rattle_iterations = 100;

constexpr char default_thermostat_kind[] = "none";

constexpr char default_thermostat_cache_config[] = "single";
  
constexpr int maximum_thermostat_cache_depth = 15;

constexpr int default_thermostat_cache_depth = 1;

constexpr int default_andersen_frequency = 10000;

constexpr double default_langevin_frequency = 0.001;

constexpr double default_simulation_temperature = 298.15;

constexpr int default_thermostat_random_seed = 1329440765;

constexpr int default_tstat_evo_window_start = 0;
constexpr int default_tstat_evo_window_end   = 0;

constexpr int maximum_nt_warp_multiplicity = 8;
constexpr int default_nt_warp_multiplicity = 1;

class DynamicsControls {
public:

  DynamicsControls(ExceptionResponse policy_in = ExceptionResponse::DIE);
  
  DynamicsControls(const TextFile &tf, int *start_line, bool *found_nml,
                   ExceptionResponse policy_in = ExceptionResponse::DIE,
                   WrapTextSearch wrap = WrapTextSearch::NO);

  DynamicsControls(const DynamicsControls &original) = default;
  DynamicsControls(DynamicsControls &&original) = default;
  DynamicsControls& operator=(const DynamicsControls &original) = default;
  DynamicsControls& operator=(DynamicsControls &&original) = default;
  
  int getStepCount() const;

  int getDiagnosticPrintFrequency() const;
  
  int getTrajectoryPrintFrequency() const;

  int getCenterOfMassMotionPurgeFrequency() const;
  
  double getTimeStep() const;

  double getElectrostaticCutoff() const;
    
  double getVanDerWaalsCutoff() const;

  VdwSumMethod getVdwSummation() const;

  double getCoulombConstant() const;

  double getElec14Screening() const;
  
  double getVdw14Screening() const;

  bool coulombSetByUser() const;

  bool elec14SetByUser() const;
  
  bool vdw14SetByUser() const;
  
  ApplyConstraints constrainGeometry() const;

  ApplyConstraints useShake() const;

  ApplyConstraints useSettle() const;

  double getRattleTolerance() const;

  int getRattleIterations() const;

  RattleMethod getCpuRattleMethod() const;

  ThermostatKind getThermostatKind() const;

  int getThermostatEvolutionStart() const;

  int getThermostatEvolutionEnd() const;
  
  int getThermostatCacheDepth() const;

  int getThermostatSeed() const;

  int getThermostatLayerCount() const;

  int getAndersenFrequency() const;

  double getLangevinFrequency() const;
  
  PrecisionModel getThermostatCacheConfig() const;
  
  const std::vector<double>& getInitialTemperatureTargets() const;

  const std::vector<double>& getFinalTemperatureTargets() const;

  const std::vector<std::string>& getThermostatLabels() const;

  const std::vector<int>& getThermostatLabelIndices() const;

  const std::vector<std::string>& getThermostatMasks() const;

  int getNTWarpMultiplicity() const;
  
  const NamelistEmulator& getTranscript() const;
  
  void setStepCount(int total_step_count_in);

  void setDiagnosticPrintFrequency(int diagnostic_frequency_in);
  
  void setTrajectoryPrintFrequency(int trajectory_frequency_in);

  void setCenterOfMassMotionPurgeFrequency(int com_motion_purge_ferquency_in);
  
  void setTimeStep(double time_step_in);

  void setElectrostaticCutoff(double cutoff_in);

  void setVanDerWaalsCutoff(double cutoff_in);

  void setCutoff(double cutoff_in);

  void setVdwSummation(const std::string &vdw_method_in);
  void setVdwSummation(const VdwSumMethod vdw_method_in);
  
  void setCoulombConstant(double coulomb_in);

  void setElec14Screening(double screening_in);
  
  void setVdw14Screening(double screening_in);
  
  void setGeometricConstraints(const std::string &constrain_geometry_in);
  void setGeometricConstraints(ApplyConstraints constrain_geometry_in = ApplyConstraints::YES);

  void setUseShake(const std::string &use_shake_in);
  void setUseShake(ApplyConstraints use_shake_in = ApplyConstraints::YES);
  
  void setUseSettle(const std::string &use_settle_in);
  void setUseSettle(ApplyConstraints use_settle_in = ApplyConstraints::YES);
  
  void setCpuRattleMethod(const std::string &rattle_protocol_in);
  
  void setRattleTolerance(double rattle_tolerance_in);

  void setThermostatKind(const std::string &thermostat_kind_in);
  void setThermostatKind(ThermostatKind thermostat_kind_in);

  void setThermostatEvolutionStart(int thermo_evolution_start_in);

  void setThermostatEvolutionEnd(int step_number);

  void setThermostatCacheDepth(int depth_in);

  void setThermostatSeed(int igseed);

  void setAndersenFrequency(int frequency_in);

  void setLangevinFrequency(double frequency_in);

  void setThermostatCacheConfig(const std::string &cache_config_in);
  void setThermostatCacheConfig(PrecisionModel cache_config_in);

  void setThermostatGroup(double initial_target = default_simulation_temperature,
                          double final_target = default_simulation_temperature,
                          const std::string &label = std::string("all"), int label_index = -1,
                          const std::string &mask = std::string("@="));

  void setNTWarpMultiplicity(int mult_in);
 
private:
  ExceptionResponse policy;        
  int total_step_count;            
  int diagnostic_frequency;        
  int trajectory_frequency;        
  int com_motion_purge_frequency;  
  double time_step;                
  double electrostatic_cutoff;     
  double van_der_waals_cutoff;     
  double coulomb;                  
  VdwSumMethod vdw_style;          
  double elec_14_screening;        
  double vdw_14_screening;         
  bool coulomb_set_by_user;        
  bool elec_14_set_by_user;        
  bool vdw_14_set_by_user;         
  std::string constrain_geometry;  
  std::string use_shake;           
  std::string use_settle;          
  double rattle_tolerance;         
  int rattle_iterations;           
  std::string rattle_protocol;     
  std::string thermostat_kind;     
  int thermo_evolution_start;      
  int thermo_evolution_end;        
  int thermostat_cache_depth;      
  int thermostat_seed;             
  int andersen_frequency;          
  double langevin_frequency;       
  int nt_warp_multiplicity;        
  
  std::string thermostat_cache_config;    
  
  std::vector<double> initial_temperature_targets;

  std::vector<double> final_temperature_targets;

  std::vector<std::string> thermostat_labels;

  std::vector<int> thermostat_label_indices;

  std::vector<std::string> thermostat_masks;

  NamelistEmulator nml_transcript;
  
  void validateStepCount();

  void validateDiagnosticPrintFrequency();
  
  void validateTrajectoryPrintFrequency();

  void validateCenterOfMassMotionPurgeFrequency();
  
  void validateTimeStep();

  void validateRattleTolerance();

  void validateRattleIterations();

  void validateTemperature(double t) const;
  
  void validateThermostatKind();

  void validateCacheDepth();
  
  void validateCacheConfiguration();

  void validateNTWarpMultiplicity();
};
  
NamelistEmulator dynamicsInput(const TextFile &tf, int *start_line, bool *found,
                               ExceptionResponse policy = ExceptionResponse::DIE,
                               WrapTextSearch wrap = WrapTextSearch::NO);
 
} // namespace namelist
} // namespace stormm
 
#endif