scorecard.h

// -*-c++-*-
#ifndef STORMM_SCORECARD_H
#define STORMM_SCORECARD_H
 
#include "copyright.h"
#include "Accelerator/gpu_details.h"
#include "Accelerator/hybrid.h"
#include "Constants/fixed_precision.h"
#include "DataTypes/stormm_vector_types.h"
#include "energy_enumerators.h"
 
namespace stormm {
namespace energy {
 
using card::GpuDetails;
using card::Hybrid;
using card::HybridTargetLevel;
using numerics::default_energy_scale_bits;

struct ScoreCardReader {

  ScoreCardReader(int system_count_in, int data_stride_in, int sampled_step_count_in,
                  float nrg_scale_f_in, double nrg_scale_lf_in, float inverse_nrg_scale_f_in,
                  double inverse_nrg_scale_lf_in, const int* time_steps_in,
                  const llint* instantaneous_accumulators_in,
                  const double* running_accumulators_in, const double* squared_accumulators_in,
                  const llint* time_series_in);

  ScoreCardReader(const ScoreCardReader &original) = default;
  ScoreCardReader(ScoreCardReader &&original) = default;
  
  const int system_count;                  
  const int data_stride;                   
  const int sampled_step_count;            
  const float nrg_scale_f;                 
  const double nrg_scale_lf;               
  const float inverse_nrg_scale_f;         
  const double inverse_nrg_scale_lf;       
  const int* time_steps;                   
  const llint* instantaneous_accumulators; 
  const double* running_accumulators;      
  const double* squared_accumulators;      
  const llint* time_series;                
};

struct ScoreCardWriter {

  ScoreCardWriter(int system_count_in, int data_stride_in, int sampled_step_count_in,
                  float nrg_scale_f_in, double nrg_scale_lf_in, float inverse_nrg_scale_f_in,
                  double inverse_nrg_scale_lf_in, int* time_steps_in,
                  llint* instantaneous_accumulators_in, double* running_accumulators_in,
                  double* squared_accumulators_in, llint* time_series_in);

  ScoreCardWriter(const ScoreCardWriter &original) = default;
  ScoreCardWriter(ScoreCardWriter &&original) = default;
 
  const int system_count;             
  const int data_stride;              
  const int sampled_step_count;       
  const float nrg_scale_f;            
  const double nrg_scale_lf;          
  const float inverse_nrg_scale_f;    
  const double inverse_nrg_scale_lf;  
  int* time_steps;                    
  llint* instantaneous_accumulators;  
  double* running_accumulators;       
  double* squared_accumulators;       
  llint* time_series;                 
};

class ScoreCard {
public:

  ScoreCard(int system_count_in, int capacity_in = 16,
            int nrg_scale_bits_in = default_energy_scale_bits);

  ScoreCard(const ScoreCard &original) = default;
  ScoreCard(ScoreCard &&original) = default;

  ScoreCard& operator=(const ScoreCard &other) = default;
  ScoreCard& operator=(ScoreCard &&other) = default;
  
  int getSystemCount() const;

  int getSampleSize() const;

  int getDataStride() const;

  int getSampleCapacity() const;
  
  int getEnergyScaleBits() const;
  
  template <typename T> T getEnergyScalingFactor() const;
  template <typename T> T getInverseEnergyScalingFactor() const;

  int getTimeStep(int time_index) const;
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif

  const ScoreCardReader data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  ScoreCardWriter data(HybridTargetLevel tier = HybridTargetLevel::HOST);

  void reserve(int new_capacity);
  
  void contribute(StateVariable var, llint amount, int system_index = 0);

  void initialize(StateVariable var, int system_index = 0,
                  HybridTargetLevel tier = HybridTargetLevel::HOST,
                  const GpuDetails &gpu = null_gpu);
  void initialize(const std::vector<StateVariable> &var, int system_index = 0,
                  HybridTargetLevel tier = HybridTargetLevel::HOST,
                  const GpuDetails &gpu = null_gpu);
  void initialize(int system_index, HybridTargetLevel tier = HybridTargetLevel::HOST,
                  const GpuDetails &gpu = null_gpu);
  void initialize(HybridTargetLevel tier = HybridTargetLevel::HOST,
                  const GpuDetails &gpu = null_gpu);
  
