nml_pppm.h

// -*-c++-*-
#ifndef STORMM_NML_PPPM_H
#define STORMM_NML_PPPM_H
 
#include "copyright.h"
#include "Constants/behavior.h"
#include "Parsing/parsing_enumerators.h"
#include "Parsing/textfile.h"
#include "Potential/cellgrid.h"
#include "Potential/energy_enumerators.h"
#include "input.h"
#include "namelist_emulator.h"
 
namespace stormm {
namespace namelist {
 
using constants::ExceptionResponse;
using energy::default_mesh_ticks;
using energy::maximum_cell_width;
using energy::NonbondedTheme;
using energy::VdwSumMethod;
using energy::PMIStrategy;
using parse::TextFile;
using parse::WrapTextSearch;

constexpr double max_pp_cutoff = 2.0 * maximum_cell_width;
constexpr NonbondedTheme default_pppm_theme = NonbondedTheme::ELECTROSTATIC;
constexpr PMIStrategy default_pppm_accuracy = PMIStrategy::NO_AUTOMATION;

class PPPMControls {
public:

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

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

  NonbondedTheme getTheme() const;

  int getInterpolationOrder() const;

  double getEwaldCoefficient() const;

  double getGaussianWidth() const;
  
  double getCutoff() const;

  double getDirectSumTolerance() const;

  int getMeshSubdivisions() const;

  PMIStrategy getStrategy() const;

  VdwSumMethod getVdwSummation() const;
  
  void setTheme(NonbondedTheme theme_in);
  void setTheme(const std::string &theme_in);

  void setInterpolationOrder(int order_in);

  void setEwaldCoefficient(double ewald_coefficient_in);

  void setGaussianWidth(double spread_in);

  void setCutoff(double cutoff_in);

  void setDirectSumTolerance(double dsum_tol_in);

  void setMeshSubdivisions(int mesh_ticks_in);

  void setStrategy(PMIStrategy strat_in);
  void setStrategy(const std::string &strat_in);

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

  void applyStrategy();
 
private:
  ExceptionResponse policy;  
  NonbondedTheme theme;      
  int order;                 
  double ewald_coefficient;  
  double cutoff;             
  double dsum_tol;           
  int mesh_ticks;            
  PMIStrategy strat;         
  VdwSumMethod vdw_method;   
  
  NamelistEmulator nml_transcript;

  bool validateOrder(const int order_in) const;

  bool validateEwaldCoefficient(double ewald_coefficient_in) const;

  bool validateCutoff(double cutoff_in) const;

  bool validateDirectSumTolerance(double tol_in) const;

  bool validateMeshSubdivisions(int mesh_ticks_in) const;
};

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