nml_mesh.h

// -*-c++-*-
#ifndef STORMM_NML_MESH_H
#define STORMM_NML_MESH_H
 
#include <string>
#include <vector>
#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 "namelist_element.h"
#include "namelist_emulator.h"
 
namespace stormm {
namespace namelist {
 
using constants::CartesianDimension;
using constants::ExceptionResponse;
using constants::UnitCellAxis;
using energy::NonbondedPotential;
using parse::TextFile;
using parse::WrapTextSearch;
using structure::BoundaryCondition;
using structure::GridDetail;
using structure::MeshPosition;
using structure::RMSDMethod;

constexpr int default_mesh_grid_dim = -1;
constexpr int default_mesh_density_averaging_order = 8;
constexpr double default_mesh_grid_angle = 0.5 * symbols::pi;
constexpr double default_mesh_grid_origin = 0.0;
constexpr double default_mesh_grid_spacing = 1.0;
constexpr double default_mesh_elec_damping_range = 0.5;
constexpr double default_mesh_vdw_damping_ratio = 0.8;
constexpr char default_mesh_grid_detail[] = "occlusion";
constexpr char default_mesh_grid_potential[] = "clash";
constexpr char default_mesh_grid_boundary[] = "isolated";

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

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

  int getAxisElementCount(UnitCellAxis dim) const;
  int getAxisElementCount(CartesianDimension dim) const;

  double getSpacing(UnitCellAxis dim) const;
  double getSpacing(CartesianDimension dim) const;

  double getAlpha() const;

  double getBeta() const;

  double getGamma() const;
  
  double getOrigin(CartesianDimension dim) const;

  double getBufferWidth(UnitCellAxis dim) const; 
  double getBufferWidth(CartesianDimension dim) const;

  GridDetail getDetail() const;

  NonbondedPotential getPotential() const;
  
  BoundaryCondition getBoundaries() const;
  
  MeshPosition getPosition() const;

  int getScalingBits() const;

  double getElecClashDistance() const;

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

  void setElementCount(int mesh_points_in, UnitCellAxis dim);
  void setElementCount(int mesh_points_in, CartesianDimension dim);

  void setSpacing(double mesh_spacing_in, UnitCellAxis dim);
  void setSpacing(double mesh_spacing_in, CartesianDimension dim);

  void setAlphaAngle(double alpha_in);

  void setBetaAngle(double beta_in);

  void setGammaAngle(double gamma_in);

  void setOrigin(double mesh_origin_in, CartesianDimension dim);

  void setBufferWidth(double buffer_width_in);
  void setBufferWidth(double buffer_width_in, UnitCellAxis dim);
  void setBufferWidth(double buffer_width_in, CartesianDimension dim);

  void setDetail(const std::string &kind_in);
  void setDetail(GridDetail kind_in);
  
  void setPotential(const std::string &potential_in);
  void setPotential(NonbondedPotential potential_in);

  void setBoundaries(const std::string &boundaries_in);
  void setBoundaries(BoundaryCondition boundaries_in);

  void setScalingBits(int mesh_scaling_bits_in);

  void setElecClashDistance(double clash_distance_in);

  void setVdwClashRatio(double clash_ratio_in);
  
private:
  ExceptionResponse policy;  
  int mesh_points_a;         
  int mesh_points_b;         
  int mesh_points_c;         
  double mesh_spacing_a;     
  double mesh_spacing_b;     
  double mesh_spacing_c;     
  double mesh_alpha;         
  double mesh_beta;          
  double mesh_gamma;         
  double mesh_origin_x;      
  double mesh_origin_y;      
  double mesh_origin_z;      
  double buffer_width_a;     
  double buffer_width_b;     
  double buffer_width_c;     
  std::string kind;          
  std::string potential;     
  std::string boundaries;    
  int mesh_scaling_bits;     
  double clash_distance;     
  double clash_ratio;        

  NamelistEmulator nml_transcript;

  void validateMeshElement();
};

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