watcher.h

// -*-c++-*-
#ifndef STORMM_WATCHER_H
#define STORMM_WATCHER_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Constants/behavior.h"
#include "DataTypes/stormm_vector_types.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "Synthesis/phasespace_synthesis.h"
 
namespace stormm {
namespace review {
 
using card::Hybrid;
using card::HybridTargetLevel;
using constants::ExceptionResponse;
using synthesis::AtomGraphSynthesis;
using synthesis::PhaseSpaceSynthesis;

constexpr int default_max_watcher_reports = 1000;

constexpr int default_watcher_force_threshold = 128.0;

constexpr int default_watcher_speed_threshold = 1.0;

constexpr float minimum_force_threshold = 1.0;

constexpr float minimum_speed_threshold = 1.0;

struct WatcherWriter {
public:
  
  WatcherWriter(int nsystem_in, int max_reports_in, float force_limit_in, float speed_limit_in,
                bool track_purge_in, int* nforce_in, int* nspeed_in, int* nrattle_in,
                int* nshake_in, float4* forces_in, int* force_steps_in, int* force_stages_in,
                float4* speeds_in, int* speed_steps_in, int* speed_stages_in,
                uint2* rattle_fails_in, uint2* shake_fails_in, float* rattle_ext_in,
                float* shake_ext_in, float* xvel_purge_in, float* yvel_purge_in,
                float* zvel_purge_in, float* xang_purge_in, float* yang_purge_in,
                float* zang_purge_in);

  WatcherWriter(const WatcherWriter &original) = default;
  WatcherWriter(WatcherWriter &&original) = default;
  
  const int nsystem;        
  const int max_reports;    
  const float force_limit;  
  const float speed_limit;  
  const bool track_purge;   
  int* nforce;              
  int* nspeed;              
  int* nrattle;             
  int* nshake;              
  float4* forces;           
  int* force_steps;         
  int* force_stages;        
  float4* speeds;           
  int* speed_steps;         
  int* speed_stages;        
  uint2* rattle_fails;      
  uint2* shake_fails;       
  float* rattle_ext;        
  float* shake_ext;         
  float* xvel_purge;        
  float* yvel_purge;        
  float* zvel_purge;        
  float* xang_purge;        
  float* yang_purge;        
  float* zang_purge;        
};

struct WatcherReader {
public:

  WatcherReader(int nsystem_in, int max_reports_in, float force_limit_in, float speed_limit_in,
                bool track_purge_in, const int* nforce_in, const int* nspeed_in,
                const int* nrattle_in, const int* nshake_in, const float4* forces_in,
                const int* force_steps_in, const int* force_stages_in, const float4* speeds_in,
                const int* speed_steps_in, const int* speed_stages_in,
                const uint2* rattle_fails_in, const uint2* shake_fails_in,
                const float* rattle_ext_in, const float* shake_ext_in, const float* xvel_purge_in,
                const float* yvel_purge_in, const float* zvel_purge_in, const float* xang_purge_in,
                const float* yang_purge_in, const float* zang_purge_in);
 
  WatcherReader(const WatcherWriter &w);

  WatcherReader(const WatcherReader &original) = default;
  WatcherReader(WatcherReader &&original) = default;
 
  const int nsystem;          
  const int max_reports;      
  const float force_limit;    
  const float speed_limit;    
  const bool track_purge;     
  const int* nforce;          
  const int* nspeed;          
  const int* nrattle;         
  const int* nshake;          
  const float4* forces;       
  const int* force_steps;     
  const int* force_stages;    
  const float4* speeds;       
  const int* speed_steps;     
  const int* speed_stages;    
  const uint2* rattle_fails;  
  const uint2* shake_fails;   
  const float* rattle_ext;    
  const float* shake_ext;     
  const float* xvel_purge;    
  const float* yvel_purge;    
  const float* zvel_purge;    
  const float* xang_purge;    
  const float* yang_purge;    
  const float* zang_purge;    
};

class Watcher {
public:

  Watcher(const PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,
          float force_threshold_in = default_watcher_force_threshold,
          float speed_threshold_in = default_watcher_speed_threshold,
          bool track_momentum_purge_in = false, int max_reports_in = default_max_watcher_reports,
          ExceptionResponse policy_in = ExceptionResponse::WARN);
 
  Watcher(const PhaseSpaceSynthesis &poly_ps, const AtomGraphSynthesis &poly_ag,
          float force_threshold_in = default_watcher_force_threshold,
          float speed_threshold_in = default_watcher_speed_threshold,
          bool track_momentum_purge_in = false, int max_reports_in = default_max_watcher_reports,
          ExceptionResponse policy_in = ExceptionResponse::WARN);

  Watcher(const Watcher &original);
  Watcher(Watcher &&original);
  Watcher& operator=(const Watcher &original);
  Watcher& operator=(Watcher &&original);

  int getReportCount() const;
  
  int getSystemCount() const;
  
  float getForceThreshold() const;

  int getLargeForceCount(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<float4> getLargeForces(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<int> getLargeForceSteps(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<DynamicsStepStage>
  getLargeForceStages(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  float getSpeedThreshold() const;
  
  int getHighSpeedCount(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<float4> getHighSpeeds(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<int> getHighSpeedSteps(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<DynamicsStepStage>
  getHighSpeedStages(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  
  int getFailedRattleCount(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  int getFailedShakeCount(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  
  std::vector<uint2> getRattleFailures(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<uint2> getShakeFailures(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<float> getRattleViolations(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  
  std::vector<float> getShakeViolations(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  const WatcherReader data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  WatcherWriter data(HybridTargetLevel tier = HybridTargetLevel::HOST);
  
  void setForceThreshold(float force_threshold_in);

  void setSpeedThreshold(float speed_threshold_in);
  
private:
 
  // General parameters
  ExceptionResponse policy;  
  int max_reports;           
  
  // Track large forces on any given atom
  float force_threshold;           
  Hybrid<int> large_force_count;   
  Hybrid<float4> large_forces;     
  Hybrid<int> large_force_steps;   
  Hybrid<int> large_force_stages;  
 
  // Track large velocities on any given atom
  float speed_threshold;             
  Hybrid<int> high_speed_count;      
  Hybrid<float4> high_speeds;        
  Hybrid<int> high_speed_steps;      
  Hybrid<int> high_speed_stages;     
  
  // Track failed convergence in SHAKE or RATTLE groups
  Hybrid<int> failed_rattle_count;      
  Hybrid<int> failed_shake_count;       
  Hybrid<uint2> rattle_group_failures;  
  Hybrid<uint2> shake_group_failures;   
  Hybrid<float> rattle_violations;      
  Hybrid<float> shake_violations;       
 
  // Track the amount of momentum purged with each cycle, if requested
  bool track_momentum_purge;
  Hybrid<float> x_velocity_purge;  
  Hybrid<float> y_velocity_purge;  
  Hybrid<float> z_velocity_purge;  
  Hybrid<float> x_angular_purge;   
  Hybrid<float> y_angular_purge;   
  Hybrid<float> z_angular_purge;   

  Hybrid<int> int_data;

  Hybrid<float> float_data;

  PhaseSpaceSynthesis *poly_ps_ptr;

  AtomGraphSynthesis *poly_ag_ptr;
  
  void allocate();

  void validateForceThreshold() const;

  void validateSpeedThreshold() const;
};
 
} // namespace review
} // namespace stormm
 
#endif