nml_files.h

// -*-c++-*-
#ifndef STORMM_NML_FILES_H
#define STORMM_NML_FILES_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "Constants/behavior.h"
#include "Parsing/textfile.h"
#include "Trajectory/trajectory_enumerators.h"
#include "input.h"
#include "namelist_emulator.h"
 
namespace stormm {
namespace namelist {
 
using constants::ExceptionResponse;
using constants::ModificationPolicy;
using parse::WrapTextSearch;
using trajectory::CoordinateFileKind;
using trajectory::TrajectoryFusion;

constexpr bool default_filecon_read_all_free = false;
constexpr char default_filecon_topology_name[] = "prmtop";
constexpr char default_filecon_coordinate_name[] = "inpcrd";
constexpr char default_filecon_report_name[] = "md.out";
constexpr char default_filecon_trajectory_name[] = "md.crd";
constexpr char default_filecon_checkpoint_name[] = "md.rst";
constexpr char default_filecon_warnings_name[] = "warn.out";
constexpr char default_filecon_errors_name[] = "err.out";
constexpr char default_filecon_result_fusion[] = "AUTO";
constexpr char default_filecon_sdf_mod_policy[] = "NO";
constexpr char default_filecon_sdf_notification[] = "WARN";
constexpr CoordinateFileKind default_filecon_inpcrd_type = CoordinateFileKind::UNKNOWN;
constexpr CoordinateFileKind default_filecon_outcrd_type = CoordinateFileKind::AMBER_CRD;
constexpr CoordinateFileKind default_filecon_chkcrd_type = CoordinateFileKind::AMBER_ASCII_RST;
constexpr char default_filecon_inpcrd_type_name[] = "AMBER_INPCRD";
constexpr char default_filecon_outcrd_type_name[] = "AMBER_CRD";
constexpr char default_filecon_chkcrd_type_name[] = "AMBER_ASCII_RST";

class MoleculeSystem {
public:

  MoleculeSystem();
  MoleculeSystem(const std::string &topology_file_in, const std::string &coordinate_file_in,
                 const std::string &trajectory_file_in, const std::string &checkpoint_file_in,
                 const std::string &label_in, int frame_start_in, int frame_end_in,
                 int replica_count_in, CoordinateFileKind coordinate_kind_in,
                 CoordinateFileKind trajectory_kind_in, CoordinateFileKind checkpoint_kind_in);

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

  const std::string& getTopologyFileName() const;

  const std::string& getInputCoordinateFileName() const;

  const std::string& getTrajectoryFileName() const;

  const std::string& getCheckpointFileName() const;

  const std::string& getLabel() const;

  int getStartingFrame() const;

  int getFinalFrame() const;

  int getTotalFrames() const;

  int getReplicaCount() const;

  CoordinateFileKind getInputCoordinateFileKind() const;

  CoordinateFileKind getTrajectoryFileKind() const;

  CoordinateFileKind getCheckpointFileKind() const;

  void setTopologyFileName(const std::string &file_name);

  void setInputCoordinateFileName(const std::string &file_name);

  void setTrajectoryFileName(const std::string &file_name);

  void setCheckpointFileName(const std::string &file_name);

  void setStartingFrame(int frame_number);

  void setFinalFrame(int frame_number);

  void setReplicaCount(int count);

  void setInputCoordinateFileKind(const std::string &kind);
  void setInputCoordinateFileKind(CoordinateFileKind kind);

  void setTrajectoryFileKind(const std::string &kind);
  void setTrajectoryFileKind(CoordinateFileKind kind);

  void setCheckpointFileKind(const std::string &kind);
  void setCheckpointFileKind(CoordinateFileKind kind);
  
  bool validateTopologyFile() const;

  bool validateInputCoordinateFile() const;
  
private:
  std::string topology_file_name;      
  std::string coordinate_file_name;    
  std::string coordinate_output_name;  
  std::string checkpoint_name;         
  std::string label;                   
  int frame_start;                     
  int frame_end;                       
  int replica_count;                   
  CoordinateFileKind coordinate_kind;  
  CoordinateFileKind trajectory_kind;  
  CoordinateFileKind checkpoint_kind;  
};

class FilesControls {
public:

  FilesControls(ExceptionResponse policy_in = ExceptionResponse::DIE,
                WrapTextSearch wrap = WrapTextSearch::NO);
  FilesControls(const TextFile &tf, int *start_line, bool *found_nml = nullptr,
                ExceptionResponse policy_in = ExceptionResponse::DIE,
                WrapTextSearch wrap = WrapTextSearch::NO,
                const std::vector<std::string> &alternatives = {},
                const std::vector<std::string> &sys_requirements = {"-pe", "-ce"});

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

  int getStructureCount() const;

  int getFreeTopologyCount() const;

  int getFreeCoordinatesCount() const;

  int getSystemDefinitionCount() const;

  bool readAllFreeFrames() const;
  
  CoordinateFileKind getOutputCoordinateFormat() const;
  
  CoordinateFileKind getCheckpointFormat() const;
  
  TrajectoryFusion getFileFusionProtocol() const;
  
  std::string getFreeTopologyName(int index) const;
  std::vector<std::string> getFreeTopologyNames() const;

  std::string getFreeCoordinateName(int index) const;
  std::vector<std::string> getFreeCoordinateNames() const;

  MoleculeSystem getSystem(int index) const;

  std::string getReportFile() const;

  std::string getInputTranscriptFile() const;
  
  std::string getTrajectoryFileName() const;

  std::string getCheckpointFileName() const;

  std::string getWarningFileName() const;

  ModificationPolicy getSdfModificationPolicy() const;

  ExceptionResponse getSdfNotifications() const;

  const NamelistEmulator& getTranscript() const;
  
  void setAllFreeFrameReading(const bool active);
  
  void setOutputCoordinateFormat(const std::string &traj_kind);
  void setOutputCoordinateFormat(CoordinateFileKind traj_kind);
  
  void setCheckpointFormat(const std::string &chk_kind);
  void setCheckpointFormat(CoordinateFileKind chk_kind);

  void addFreeTopologyName(const std::string &file_name);

  void removeFreeTopologyName(int index, int stretch = 1);
  void removeFreeTopologyName(const std::string &fname);
  
  void addFreeCoordinateName(const std::string &file_name);

  void removeFreeCoordinateName(int index, int stretch = 1);
  void removeFreeCoordinateName(const std::string &fname);

  void addSystem(const MoleculeSystem &new_mol);

  void removeSystem(int index, int stretch = 1);

  void setReportFileName(const std::string &file_name);

  void setInputTranscriptFileName(const std::string &file_name);
  
  void setGeneralTrajectoryFileName(const std::string &proto_name);

  void setGeneralCheckpointFileName(const std::string &proto_name);

  void setWarningFileName(const std::string &file_name);

  void setSdfModficiationPolicy(ModificationPolicy policy_in);
  
  void setSdfNotifications(ExceptionResponse policy_in);
  
private:

  ExceptionResponse policy;
  
  // Counts of critical data
  int structure_count;          
  int free_topology_count;      
  int free_coordinate_count;    
  int system_count;             
  bool all_free_frames;         
  TrajectoryFusion fuse_files;  

  CoordinateFileKind coordinate_input_format;
  
  CoordinateFileKind coordinate_output_format;

  CoordinateFileKind coordinate_checkpoint_format;

  std::vector<std::string> topology_file_names;

  std::vector<std::string> coordinate_file_names;

  std::vector<MoleculeSystem> systems;

  std::string report_file;

  std::string input_transcript_file;
  
  std::string coordinate_output_name;

  std::string checkpoint_name;

  std::string warning_file_name;

  ModificationPolicy sdf_mod_policy;

  ExceptionResponse sdf_mod_alert;

  NamelistEmulator nml_transcript;
};
  
NamelistEmulator
filesInput(const TextFile &tf, int *start_line, bool *found,
           const std::vector<KeyRequirement> &sys_keyword_reqs,
           ExceptionResponse policy = ExceptionResponse::DIE,
           WrapTextSearch wrap = WrapTextSearch::NO,
           CoordinateFileKind crd_input_format = default_filecon_inpcrd_type,
           CoordinateFileKind crd_output_format = default_filecon_outcrd_type,
           CoordinateFileKind crd_checkpoint_format = default_filecon_chkcrd_type);
 
NamelistEmulator
filesInput(const TextFile &tf, int *start_line, bool *found, ExceptionResponse policy,
           WrapTextSearch wrap);
 
} // namespace namelist
} // namespace stormm
 
#endif