test_system_manager.h

// -*-c++-*-
#ifndef STORMM_TEST_SYSTEM_MANAGER_H
#define STORMM_TEST_SYSTEM_MANAGER_H
 
#include "copyright.h"
#include <string>
#include <vector>
#include "Accelerator/gpu_details.h"
#include "Constants/behavior.h"
#include "Constants/fixed_precision.h"
#include "Constants/scaling.h"
#include "FileManagement/file_listing.h"
#include "Math/rounding.h"
#include "Namelists/nml_dynamics.h"
#include "Numerics/split_fixed_precision.h"
#include "Random/random.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "Synthesis/condensate.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Synthesis/systemcache.h"
#include "Topology/atomgraph.h"
#include "Topology/atomgraph_enumerators.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/coordinate_series.h"
#include "Trajectory/phasespace.h"
#include "test_environment.h"
 
namespace stormm {
namespace testing {
 
using card::GpuDetails;
using constants::ExceptionResponse;
using stmath::roundUp;
using namelist::DynamicsControls;
using numerics::hostDoubleToInt95;
using numerics::hostSplitFPSum;
using numerics::default_velocity_scale_bits;
using numerics::default_force_scale_bits;
using random::Xoshiro256ppGenerator;
using synthesis::Condensate;
using synthesis::AtomGraphSynthesis;
using synthesis::PhaseSpaceSynthesis;
using synthesis::PsSynthesisWriter;
using synthesis::SystemCache;
using topology::AtomGraph;
using topology::UnitCellType;
using trajectory::CoordinateFileKind;
using trajectory::CoordinateFrame;
using trajectory::CoordinateSeries;
using trajectory::CoordinateSeriesWriter;
using trajectory::PhaseSpace;
  
class TestSystemManager {
public:

  TestSystemManager();
 
  TestSystemManager(const std::string &topology_base_in, const std::string &topology_extn_in,
                    const std::vector<std::string> &topology_names_in,
                    const std::string &coordinate_base_in, const std::string &coordinate_extn_in,
                    const std::vector<std::string> &coordinate_names_in,
                    ExceptionResponse policy = ExceptionResponse::WARN,
                    TestPriority fault_response_in = TestPriority::ABORT,
                    TestPriority all_go_response_in = TestPriority::CRITICAL,
                    const DynamicsControls &dyncon = DynamicsControls());
 
  TestSystemManager(const std::string &topology_base_in, const std::string &topology_extn_in,
                    const std::vector<std::string> &topology_names_in,
                    const std::string &coordinate_base_in, const std::string &coordinate_extn_in,
                    const std::vector<std::string> &coordinate_names_in,
                    const DynamicsControls &dyncon,
                    ExceptionResponse policy = ExceptionResponse::WARN);
 
  TestSystemManager(const std::string &topology_base_in,
                    const std::vector<std::string> &topology_names_in,
                    const std::string &coordinate_base_in,
                    const std::vector<std::string> &coordinate_names_in,
                    ExceptionResponse policy = ExceptionResponse::WARN,
                    TestPriority fault_response_in = TestPriority::ABORT,
                    TestPriority all_go_response_in = TestPriority::CRITICAL,
                    const DynamicsControls &dyncon = DynamicsControls());
 
  TestSystemManager(const std::string &topology_base_in,
                    const std::vector<std::string> &topology_names_in,
                    const std::string &coordinate_base_in,
                    const std::vector<std::string> &coordinate_names_in,
                    const DynamicsControls &dyncon,
                    ExceptionResponse policy = ExceptionResponse::WARN);
  
  TestSystemManager(const std::vector<std::string> &topology_names_in,
                    const std::vector<std::string> &coordinate_names_in,
                    ExceptionResponse policy = ExceptionResponse::WARN,
                    TestPriority fault_response_in = TestPriority::ABORT,
                    TestPriority all_go_response_in = TestPriority::CRITICAL,
                    const DynamicsControls &dyncon = DynamicsControls());
 
  TestSystemManager(const std::vector<std::string> &topology_names_in,
                    const std::vector<std::string> &coordinate_names_in,
                    const DynamicsControls &dyncon,
                    ExceptionResponse policy = ExceptionResponse::WARN);

  int getSystemCount() const;
  int getSystemCount(UnitCellType query_bc) const;
  int getSystemCount(const std::vector<UnitCellType> &query_bc) const;

