implicit_solvent_workspace.h

// -*-c++-*-
#ifndef STORMM_IMPLICIT_SOLVENT_WORKSPACE_H
#define STORMM_IMPLICIT_SOLVENT_WORKSPACE_H
 
#include <cmath>
#include "copyright.h"
#include "Accelerator/gpu_details.h"
#include "Accelerator/hybrid.h"
#include "Constants/behavior.h"
#include "Trajectory/trajectory_enumerators.h"
 
namespace stormm {
namespace synthesis {
 
using card::GpuDetails;
using card::Hybrid;
using card::HybridTargetLevel;
using constants::PrecisionModel;
using trajectory::CoordinateCycle;

template <typename T> struct ISWorkspaceKit {

  ISWorkspaceKit(int fp_bits_in, llint* psi_in, int* psi_overflow_in, llint* sum_deijda_in,
                 int* sum_deijda_overflow_in, llint* alt_psi_in, int* alt_psi_overflow_in,
                 llint* alt_sum_deijda_in, int* alt_sum_deijda_overflow_in);

  ISWorkspaceKit(const ISWorkspaceKit &original) = default;
  ISWorkspaceKit(ISWorkspaceKit &&original) = default;
 
  const int fp_bits;         
  const T fp_scale;          
  const T inv_fp_scale;      
  llint* psi;                
  int* psi_ovrf;             
  llint* sum_deijda;         
  int* sum_deijda_ovrf;      
 
  // The following are alternative arrays made available so that one of the GB kernels can
  // initialize them for use in the following calculation, saving a kernel call in the GB cycle.
  llint* alt_psi;            
  int* alt_psi_ovrf;         
  llint* alt_sum_deijda;     
  int* alt_sum_deijda_ovrf;  
};
  
class ImplicitSolventWorkspace {
public:
  
  ImplicitSolventWorkspace(const Hybrid<int> &atom_starts, const Hybrid<int> &atom_counts,
                           int bit_count);
 
  ImplicitSolventWorkspace(const Hybrid<int> &atom_starts, const Hybrid<int> &atom_counts,
                           PrecisionModel prec);

  ImplicitSolventWorkspace(const ImplicitSolventWorkspace &original);
  ImplicitSolventWorkspace(ImplicitSolventWorkspace &&original);
  ImplicitSolventWorkspace& operator=(const ImplicitSolventWorkspace &other);
  ImplicitSolventWorkspace& operator=(ImplicitSolventWorkspace &&other);
  
  int getFixedPrecisionBits() const;

  CoordinateCycle getCyclePosition() const;
  
  ISWorkspaceKit<double> dpData(CoordinateCycle orientation,
                                HybridTargetLevel tier = HybridTargetLevel::HOST);
 
  ISWorkspaceKit<double> dpData(HybridTargetLevel tier = HybridTargetLevel::HOST);
  
  ISWorkspaceKit<float> spData(CoordinateCycle orientation,
                               HybridTargetLevel tier = HybridTargetLevel::HOST);
 
  ISWorkspaceKit<float> spData(HybridTargetLevel tier = HybridTargetLevel::HOST);
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif

  void updateCyclePosition();
  
  void initialize(HybridTargetLevel tier = HybridTargetLevel::HOST,
                  CoordinateCycle orientation = CoordinateCycle::WHITE,
                  const GpuDetails &gpu = null_gpu);
 
#ifdef STORMM_USE_HPC
  void launchInitialization(const GpuDetails &gpu,
                            CoordinateCycle orientation = CoordinateCycle::WHITE);
#endif
 
private:
  int fp_bits;                          
  int padded_atom_count;                
  CoordinateCycle cycle_position;       
  Hybrid<llint> psi;                    
  Hybrid<int> psi_overflow;             
  Hybrid<llint> sum_deijda;             
  Hybrid<int> sum_deijda_overflow;      
  Hybrid<llint> alt_psi;                
  Hybrid<int> alt_psi_overflow;         
  Hybrid<llint> alt_sum_deijda;         
  Hybrid<int> alt_sum_deijda_overflow;  
  Hybrid<llint> llint_data;             
  Hybrid<int> int_data;                 

  void rebasePointers();
};
 
} // namespace synthesis
} // namespace stormm
 
#include "implicit_solvent_workspace.tpp"
 
#endif