nml_report.h

// -*-c++-*-
#ifndef STORMM_NML_OUTPUT_H
#define STORMM_NML_OUTPUT_H
 
#include <cstring>
#include <string>
#include <vector>
#include <cstdio>
#include <sys/time.h>
#include "copyright.h"
#include "Constants/behavior.h"
#include "DataTypes/common_types.h"
#include "MoleculeFormat/mdlmol_dataitem.h"
#include "Parsing/textfile.h"
#include "Potential/energy_enumerators.h"
#include "Reporting/reporting_enumerators.h"
#include "input.h"
#include "namelist_element.h"
#include "namelist_emulator.h"
 
namespace stormm {
namespace namelist {
 
using energy::EnergySample;
using energy::StateVariable;
using parse::TextFile;
using parse::WrapTextSearch;
using review::OutputScope;
using review::OutputSyntax;
using structure::MdlMolDataRequest;

constexpr int default_common_path_limit = 8;
constexpr int default_common_path_threshold = 4;
constexpr int default_energy_decimal_places = 4;
constexpr double default_energy_outlier_sigmas = 3.0;
constexpr int default_outlier_limit = 4;
constexpr char default_report_variable_name[] = "stormm";

class ReportControls {
public:

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

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

  OutputSyntax getOutputSyntax() const;

  OutputScope getOutputScope() const;

  EnergySample getEnergySamplingMethod() const;

  
  const std::string& getUsername() const;

  const std::string& getReportVariable() const;
  
  timeval getStartDate() const;
  
  const NamelistEmulator& getTranscript() const;
  
  bool printWallTimeData() const;

  int getReportFileWidth() const;
  
  int getReportedQuantityCount() const;
  
  const std::vector<StateVariable>& getReportedQuantities() const;

  int getSDFileDataRequestCount() const;
  
  const std::vector<MdlMolDataRequest>& getSDFileDataRequests() const;

  MdlMolDataRequest getSDFileDataRequest(int index) const;

  int getCommonPathLimit() const;

  int getCommonPathThreshold() const;

  int getEnergyDecimalPlaces() const;

  double getOutlierSigmaFactor() const;

  int getOutlierCount() const;
  
  void setOutputSyntax(OutputSyntax report_layout_in);
  void setOutputSyntax(const std::string &report_layout_in);

  void setOutputScope(OutputScope report_scope_in);
  void setOutputScope(const std::string &report_scope_in);

  void setStateSampling(EnergySample state_sampling_in);
  void setStateSampling(const std::string &state_sampling_in);
  
  void setUsername(const std::string &username_in);

  void setReportVariable(const std::string &report_variable_in);
  
  void setWallTimeData(bool preference);
  void setWallTimeData(const std::string &preference);

  void setReportFileWidth(int report_file_width_in);
  
  void setReportedQuantities(const std::string &quantity_in);
  void setReportedQuantities(StateVariable quantities_in);
  void setReportedQuantities(const std::vector<StateVariable> &quantities_in);
  
  void addDataItem(const MdlMolDataRequest &ask);

  void setCommonPathLimit(int common_path_limit_in);
  
  void setCommonPathThreshold(int common_path_threshold);

  void setEnergyDecimalPlaces(int energy_decimal_places_in);
  
private:
  ExceptionResponse policy;     
  OutputSyntax report_layout;   
  OutputScope report_scope;     
  EnergySample state_sampling;  
  std::string username;         
  std::string report_variable;  
  timeval start_date;           
  bool print_walltime_data;     
  int report_file_width;        
  int common_path_limit;        
  int common_path_threshold;    
  int energy_decimal_places;    
  double outlier_sigma_factor;  
  int outlier_count;            
  
  std::vector<StateVariable> reported_quantities;

  std::vector<MdlMolDataRequest> sdf_addons;

  NamelistEmulator nml_transcript;
  
  std::vector<StateVariable> translateEnergyComponent(const std::string &inpstr);

  std::vector<StateVariable> translateStateQuantity(const std::string &inpstr);
  
  std::vector<MdlMolDataRequest> translateSdfKeywordInput(const NamelistEmulator &t_nml,
                                                          int index);

  void validateEnergyDecimalPlaces();

  void validateOutlierMetrics();
};

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