systemcache.h

// -*-c++-*-
#ifndef STORMM_SYSTEM_PREP_H
#define STORMM_SYSTEM_PREP_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/gpu_details.h"
#include "Chemistry/chemical_features.h"
#include "Chemistry/chemistry_enumerators.h"
#include "Constants/behavior.h"
#include "Constants/fixed_precision.h"
#include "FileManagement/file_enumerators.h"
#include "MoleculeFormat/mdlmol.h"
#include "Namelists/nml_dynamics.h"
#include "Namelists/nml_files.h"
#include "Namelists/nml_restraint.h"
#include "Potential/forward_exclusionmask.h"
#include "Potential/static_exclusionmask.h"
#include "Restraints/restraint_apparatus.h"
#include "Topology/atomgraph.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/phasespace.h"
#include "Trajectory/trajectory_enumerators.h"
#include "UnitTesting/stopwatch.h"
#include "atomgraph_synthesis.h"
#include "phasespace_synthesis.h"
#include "static_mask_synthesis.h"
 
namespace stormm {
namespace synthesis {
 
using card::GpuDetails;
using chemistry::ChemicalFeatures;
using chemistry::MapRotatableGroups;
using constants::ExceptionResponse;
using diskutil::PrintSituation;
using energy::ForwardExclusionMask;
using energy::StaticExclusionMask;
using namelist::DynamicsControls;
using namelist::FilesControls;
using namelist::RestraintControls;
using numerics::default_globalpos_scale_bits;
using numerics::default_velocity_scale_bits;
using numerics::default_force_scale_bits;
using restraints::RestraintApparatus;
using structure::MdlMol;
using testing::StopWatch;
using topology::AtomGraph;
using trajectory::CoordinateFileKind;
using trajectory::CoordinateFileRole;
using trajectory::CoordinateFrame;
using trajectory::CoordinateFrameReader;
using trajectory::CoordinateFrameWriter;
using trajectory::detectCoordinateFileKind;
using trajectory::PhaseSpace;
using trajectory::TrajectoryFusion;

class SystemCache {
public:

  SystemCache(ExceptionResponse policy_in = ExceptionResponse::DIE,
              MapRotatableGroups map_chemfe_rotators = MapRotatableGroups::NO,
              PrintSituation expectation_in = PrintSituation::OPEN_NEW);
 
  SystemCache(const FilesControls &fcon, const std::vector<RestraintControls> &rstcon,
              const DynamicsControls &dyncon, ExceptionResponse policy_in = ExceptionResponse::DIE,
              MapRotatableGroups map_chemfe_rotators = MapRotatableGroups::NO,
              PrintSituation expectation_in = PrintSituation::OPEN_NEW,
              StopWatch *timer_in = nullptr);
 
  SystemCache(const FilesControls &fcon, const DynamicsControls &dyncon,
              ExceptionResponse policy_in = ExceptionResponse::DIE,
              MapRotatableGroups map_chemfe_rotators = MapRotatableGroups::NO,
              PrintSituation expectation_in = PrintSituation::OPEN_NEW,
              StopWatch *timer_in = nullptr);
 
  SystemCache(const FilesControls &fcon, ExceptionResponse policy_in = ExceptionResponse::DIE,
              MapRotatableGroups map_chemfe_rotators = MapRotatableGroups::NO,
              PrintSituation expectation_in = PrintSituation::OPEN_NEW,
              StopWatch *timer_in = nullptr);

  SystemCache(const SystemCache &original) = default;
  SystemCache(SystemCache &&original) = default;
  SystemCache& operator=(const SystemCache &other) = default;
  SystemCache& operator=(SystemCache &&other) = default;
  
  int getSystemCount() const;

  int getTopologyCount() const;

  int getLabelCount() const;

  int getRestraintCount() const;

  int getSystemTopologyIndex(int coord_index) const;
  std::vector<int> getSystemTopologyIndex() const;

