nml_remd.h

// -*-c++-*-
#ifndef STORMM_NML_REMD_H
#define STORMM_NML_REMD_H
 
#include "copyright.h"
#include "Constants/behavior.h"
#include "Constants/symbol_values.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_emulator.h"
 
namespace stormm {
namespace namelist {
 
using constants:: CartesianDimension;
using constants::PrecisionModel;
using constants::ExceptionResponse;
using parse::TextFile;
using parse::WrapTextSearch;
using structure::ApplyConstraints;
 
constexpr int default_total_swaps = 0;
constexpr char default_remd_type[] = "Temperature";
constexpr int default_freq_swaps = 500;
constexpr char default_swap_store[] = "Successful";
constexpr char default_temp_distribution[] = "Van Der Spoel";
constexpr double default_exchange_probability = 0.2;
constexpr double default_tolerance = 0.00001;
constexpr int default_max_replicas = 1000;
constexpr double default_low_temperature = 298.15;
constexpr double default_high_temperature = 398.15;
 
class RemdControls {
public:

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

  RemdControls(const RemdControls &original) = default;
  RemdControls(RemdControls &&original) = default;
  RemdControls& operator=(const RemdControls &original) = default;
  RemdControls& operator=(RemdControls &&original) = default;
    
  int getTotalSwapCount() const;

  std::string getRemdType() const;

  int getFrequencyOfSwaps() const;

  std::string getSwapStore() const;
  
  std::string getTemperatureDistributionMethod() const;

  double getExchangeProbability() const;

  double getTolerance() const;

  int getMaxReplicas() const;
  
  // TODO: Change this to just a double
  double getLowTemperature() const;

  double getHighTemperature() const;
  
  const NamelistEmulator& getTranscript() const;

  void setTotalSwapCount(int total_swap_count_in);
  
  void setRemdType(std::string remd_type_in);

  void setFrequencyOfSwaps(int frequency_swaps_in);

  void setSwapStore(std::string swap_store_in);

  void setTemperatureDistributionMethod(std::string temperature_dist_in);

  void setExchangeProbability(double exchange_probability_in);

  void setTolerance(double tolerance_in);

  void setMaxReplicas(int max_replicas_in);

  void setLowTemperature(double low_temperature_in);

  void setHighTemperature(double high_temperature_in);
 
private:
  ExceptionResponse policy;      
  int total_swap_count;          
  std::string remd_type;         
  int frequency_swaps;           
  std::string swap_store;        
  std::string temperature_dist;  
  double exchange_probability;   
  double tolerance;              
  int max_replicas;              

  double low_temperature;

  double high_temperature;

  NamelistEmulator nml_transcript;
    
  void validateSwapCount();
    
  void validateRemdKind();

  void validateFreqOrTotalSwaps();

  void validateSwapFrequency();

  void validateSwapStore();
 
  void validateTemperature();

  void validateTemperatureDistribution();

  void validateExchangeProbability();

  void validateTolerance();

  void validateMaxReplicas();
};

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