convolution_manager.h

// -*-c++-*-
#ifndef STORMM_CONVOLUTION_MANAGER_H
#define STORMM_CONVOLUTION_MANAGER_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Constants/behavior.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "pmigrid.h"
 
namespace stormm {
namespace energy {
 
using constants::PrecisionModel;
using card::Hybrid;
using card::HybridTargetLevel;
using synthesis::AtomGraphSynthesis;

template <typename T> struct ConvolutionKit {

  ConvolutionKit(int system_count_in, T ew_coeff_in, const int* sys_offsets_in,
                 const T* self_ecorr_in, const T* bmesh_a_in, const T* bmesh_b_in,
                 const T* bmesh_c_in, const T* mval_a_in, const T* mval_b_in, const T* mval_c_in,
                 const T* msval_a_in, const T* msval_b_in, const T* msval_c_in,
                 const T* cmesh_a_in, const T* cmesh_b_in, const T* cmesh_c_in);

  ConvolutionKit(const ConvolutionKit &original) = default;
  ConvolutionKit(ConvolutionKit &&original) = default;
 
  const int system_count;  
  const T ew_coeff;        
  const int* sys_offsets;  
  const T* self_ecorr;     
  const T* bmesh_a;        
  const T* bmesh_b;        
  const T* bmesh_c;        
  const T* mval_a;         
  const T* mval_b;         
  const T* mval_c;         
  const T* msval_a;        
  const T* msval_b;        
  const T* msval_c;        
  const T* cmesh_a;        
  const T* cmesh_b;        
  const T* cmesh_c;        
};
  
class ConvolutionManager {
public:

  ConvolutionManager(const PMIGrid *pmig_in, const double ewald_coefficient_in);
  ConvolutionManager(const PMIGrid &pmig_in, const double ewald_coefficient_in);

  ConvolutionManager(const ConvolutionManager &original);
  ConvolutionManager(ConvolutionManager &&original);
  ConvolutionManager& operator=(const ConvolutionManager &other);
  ConvolutionManager& operator=(ConvolutionManager &&other);
  
  int getSystemCount() const;

  double getEwaldCoefficient() const;

  double getCoulombConstant() const;

  const PMIGrid* getPMIGridPointer() const;

  const AtomGraphSynthesis* getTopologySynthesisPointer() const;

  std::vector<double> getSelfEcorr(PrecisionModel prec) const;
 
#ifdef STORMM_USE_HPC
  void upload();
  
  void download();
#endif
  
private:
  int system_count;                 
  double ewald_coefficient;         
  Hybrid<int> system_offsets;       
  Hybrid<double> self_ecorr;        
  Hybrid<double> b_prefactor_a;     
  Hybrid<double> b_prefactor_b;     
  Hybrid<double> b_prefactor_c;     
  Hybrid<double> m_values_a;        
  Hybrid<double> m_values_b;        
  Hybrid<double> m_values_c;        
  Hybrid<double> mshift_values_a;   
  Hybrid<double> mshift_values_b;   
  Hybrid<double> mshift_values_c;   
  Hybrid<double> c_prefactor_a;     
  Hybrid<double> c_prefactor_b;     
  Hybrid<double> c_prefactor_c;     
  Hybrid<double> double_data;       
 
  // Single-precision (32-bit) variants of each of the above arrays
  Hybrid<float> sp_self_ecorr;       
  Hybrid<float> sp_b_prefactor_a;    
  Hybrid<float> sp_b_prefactor_b;    
  Hybrid<float> sp_b_prefactor_c;    
  Hybrid<float> sp_m_values_a;       
  Hybrid<float> sp_m_values_b;       
  Hybrid<float> sp_m_values_c;       
  Hybrid<float> sp_mshift_values_a;  
  Hybrid<float> sp_mshift_values_b;  
  Hybrid<float> sp_mshift_values_c;  
  Hybrid<float> sp_c_prefactor_a;    
  Hybrid<float> sp_c_prefactor_b;    
  Hybrid<float> sp_c_prefactor_c;    
  Hybrid<float> float_data;          
 
  // Pointers to associated objects
  PMIGrid *pmig_ptr;                
  AtomGraphSynthesis *poly_ag_ptr;  

  void allocate();

  void computeSystemSelfEnergies();
};
 
} // namespace energy
} // namespace stormm
 
#include "convolution_manager.tpp"
 
#endif