  int getSystemExampleIndex(int topology_index) const;
  
  const AtomGraph* getTopologyPointer(int topology_index) const;
  AtomGraph* getTopologyPointer(int topology_index);
  const std::vector<AtomGraph*> getTopologyPointer() const;
  std::vector<AtomGraph*> getTopologyPointer();

  const AtomGraph& getTopology(int topology_index) const;  

  int getTopologyCacheIndex(const AtomGraph *ag) const;
  int getTopologyCacheIndex(const AtomGraph &ag) const;
  
  const std::vector<AtomGraph*> getTopologiesMatchingLabel(const std::string &query_label) const;
  std::vector<AtomGraph*> getTopologiesMatchingLabel(const std::string &query_label);

  const std::string& getLabel(int label_index) const;
  
  std::vector<std::string> getLabelsMatchingTopology(const AtomGraph *query_ag) const;
  std::vector<std::string> getLabelsMatchingTopology(const AtomGraph &query_ag) const;

  int getLabelCacheIndex(const std::string &query) const;
  
  std::vector<int> getMatchingSystemIndices(const AtomGraph* query_ag,
                                            const std::string &query_label) const;
 
  std::vector<int> getMatchingSystemIndices(const AtomGraph &query_ag,
                                            const std::string &query_label) const;
 
  std::vector<int> getMatchingSystemIndices(const AtomGraph *query_ag) const;
 
  std::vector<int> getMatchingSystemIndices(const AtomGraph &query_ag) const;
 
  std::vector<int> getMatchingSystemIndices(const std::string &query_label) const;
 
  int getFirstMatchingSystemIndex(const AtomGraph *query_ag,
                                  ExceptionResponse xcpt = ExceptionResponse::DIE) const;
 
  int getFirstMatchingSystemIndex(const std::string &query_label,
                                  ExceptionResponse xcpt = ExceptionResponse::DIE) const;
 
  int getFirstMatchingSystemIndex(const AtomGraph *query_ag, const std::string &query_label,
                                  ExceptionResponse xcpt = ExceptionResponse::DIE) const;
 
  const AtomGraph* getSystemTopologyPointer(int index) const;
  AtomGraph* getSystemTopologyPointer(int index);
  const std::vector<AtomGraph*> getSystemTopologyPointer() const;
  std::vector<AtomGraph*> getSystemTopologyPointer();

  const AtomGraph& getSystemTopology(int index) const;

  AtomGraphSynthesis
  exportTopologySynthesis(const GpuDetails &gpu = null_gpu,
                          const ExceptionResponse policy = ExceptionResponse::DIE) const;

  const PhaseSpace* getCoordinatePointer(int index) const;
  PhaseSpace* getCoordinatePointer(int index);
  const std::vector<PhaseSpace*> getCoordinatePointer() const;
  std::vector<PhaseSpace*> getCoordinatePointer();

  const PhaseSpace& getCoordinates(int index) const;
  const std::vector<PhaseSpace>& getCoordinates() const;

  PhaseSpaceSynthesis
  exportCoordinateSynthesis(int globalpos_scale_bits = default_globalpos_scale_bits,
                            int velocity_scale_bits = default_velocity_scale_bits,
                            int force_scale_bits = default_force_scale_bits) const;
  
  const MdlMol* getStructureDataEntryPointer(int index) const;
  MdlMol* getStructureDataEntryPointer(int index);
  const std::vector<MdlMol*> getStructureDataEntryPointer() const;
  std::vector<MdlMol*> getStructureDataEntryPointer();

  const MdlMol& getStructureDataEntry(int index) const;
  const std::vector<MdlMol>& getStructureDataEntry() const;
  
  const ChemicalFeatures* getFeaturesPointer(int index) const;
  ChemicalFeatures* getFeaturesPointer(int index);
  const std::vector<ChemicalFeatures*> getFeaturesPointer() const;
  std::vector<ChemicalFeatures*> getFeaturesPointer();