  void add(StateVariable var, llint amount, int system_index = 0);  

  void commit(StateVariable var, int system_index,
              HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
 
  void commit(const std::vector<StateVariable> &var, int system_index,
              HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
 
  void commit(StateVariable var,
              HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
 
  void commit(const std::vector<StateVariable> &var,
              HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
 
  void commit(int system_index,
              HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
  
  void commit(HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);

  void computePotentialEnergy(HybridTargetLevel tier = HybridTargetLevel::HOST,
                              const GpuDetails &gpu = null_gpu);

  void computeTotalEnergy(HybridTargetLevel tier = HybridTargetLevel::HOST,
                          const GpuDetails &gpu = null_gpu);

  void incrementSampleCount();

  void resetSampleCount(int count_in = 0);
  
  std::vector<double>
  reportPotentialEnergies(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  double reportPotentialEnergy(int system_index = 0,
                               HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  std::vector<double> reportTotalEnergies(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  double reportTotalEnergy(int system_index = 0,
                           HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<double>
  reportInstantaneousStates(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  std::vector<double>
  reportInstantaneousStates(int system_index,
                            HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  std::vector<double>
  reportInstantaneousStates(StateVariable aspect,
                            HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  double reportInstantaneousStates(StateVariable aspect, int system_index,
                                   HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<double> reportAverageStates(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  std::vector<double> reportAverageStates(int system_index,
                                          HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  std::vector<double> reportAverageStates(StateVariable aspect,
                                          HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  double reportAverageStates(StateVariable aspect, int system_index,
                             HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<double>
  reportVarianceOfStates(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  std::vector<double>
  reportVarianceOfStates(int system_index, HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  std::vector<double>
  reportVarianceOfStates(StateVariable aspect,
                         HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
  double reportVarianceOfStates(StateVariable aspect, int system_index,
                                HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<double> reportHistory(int system_index,
                                    HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  std::vector<double> reportHistory(StateVariable aspect, int system_index,
                                    HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  std::vector<double2> reportHistory(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  std::vector<double2> reportHistory(StateVariable aspect,
                                     HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  const ScoreCard* getSelfPointer() const;

  void setLastTimeStep(int time_index, HybridTargetLevel tier = HybridTargetLevel::HOST);
  
  void importCard(const ScoreCard *other, size_t fill_index, size_t source_index);
  void importCard(const ScoreCard &other, size_t fill_index, size_t source_index);
  void importCard(const ScoreCard *other, const std::vector<int> &fill_indices,
                  const std::vector<int> &source_indices);
  void importCard(const ScoreCard &other, const std::vector<int> &fill_indices,
                  const std::vector<int> &source_indices);
  
private:
  int system_count;                          
  int data_stride;                           
  int sampled_step_count;                    
  int sample_capacity;                       
  
  int nrg_scale_bits;
  float nrg_scale_f;
  double nrg_scale_lf;
  float inverse_nrg_scale_f;
  double inverse_nrg_scale_lf;
 
  Hybrid<int> time_steps;                    
  Hybrid<llint> instantaneous_accumulators;  
  Hybrid<double> running_accumulators;       
  Hybrid<double> squared_accumulators;       
  Hybrid<llint> time_series_accumulators;    

  llint sumPotentialEnergyAsLlint(const llint* nrg_data) const;
  double sumPotentialEnergy(const llint* nrg_data) const;

  llint sumTotalEnergyAsLlint(const llint* nrg_data) const;
  double sumTotalEnergy(const llint* nrg_data) const;
};

void add(ScoreCardWriter *csw, StateVariable var, llint amount, int system_index);
 
} // namespace energy
} // namespace stormm
 
#include "scorecard.tpp"
 
#endif