nml_minimize.h

// -*-c++-*-
#ifndef STORMM_NML_MINIMIZE_H
#define STORMM_NML_MINIMIZE_H
 
#include "copyright.h"
#include "Constants/behavior.h"
#include "Parsing/textfile.h"
#include "Potential/energy_enumerators.h"
#include "input.h"
#include "namelist_common.h"
#include "namelist_emulator.h"
 
namespace stormm {
namespace namelist {
 
using energy::VdwSumMethod;
using parse::WrapTextSearch;

constexpr int default_minimize_maxcyc         = 200;
constexpr int default_minimize_ncyc           = 50;
constexpr int default_minimize_cdcyc          = 25;
constexpr int default_minimize_ntpr           = 50;
constexpr char default_minimize_checkpoint[]  = "true";
constexpr double default_minimize_cut         = 8.0;
constexpr double default_minimize_dx0         = 0.01;
constexpr double default_minimize_drms        = 0.0001;
constexpr double default_minimize_clash_r0    = 0.2;
constexpr double default_minimize_clash_ratio = 0.5;
  
class MinimizeControls {
public:

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

  MinimizeControls(const MinimizeControls &original) = default;
  MinimizeControls(MinimizeControls &&original) = default;
  MinimizeControls& operator=(const MinimizeControls &original) = default;
  MinimizeControls& operator=(MinimizeControls &&original) = default;

  int getTotalCycles() const;

  int getSteepestDescentCycles() const;

  int getClashDampingCycles() const;
  
  int getDiagnosticPrintFrequency() const;

  bool getCheckpointProduction() const;
  
  double getElectrostaticCutoff() const;
  
  double getLennardJonesCutoff() const;

  VdwSumMethod getVdwSummation() const;
  
  double getInitialStep() const;

  double getConvergenceTarget() const;

  double getAbsoluteClashDistance() const;

  double getVdwClashRatio() const;

  const NamelistEmulator& getTranscript() const;
  
  void setTotalCycles(int cycles_in);
  
  void setSteepestDescentCycles(int cycles_in);

  void setClashDampingCycles(int cycles_in);

  void setAbsoluteClashDistance(double clash_minimum_distance_in);

  void setVdwClashRatio(double clash_vdw_ratio_in);
  
  void setDiagnosticPrintFrequency(int frequency_in);

  void setCheckpointProduction(bool produce_in);
  
  void setElectrostaticCutoff(double cutoff_in);
  
  void setLennardJonesCutoff(double cutoff_in);

  void setVdwSummation(const std::string &vdw_method_in);
  void setVdwSummation(const VdwSumMethod vdw_method_in);
  
  void setInitialStep(double step_size_in);

  void setConvergenceTarget(double target_in);
  
private:
  ExceptionResponse policy;       
  int total_cycles;               
  int steepest_descent_cycles;    
  int clash_damping_cycles;       
  int print_frequency;            
  bool produce_checkpoint;        
  double electrostatic_cutoff;    
  double lennard_jones_cutoff;    
  VdwSumMethod lj_style;          
  double initial_step;            
  double convergence_target;      
  double clash_minimum_distance;  
  double clash_vdw_ratio;         

  NamelistEmulator nml_transcript;
  
  void validateTotalCycles();

  void validateAuxiliaryCycles(int *cycles_in, int default_cycles);
  
  void validatePrintFrequency();

  void validateCheckpointProduction(const std::string &directive) const;
  
  void validateInitialStep();

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