  std::vector<int> getQualifyingSystems(UnitCellType uc_choice) const;
  std::vector<int> getQualifyingSystems(const std::vector<UnitCellType> &uc_choice) const;
  std::vector<int> getQualifyingSystems(int critical_atom_count, RelationalOperator rel) const;
  
  std::string getTopologyBasePath() const;
  
  std::string getCoordinateBasePath() const;

  std::string getTopologyExtension() const;

  std::string getCoordinateExtension() const;
  
  std::string getTopologyFile(int index) const;

  std::string getCoordinateFile(int index) const;

  TestPriority getTestingStatus() const;
  TestPriority getTestingStatus(int index) const;
  TestPriority getTestingStatus(const std::vector<int> &indices) const;

  CoordinateFrame exportCoordinateFrame(int index) const;

  PhaseSpace exportPhaseSpace(int index) const;

  AtomGraph exportAtomGraph(int index) const;
  
  const PhaseSpace& viewCoordinates(int index);
  const std::vector<PhaseSpace>& viewCoordinates();

  const AtomGraph& getTopologyReference(int index) const;
  const std::vector<AtomGraph>& getTopologyReference() const;
  
  AtomGraph* getTopologyPointer(int index);
  const AtomGraph* getTopologyPointer(int index) const;
  std::vector<AtomGraph*> getTopologyPointer();
  const std::vector<AtomGraph*> getTopologyPointer() const;

  template <typename T>
  CoordinateSeries<T> exportCoordinateSeries(const int base_system, int frame_count,
                                             double perturbation_sigma = 0.0,
                                             int xrs_seed = 915083, int scale_bits = 0) const;

  PhaseSpaceSynthesis exportPhaseSpaceSynthesis(const std::vector<int> &index_key,
                                                double perturbation_sigma = 0.0,
                                                int xrs_seed = 7108262, int scale_bits = 40,
                                                int vel_bits = default_velocity_scale_bits,
                                                int frc_bits = default_force_scale_bits) const;
  PhaseSpaceSynthesis exportPhaseSpaceSynthesis(UnitCellType uc_choice) const;
  PhaseSpaceSynthesis exportPhaseSpaceSynthesis(const std::vector<UnitCellType> &uc_choice) const;
  
  AtomGraphSynthesis
  exportAtomGraphSynthesis(const std::vector<int> &index_key,
                           ExceptionResponse policy = ExceptionResponse::SILENT,
                           const GpuDetails &gpu = null_gpu) const;
 
  AtomGraphSynthesis
  exportAtomGraphSynthesis(UnitCellType uc_choice,
                           ExceptionResponse policy = ExceptionResponse::SILENT,
                           const GpuDetails &gpu = null_gpu) const;
 
  AtomGraphSynthesis
  exportAtomGraphSynthesis(const std::vector<UnitCellType> &uc_choice,
                           ExceptionResponse policy = ExceptionResponse::SILENT,
                           const GpuDetails &gpu = null_gpu) const;

  SystemCache exportSystemCache(const std::vector<int> &index_key, const TestEnvironment &oe,
                                const std::vector<std::string> &x_name_list = {},
                                const std::vector<CoordinateFileKind> &x_type_list = {},
                                const std::vector<std::string> &r_name_list = {},
                                const std::vector<CoordinateFileKind> &r_type_list = {},
                                const std::vector<std::string> &label_list = {});
 
  SystemCache exportSystemCache(const std::string &fnml);
  
private:
  int system_count;              
  std::string topology_base;     
  std::string topology_extn;     
  std::string coordinate_base;   
  std::string coordinate_extn;   
  TestPriority fault_response;   
  TestPriority all_go_response;  
  bool fault_found;              
 
  // Vectors of names and flags describing the file parsing
  std::vector<std::string> topology_names;    
  std::vector<std::string> coordinate_names;  
  std::vector<bool> topology_exist;           
  std::vector<bool> topology_success;         
  std::vector<bool> coordinate_exist;         
  std::vector<bool> coordinate_success;       
  std::vector<bool> compatibility;            

  std::vector<AtomGraph> all_topologies;

  std::vector<PhaseSpace> all_coordinates;

  void checkIndexing(int index, const char* caller) const;
};
 
} // namespace testing
} // namespace stormm
 
#include "test_system_manager.tpp"
 
#endif