ComputeGridForceCUDA.h

Go to the documentation of this file.

#ifndef GRIDFORCECUDA_H
#define GRIDFORCECUDA_H

#ifdef NAMD_CUDA
#include <cuda.h>
#endif
#ifdef NAMD_HIP
#include <hip/hip_runtime.h>
#endif

#include <vector>
#include "PatchMap.h"
#include "AtomMap.h"
#include "Lattice.h"
#include "CudaUtils.h"
#include "CudaRecord.h"
#include "HipDefines.h"
#include "GridForceGrid.h"
#include "GridforceGridCUDAKernel.h"
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
#ifdef NODEGROUP_FORCE_REGISTER
class ComputeGridForceCUDA {
 public:
  ComputeGridForceCUDA(
                       std::vector<HomePatch*> &patchList,
                       std::vector<AtomMap*> &atomMapsList,
                       cudaStream_t stream);
  int updateGriddedAtoms(
      std::vector<AtomMap*> &atomMapsList,
      std::vector<CudaLocalRecord> &localRecords,
      std::vector<HomePatch*> &patches,
      const int *h_globalToLocalID,
      bool mGpuOn);

  int createGriddedLists();
  void destroyGriddedLists();
  ~ComputeGridForceCUDA();
  // all the parameters we need from the patch
  // and the device resident grid
  void doForce(
               const int doEnergy,
               const int doVirial,
               const Lattice lat,
               const int timeStep,
               const double* d_pos_x,
               const double* d_pos_y,
               const double* d_pos_z,
               const char3* d_transform,
               double* f_normal_x,
               double* f_normal_y,
               double* f_normal_z,
               cudaStream_t stream);
  int getNumGriddedAtoms(){return numGriddedAtoms;}
  void zeroOutEnergyVirialForcesAcrossGrids(double* h_extEnergy,
                                            double3* h_netForce,
                                            cudaTensor* h_virial);
  void sumEnergyVirialForcesAcrossGrids( double* h_extEnergy,
                                         double3* h_netForce,
                                         cudaTensor* h_virial);
 private:
  std::vector<HomePatch*> patchList;           
  int numGriddedAtoms; 
  int numGriddedAtomsLocal; 
  std::vector<int> griddedAtomsSOAIndex;       
  std::vector<int> griddedAtomsGlobalIndex;       
  std::map< std::pair<int,int>,int> griddedAtomsGlobalIndexMap;       
  std::vector<int> griddedAtomsLocalIndex;       
  std::vector<int> gridOffsets;       
  std::vector<int> gridOffsetsLocal;       
  std::vector<int> gridCoordsOffsets; 
  GridforceGridCUDA* d_grids; 
  std::vector<GridforceGridCUDA> h_grids; 
  float* d_gridCoords; 
  float* h_gridded_charge; 
  float* h_gridded_scale; 
  float* d_gridded_charge; 
  float* d_gridded_scale;
  unsigned int* d_tbcatomic; 
  int* d_griddedAtomsSOAIndex;       
  int* d_griddedAtomsLocalIndex;       
  double* d_extEnergy_G; 
  double3* d_netForce_G;
  cudaTensor* d_extVirial_G;
  double* h_extEnergy_G;
  double3*  h_netForce_G;
  cudaTensor* h_extVirial_G;

  cudaStream_t stream; /*< CUDA stream */
};
#endif //NODEGROUP_FORCE_REGISTER
#endif
#endif