ComputeSMDCUDA.h

Go to the documentation of this file.

#ifndef SMDCUDA_H
#define SMDCUDA_H

#if defined NAMD_CUDA
#include <cuda.h>
#endif

#include <vector>
#include "PatchMap.h"
#include "AtomMap.h"
#include "Lattice.h"
#include "CudaUtils.h"
#include "HipDefines.h"
#if defined NAMD_CUDA || defined NAMD_HIP
#ifdef NODEGROUP_FORCE_REGISTER
class ComputeSMDCUDA{
  public:
    ComputeSMDCUDA(
        std::vector<HomePatch*> &patchList, 
        double springConstant, 
        double transverseSpringConstant, 
        double velocity,
        double3 direction,
        int outputFrequency,
        int firsttimestep,
        const char* filename,
        bool isMasterDevice,
        int numAtoms,
        int numDevices,
        int deviceIndex,
        bool mGpuOn);
    
    ~ComputeSMDCUDA();
    void outputCOM(std::string);
    void dump(std::string, const int step, const int numAtoms, const double*, const double*, const double*, const float*);
    void updateAtoms(
                     std::vector<AtomMap*> &atomMapsList,
                     std::vector<CudaLocalRecord> &localRecords,
                     const int* h_globalToLocalID);
    void computeCOMMGpu(
                 const Lattice lat,
                 const float * d_mass,
                 const double* d_pos_x,
                 const double* d_pos_y,
                 const double* d_pos_z,
                 const char3*  d_transform,
                 cudaStream_t stream
                        );
    void outputStep(const int timeStep, double3* curCOM, double3* extForce);
    void doForce(
      const int timeStep, 
      const Lattice &lat, 
      bool doEnergy,
      const float*  d_mass,
      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,
      cudaTensor* d_extVirial,
      double*     h_extEnergy,
      double3*    h_extForce,
      cudaTensor* h_extVirial,
      cudaStream_t stream
    );

  void initPeerCOM(double3** d_peerPoolCOM, cudaStream_t stream);

private:
    double   springConstant;
    double   transverseSpringConstant;
    double   velocity;
    double   inv_group_mass; 
    double3  direction;
    double3  origCOM; 
    double3* curCOM;  
    double3* d_curCOM; 
    int numDevices;
    int deviceIndex;
    std::vector<HomePatch*> *patchList; 
    std::vector<int> smdAtomsGlobalIndex; 
    std::vector<int> smdAtomsSOAIndex; 
    std::map<int,int> smdAtomsSOAtoGlobalLocalMap; 
    int* d_smdAtomsSOAIndex;
        
    // JM: SMD needs to handle IO, so I need to have a pointer to the file somehow
    int firstTimeStep;
    const char* filename;
    int outputFrequency;
    int numAtoms;
    int numSMDAtoms;
    bool isMasterDevice;
    bool mGpuOn;
    unsigned int* d_tbcatomic; 
    double3* d_peerCOM;
    double3* h_peerCOM;
    void parseAtoms(); 
};
#endif // NODEGROUP_FORCE_REGISTER

#endif // NAMD_CUDA

#endif // SMDCUDA_H