ComputeGroupRestraintsCUDA.h

Go to the documentation of this file.

#ifndef COMPUTE_GROUP_RESTRAINTS_H
#define COMPUTE_GROUP_RESTRAINTS_H

#ifdef NAMD_CUDA
#include <cuda.h>
#endif

#include <vector>
#include "PatchMap.h"
#include "AtomMap.h"
#include "CudaUtils.h"
#include "Lattice.h"
#include "GroupRestraintsParam.h"
#include "HipDefines.h"

#if defined NAMD_CUDA || defined NAMD_HIP

#ifdef NODEGROUP_FORCE_REGISTER

class GroupRestraintsCUDA {
public:

  GroupRestraintsCUDA(const GroupRestraintParam *param, bool mGpuOn, int numDevices, int devIdx, int grpId);
    
    ~GroupRestraintsCUDA();

    void updateAtoms(std::vector<AtomMap*> &atomMapsList,
                    std::vector<CudaLocalRecord> &localRecords,
                    const int *h_globalToLocalID);

   void doCOM_mgpu(
        const Lattice &lat,
        const char3*  d_transform,
        const float*  d_mass,
        const double* d_pos_x,
        const double* d_pos_y,
        const double* d_pos_z,
        const int     grp,
        cudaStream_t  stream);

    void doForce(
        const int timeStep,
        const int doEnergy,
        const int doVirial,
        const int doOutput,
        const int grp,
        const Lattice &lat, 
        const char3*  d_transform, 
        const float*  d_mass, 
        const double* d_pos_x,
        const double* d_pos_y,
        const double* d_pos_z,
        double*       d_f_normal_x,
        double*       d_f_normal_y,
        double*       d_f_normal_z,
        cudaTensor*   d_virial,
        double*       h_extEnergy, 
        double3*      h_extForce, 
        cudaTensor*   h_extVirial,
        double3**     peer1COM,
        double3**     peer2COM,
        cudaStream_t  stream);
    void initPeerCOM(double3** peerCOM, double3** peerCOM2,  cudaStream_t stream);
    bool splitOverDevicesGrp1;
    bool splitOverDevicesGrp2;
    bool mGpuOn;
    bool isMaster;
    int deviceIndex;
    int numDevices;
    int numRestrainedGroup1Local;              
    int numRestrainedGroup2Local;              
  private:
    bool calcGroup1COM;       
    bool useDistMagnitude;    
    const char *groupName;    
    int      restraintExp;    
    double   restraintK;      
    double   inv_group1_mass; 
    double   inv_group2_mass; 
    double3  resDirection;    
    double3  resCenterVec;    
    double3* h_diffCOM;       
    double3* h_group1COM;     
    double3* h_group2COM;     
    double3* d_group1COM;     
    double3* d_group2COM;     
    double3* d_peer1COM;     
    double3* d_peer2COM;     
    double3* h_peer1COM;      
    double3* h_peer2COM;    
    double3** h_peer2COMG;    
    double3* h_resForce;      
    double* h_resEnergy;      
    int groupRestID;

    std::vector<HomePatch*> *patchList;        
    std::vector<int> groupAtomsSOAIndex;       
    int* d_groupAtomsSOAIndex;                 
    int numRestrainedGroup1;                   
    int numRestrainedGroup2;                   
    int totalNumRestrained;                    
    const GroupRestraintParam *resParam;       
    unsigned int* d_tbcatomic; 
};

class ComputeGroupRestraintsCUDA {
public:
    ComputeGroupRestraintsCUDA(const int ouputFreq,
                               const GroupRestraintList &resList, bool mGpuOn, int numDevices, int deviceIndex);
    
    ~ComputeGroupRestraintsCUDA();
  
    void updateAtoms(std::vector<AtomMap*> &atomMapsList,
                    std::vector<CudaLocalRecord> &localRecords,
                    const int *h_globalToLocalID);

   void doCOM_mgpu(
        const Lattice &lat,
        const char3*  d_transform,
        const float*  d_mass,
        const double* d_pos_x,
        const double* d_pos_y,
        const double* d_pos_z,
        cudaStream_t  stream);
    void initPeerCOM(cudaStream_t stream);
    void doForce(
        const int timeStep, 
        const int doEnergy,
        const int doVirial, 
        const Lattice &lat, 
        const char3*  d_transform, 
        const float*  d_mass, 
        const double* d_pos_x,
        const double* d_pos_y,
        const double* d_pos_z,
        double*       d_f_normal_x,
        double*       d_f_normal_y,
        double*       d_f_normal_z,
        cudaTensor*   d_virial,
        double*       h_extEnergy, 
        double3*      h_extForce, 
        cudaTensor*   h_extVirial, 
        cudaStream_t  stream);
private:
    int gResOutputFreq; 
    bool mGpuOn;
    int deviceIndex;
    int numDevices;
    double3** d_peer1COMG;     
    double3** d_peer2COMG;     
    std::vector<GroupRestraintsCUDA*> restraintsCUDAList;
};

#endif // NODEGROUP_FORCE_REGISTER

#endif // NAMD_CUDA

#endif // COMPUTE_GROUP_RESTRAINTS_H