  const ChemicalFeatures& getFeatures(int index) const;

  const RestraintApparatus* getRestraintPointer(int index) const;
  RestraintApparatus* getRestraintPointer(int index);
  const std::vector<RestraintApparatus*> getRestraintPointer() const;
  std::vector<RestraintApparatus*> getRestraintPointer();

  const RestraintApparatus& getRestraints(int index) const;

  const std::vector<StaticExclusionMask*> getUniqueStaticMaskPointers() const;
  std::vector<StaticExclusionMask*> getUniqueStaticMaskPointers();

  const StaticExclusionMask* getSystemStaticMaskPointer(int index) const;
  StaticExclusionMask* getSystemStaticMaskPointer(int index);

  const StaticExclusionMask& getSystemStaticMask(int index) const;

  const ForwardExclusionMask* getSystemForwardMaskPointer(int index) const;
  ForwardExclusionMask* getSystemForwardMaskPointer(int index);

  const ForwardExclusionMask& getSystemForwardMask(int index) const;

  int getTopologyCaseCount(int topology_index) const;

  std::vector<int> getTopologicalCases(int topology_index) const;

  const std::string& getInputCoordinatesName(int system_index) const;
  
  std::string getTrajectoryName(int system_index) const;
  const std::string& getTrajectoryName(const AtomGraph *query_ag) const;
  const std::string& getTrajectoryName(const AtomGraph &query_ag) const;
  const std::string& getTrajectoryName(const AtomGraph *query_ag,
                                       const std::string &query_label) const;
  const std::string& getTrajectoryName(const AtomGraph &query_ag,
                                       const std::string &query_label) const;
  const std::string& getTrajectoryName(const std::string &query_label) const;
  
  std::string getCheckpointName(int system_index) const;
  const std::string& getCheckpointName(const AtomGraph *query_ag) const;
  const std::string& getCheckpointName(const AtomGraph &query_ag) const;
  const std::string& getCheckpointName(const AtomGraph *query_ag,
                                       const std::string &query_label) const;
  const std::string& getCheckpointName(const AtomGraph &query_ag,
                                       const std::string &query_label) const;
  const std::string& getCheckpointName(const std::string &query_label) const;

  int getSystemLabelIndex(int system_index) const;
  
  const std::string& getSystemLabel(int system_index) const;

  CoordinateFileKind getInputCoordinatesKind(const int system_index) const;
  CoordinateFileKind getInputCoordinatesKind(const AtomGraph *query_ag) const;
  CoordinateFileKind getInputCoordinatesKind(const AtomGraph &query_ag) const;
  CoordinateFileKind getInputCoordinatesKind(const AtomGraph *query_ag,
                                             const std::string &query_label) const;
  CoordinateFileKind getInputCoordinatesKind(const AtomGraph &query_ag,
                                             const std::string &query_label) const;
  CoordinateFileKind getInputCoordinatesKind(const std::string &query_label) const;
  
  CoordinateFileKind getTrajectoryKind(const int system_index) const;
  CoordinateFileKind getTrajectoryKind(const AtomGraph *query_ag) const;
  CoordinateFileKind getTrajectoryKind(const AtomGraph &query_ag) const;
  CoordinateFileKind getTrajectoryKind(const AtomGraph *query_ag,
                                       const std::string &query_label) const;
  CoordinateFileKind getTrajectoryKind(const AtomGraph &query_ag,
                                       const std::string &query_label) const;
  CoordinateFileKind getTrajectoryKind(const std::string &query_label) const;
  
  CoordinateFileKind getCheckpointKind(const int system_index) const;
  CoordinateFileKind getCheckpointKind(const AtomGraph *query_ag) const;
  CoordinateFileKind getCheckpointKind(const AtomGraph &query_ag) const;
  CoordinateFileKind getCheckpointKind(const AtomGraph *query_ag,
                                       const std::string &query_label) const;
  CoordinateFileKind getCheckpointKind(const AtomGraph &query_ag,
                                       const std::string &query_label) const;
  CoordinateFileKind getCheckpointKind(const std::string &query_label) const;
  
  PrintSituation getPrintingProtocol() const;
  PrintSituation getPrintingProtocol(CoordinateFileRole purpose, int system_index) const;

  const SystemCache* getSelfPointer() const;
  
  void setPrintingProtocol(const PrintSituation expectation_in);

  TrajectoryFusion getTrajectoryFusionProtocol() const;

  void setTrajectoryFusionProtocol(TrajectoryFusion file_merger_protocol_in);
  
private:

  ExceptionResponse policy;

  PrintSituation expectation;
  
  // Counts are kept as separate integers, to have a single authoritative number on some central
  // quantities in this systems cache.
  int system_count;       
  int topology_count;     
  int label_count;        
  int restraint_count;    

  TrajectoryFusion file_merger_protocol;
  
  std::vector<AtomGraph> topology_cache;

  std::vector<PhaseSpace> coordinates_cache;

  std::vector<MdlMol> sdf_cache;
  
  std::vector<std::string> label_cache;
  
  std::vector<ChemicalFeatures> features_cache;

  std::vector<RestraintApparatus> restraints_cache;

  std::vector<StaticExclusionMask> static_masks_cache;

  std::vector<ForwardExclusionMask> forward_masks_cache;

  std::vector<int> topology_indices;

  std::vector<int> label_indices;

  std::vector<int> label_degeneracy;

  std::vector<int> restraint_indices;
  
  std::vector<int> example_indices;

  std::vector<int> topology_cases;

  std::vector<int> topology_case_bounds;

  std::vector<std::string> system_input_coordinate_names;
  
  std::vector<std::string> system_trajectory_names;

  std::vector<std::string> system_checkpoint_names;

  std::vector<std::string> system_labels;
  
  std::vector<int> trajectory_subindices;

  std::vector<int> trajectory_degeneracy;

  std::vector<int> checkpoint_subindices;

  std::vector<int> checkpoint_degeneracy;

  std::vector<int> label_cases;

  std::vector<int> label_case_bounds;
  
  std::vector<CoordinateFileKind> system_input_coordinate_kinds;

  std::vector<CoordinateFileKind> system_trajectory_kinds;

  std::vector<CoordinateFileKind> system_checkpoint_kinds;

  void checkSystemBounds(int index, const char* caller) const;

  void checkTopologyBounds(int index, const char* caller) const;

  void checkLabelBounds(int index, const char* caller) const;

  bool determineFileMerger(CoordinateFileRole purpose, int system_index) const;
  
  std::string nondegenerateName(const std::string &fname_in, CoordinateFileRole purpose,
                                int system_index) const;
};

void extendTopologyList(std::vector<AtomGraph> *list, const std::string &fname,
                        const DynamicsControls &dyncon,
                        ExceptionResponse policy = ExceptionResponse::DIE,
                        const std::string &caller = std::string(""));
  
//      masks appropriately
StaticExclusionMaskSynthesis createMaskSynthesis(const SystemCache &sc,
                                                 const std::vector<int> &cached_system_indices);
 
StaticExclusionMaskSynthesis createMaskSynthesis(const SystemCache &sc);
 
StaticExclusionMaskSynthesis createMaskSynthesis(const SystemCache &sc,
                                                 const PhaseSpaceSynthesis *poly_ps);
 
StaticExclusionMaskSynthesis createMaskSynthesis(const SystemCache &sc,
                                                 const PhaseSpaceSynthesis &poly_ps);
 
StaticExclusionMaskSynthesis createMaskSynthesis(const SystemCache &sc,
                                                 const AtomGraphSynthesis *poly_ps);
 
StaticExclusionMaskSynthesis createMaskSynthesis(const SystemCache &sc,
                                                 const AtomGraphSynthesis &poly_ps);
 
} // namespace synthesis
} // namespace stormm
 
#endif