Page MenuHomec4science
Files F75055679

pair_tersoff_cuda_kernel_nc.cu
No OneTemporary
Actions

File Metadata

Created
Wed, Jul 31, 03:16

pair_tersoff_cuda_kernel_nc.cu
View Options

/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
Original Version:
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
See the README file in the top-level LAMMPS directory.
-----------------------------------------------------------------------
USER-CUDA Package and associated modifications:
https://sourceforge.net/projects/lammpscuda/
Christian Trott, christian.trott@tu-ilmenau.de
Lars Winterfeld, lars.winterfeld@tu-ilmenau.de
Theoretical Physics II, University of Technology Ilmenau, Germany
See the README file in the USER-CUDA directory.
This software is distributed under the GNU General Public License.
------------------------------------------------------------------------- */
#define Pi F_F(3.1415926535897932384626433832795)
#define PI Pi
#define PI2 F_F(0.5)*Pi
#define PI4 F_F(0.25)*Pi
template <const int eflag, const int vflag>
static inline __device__ void PairVirialCompute_A_Kernel_Template()
{
__syncthreads();
ENERGY_FLOAT* shared = sharedmem;
if(eflag) {
reduceBlock(shared);
shared += blockDim.x;
}
if(vflag) {
reduceBlock(shared + 0 * blockDim.x);
reduceBlock(shared + 1 * blockDim.x);
reduceBlock(shared + 2 * blockDim.x);
reduceBlock(shared + 3 * blockDim.x);
reduceBlock(shared + 4 * blockDim.x);
reduceBlock(shared + 5 * blockDim.x);
}
if(threadIdx.x == 0) {
shared = sharedmem;
ENERGY_FLOAT* buffer = (ENERGY_FLOAT*) _buffer;
if(eflag) {
buffer[blockIdx.x * gridDim.y + blockIdx.y] = ENERGY_F(0.5) * shared[0];
shared += blockDim.x;
buffer += gridDim.x * gridDim.y;
}
if(vflag) {
buffer[blockIdx.x * gridDim.y + blockIdx.y + 0 * gridDim.x * gridDim.y] = ENERGY_F(0.5) * shared[0 * blockDim.x];
buffer[blockIdx.x * gridDim.y + blockIdx.y + 1 * gridDim.x * gridDim.y] = ENERGY_F(0.5) * shared[1 * blockDim.x];
buffer[blockIdx.x * gridDim.y + blockIdx.y + 2 * gridDim.x * gridDim.y] = ENERGY_F(0.5) * shared[2 * blockDim.x];
buffer[blockIdx.x * gridDim.y + blockIdx.y + 3 * gridDim.x * gridDim.y] = ENERGY_F(0.5) * shared[3 * blockDim.x];
buffer[blockIdx.x * gridDim.y + blockIdx.y + 4 * gridDim.x * gridDim.y] = ENERGY_F(0.5) * shared[4 * blockDim.x];
buffer[blockIdx.x * gridDim.y + blockIdx.y + 5 * gridDim.x * gridDim.y] = ENERGY_F(0.5) * shared[5 * blockDim.x];
}
}
__syncthreads();
}
__global__ void virial_fdotr_compute_kernel(int eflag)
{
int i = (blockIdx.x * gridDim.y + blockIdx.y) * blockDim.x + threadIdx.x;
ENERGY_FLOAT* sharedE = (ENERGY_FLOAT*) &sharedmem[0];
ENERGY_FLOAT* sharedVirial = (ENERGY_FLOAT*) &sharedE[blockDim.x];
sharedE += threadIdx.x;
sharedVirial += threadIdx.x;
if(i < _nlocal) {
F_FLOAT x = _x[i];
F_FLOAT y = _x[i + _nmax];
F_FLOAT z = _x[i + 2 * _nmax];
F_FLOAT fx = _f[i];
F_FLOAT fy = _f[i + _nmax];
F_FLOAT fz = _f[i + 2 * _nmax];
//if(fz*z*fz*z>1e-5) printf("V %i %i %e %e %e %e %e %e\n",i,_tag[i],x,y,z,fx,fy,fz);
sharedVirial[0] = fx * x;
sharedVirial[1 * blockDim.x] = fy * y;
sharedVirial[2 * blockDim.x] = fz * z;
sharedVirial[3 * blockDim.x] = fy * x;
sharedVirial[4 * blockDim.x] = fz * x;
sharedVirial[5 * blockDim.x] = fz * y;
} else {
sharedVirial[0] = 0;
sharedVirial[1 * blockDim.x] = 0;
sharedVirial[2 * blockDim.x] = 0;
sharedVirial[3 * blockDim.x] = 0;
sharedVirial[4 * blockDim.x] = 0;
sharedVirial[5 * blockDim.x] = 0;
}
sharedVirial = (ENERGY_FLOAT*) &sharedmem[0];
sharedVirial += blockDim.x;
reduceBlockP2(sharedVirial);
reduceBlockP2(&sharedVirial[1 * blockDim.x]);
reduceBlockP2(&sharedVirial[2 * blockDim.x]);
reduceBlockP2(&sharedVirial[3 * blockDim.x]);
reduceBlockP2(&sharedVirial[4 * blockDim.x]);
reduceBlockP2(&sharedVirial[5 * blockDim.x]);
if(threadIdx.x < 6) {
ENERGY_FLOAT* buffer = (ENERGY_FLOAT*) _buffer;
if(eflag) buffer = &buffer[gridDim.x * gridDim.y];
buffer[blockIdx.x * gridDim.y + blockIdx.y + threadIdx.x * gridDim.x * gridDim.y] = sharedVirial[threadIdx.x * blockDim.x];
}
}
/*#define vec3_scale(K,X,Y) Y.x = K*X.x; Y.y = K*X.y; Y.z = K*X.z;
#define vec3_scaleadd(K,X,Y,Z) Z.x = K*X.x+Y.x; Z.y = K*X.y+Y.y; Z.z = K*X.z+Y.z;
#define vec3_add(X,Y,Z) Z.x = X.x+Y.x; Z.y = X.y+Y.y; Z.z = X.z+Y.z;
#define vec3_dot(X,Y) (X.x*Y.x + X.y*Y.y + X.z*Y.z)*/
__device__ inline void vec3_scale(F_FLOAT k, F_FLOAT3 &x, F_FLOAT3 &y)
{
y.x = k * x.x;
y.y = k * x.y;
y.z = k * x.z;
}
__device__ inline void vec3_scale(F_FLOAT k, F_FLOAT4 &x, F_FLOAT3 &y)
{
y.x = k * x.x;
y.y = k * x.y;
y.z = k * x.z;
}
__device__ inline void vec3_scale(F_FLOAT k, F_FLOAT4 &x, F_FLOAT4 &y)
{
y.x = k * x.x;
y.y = k * x.y;
y.z = k * x.z;
}
__device__ inline void vec3_scaleadd(F_FLOAT k, F_FLOAT3 &x, F_FLOAT3 &y, F_FLOAT3 &z)
{
z.x = k * x.x + y.x;
z.y = k * x.y + y.y;
z.z = k * x.z + y.z;
}
__device__ inline void vec3_add(F_FLOAT3 &x, F_FLOAT3 &y, F_FLOAT3 &z)
{
z.x = x.x + y.x;
z.y = x.y + y.y;
z.z = x.z + y.z;
}
__device__ inline F_FLOAT vec3_dot(F_FLOAT3 x, F_FLOAT3 y)
{
return x.x * y.x + x.y * y.y + x.z * y.z;
}
__device__ inline F_FLOAT vec3_dot(F_FLOAT4 x, F_FLOAT4 y)
{
return x.x * y.x + x.y * y.y + x.z * y.z;
}
/* ----------------------------------------------------------------------
Fermi-like smoothing function
------------------------------------------------------------------------- */
__device__ inline F_FLOAT F_fermi(F_FLOAT &r, int &iparam)
{
return F_F(1.0) / (F_F(1.0) + exp(-params[iparam].ZBLexpscale * (r - params[iparam].ZBLcut)));
}
/* ----------------------------------------------------------------------
Fermi-like smoothing function derivative with respect to r
------------------------------------------------------------------------- */
__device__ inline F_FLOAT F_fermi_d(F_FLOAT &r, int &iparam)
{
volatile const F_FLOAT tmp = exp(-params[iparam].ZBLexpscale * (r - params[iparam].ZBLcut));
return params[iparam].ZBLexpscale * tmp /
((F_F(1.0) + tmp) * (F_F(1.0) + tmp));
}
__device__ inline F_FLOAT ters_fc(F_FLOAT r, F_FLOAT ters_R, F_FLOAT ters_D)
{
return (r < ters_R - ters_D) ? F_F(1.0) : ((r > ters_R + ters_D) ?
F_F(0.0) : F_F(0.5) * (F_F(1.0) - sin(PI2 * (r - ters_R) / ters_D)));
}
__device__ inline F_FLOAT ters_fc_d(F_FLOAT r, F_FLOAT ters_R, F_FLOAT ters_D)
{
return ((r < ters_R - ters_D) || (r > ters_R + ters_D)) ?
F_F(0.0) : -(PI4 / ters_D) * cos(PI2 * (r - ters_R) / ters_D);
}
__device__ inline F_FLOAT ters_gijk(F_FLOAT &cos_theta, int iparam)
{
F_FLOAT ters_c = params[iparam].c;
F_FLOAT ters_d = params[iparam].d;
return params[iparam].gamma * (F_F(1.0) + pow(params[iparam].c / params[iparam].d, F_F(2.0)) -
pow(ters_c, F_F(2.0)) / (pow(ters_d, F_F(2.0)) + pow(params[iparam].h - cos_theta, F_F(2.0))));
}
__device__ F_FLOAT ters_gijk2(F_FLOAT &cos_theta, int iparam)
{
F_FLOAT ters_c = params[iparam].c;
F_FLOAT ters_d = params[iparam].d;
return params[iparam].gamma * (F_F(1.0) + pow(ters_c / ters_d, F_F(2.0)) -
pow(ters_c, F_F(2.0)) / (pow(ters_d, F_F(2.0)) + pow(params[iparam].h - cos_theta, F_F(2.0))));
}
__device__ inline F_FLOAT ters_gijk_d(F_FLOAT costheta, int iparam)
{
F_FLOAT numerator = -F_F(2.0) * pow(params[iparam].c, F_F(2.0)) * (params[iparam].h - costheta);
F_FLOAT denominator = pow(pow(params[iparam].d, F_F(2.0)) +
pow(params[iparam].h - costheta, F_F(2.0)), F_F(2.0));
return params[iparam].gamma * numerator / denominator;
}
__device__ inline F_FLOAT zeta(int iparam, const F_FLOAT rsqij, const F_FLOAT rsqik,
F_FLOAT3 &delij, F_FLOAT3 &delik)
{
F_FLOAT rij, rik, costheta, arg, ex_delr;
rij = sqrt(rsqij);
rik = sqrt(rsqik);
costheta = vec3_dot(delij, delik) / (rij * rik);
arg = (params[iparam].powermint == 3) ? (params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik)) : params[iparam].lam3 * (rij - rik);
if(arg > F_F(69.0776)) ex_delr = F_F(1.e30);
else if(arg < -F_F(69.0776)) ex_delr = F_F(0.0);
else ex_delr = exp(arg);
return ters_fc(rik, params[iparam].bigr, params[iparam].bigd) * ex_delr * params[iparam].gamma * (F_F(1.0) + (params[iparam].c * params[iparam].c / (params[iparam].d * params[iparam].d)) -
(params[iparam].c * params[iparam].c) / ((params[iparam].d * params[iparam].d) + (params[iparam].h - costheta) * (params[iparam].h - costheta)));
}
__device__ void repulsive(int iparam, F_FLOAT rsq, F_FLOAT &fforce,
int eflag, ENERGY_FLOAT &eng)
{
F_FLOAT r, tmp_fc, tmp_fc_d, tmp_exp;
F_FLOAT ters_R = params[iparam].bigr;
F_FLOAT ters_D = params[iparam].bigd;
r = sqrt(rsq);
tmp_fc = ters_fc(r, ters_R, ters_D);
tmp_fc_d = ters_fc_d(r, ters_R, ters_D);
tmp_exp = exp(-params[iparam].lam1 * r);
if(!_zbl) {
fforce = -params[iparam].biga * tmp_exp * (tmp_fc_d - tmp_fc * params[iparam].lam1) / r;
if(eflag) eng += tmp_fc * params[iparam].biga * tmp_exp;
} else {
F_FLOAT const fforce_ters = params[iparam].biga * tmp_exp * (tmp_fc_d - tmp_fc * params[iparam].lam1);
ENERGY_FLOAT eng_ters = tmp_fc * params[iparam].biga * tmp_exp;
F_FLOAT r_ov_a = r / params[iparam].a_ij;
F_FLOAT phi = F_F(0.1818) * exp(-F_F(3.2) * r_ov_a) + F_F(0.5099) * exp(-F_F(0.9423) * r_ov_a) +
F_F(0.2802) * exp(-F_F(0.4029) * r_ov_a) + F_F(0.02817) * exp(-F_F(0.2016) * r_ov_a);
F_FLOAT dphi = (F_F(1.0) / params[iparam].a_ij) * (-F_F(3.2) * F_F(0.1818) * exp(-F_F(3.2) * r_ov_a) -
F_F(0.9423) * F_F(0.5099) * exp(-F_F(0.9423) * r_ov_a) -
F_F(0.4029) * F_F(0.2802) * exp(-F_F(0.4029) * r_ov_a) -
F_F(0.2016) * F_F(0.02817) * exp(-F_F(0.2016) * r_ov_a));
F_FLOAT fforce_ZBL = params[iparam].premult / (-r * r) * phi + params[iparam].premult / r * dphi;
ENERGY_FLOAT eng_ZBL = params[iparam].premult * (F_F(1.0) / r) * phi;
fforce = -(-F_fermi_d(r, iparam) * (eng_ZBL - eng_ters) + fforce_ZBL + F_fermi(r, iparam) * (fforce_ters - fforce_ZBL)) / r;
if(eflag)
eng += eng_ZBL + F_fermi(r, iparam) * (eng_ters - eng_ZBL);
}
}
/* ---------------------------------------------------------------------- */
__device__ inline F_FLOAT ters_fa(F_FLOAT r, int iparam, F_FLOAT ters_R, F_FLOAT ters_D)
{
if(r > ters_R + ters_D) return F_F(0.0);
if(_zbl)
return -params[iparam].bigb * exp(-params[iparam].lam2 * r) * ters_fc(r, ters_R, ters_D) * F_fermi(r, iparam);
else
return -params[iparam].bigb * exp(-params[iparam].lam2 * r) * ters_fc(r, ters_R, ters_D);
}
/* ---------------------------------------------------------------------- */
__device__ inline F_FLOAT ters_fa_d(F_FLOAT r, int iparam, F_FLOAT ters_R, F_FLOAT ters_D)
{
if(r > ters_R + ters_D) return F_F(0.0);
if(_zbl)
return params[iparam].bigb * exp(-params[iparam].lam2 * r) *
((params[iparam].lam2 * ters_fc(r, ters_R, ters_D) - ters_fc_d(r, ters_R, ters_D)) * F_fermi(r, iparam)
- ters_fc(r, ters_R, ters_D) * F_fermi_d(r, iparam));
else
return params[iparam].bigb * exp(-params[iparam].lam2 * r) *
(params[iparam].lam2 * ters_fc(r, ters_R, ters_D) - ters_fc_d(r, ters_R, ters_D));
}
/* ---------------------------------------------------------------------- */
__device__ inline F_FLOAT ters_bij(F_FLOAT zeta, int iparam)
{
F_FLOAT tmp = params[iparam].beta * zeta;
if(tmp > params[iparam].c1) return F_F(1.0) / sqrt(tmp);
if(tmp > params[iparam].c2)
return (F_F(1.0) - pow(tmp, -params[iparam].powern) / (F_F(2.0) * params[iparam].powern)) / sqrt(tmp);
if(tmp < params[iparam].c4) return F_F(1.0);
if(tmp < params[iparam].c3)
return F_F(1.0) - pow(tmp, params[iparam].powern) / (F_F(2.0) * params[iparam].powern);
return pow(F_F(1.0) + pow(tmp, params[iparam].powern), -F_F(1.0) / (F_F(2.0) * params[iparam].powern));
}
/* ---------------------------------------------------------------------- */
__device__ inline F_FLOAT ters_bij_d(F_FLOAT zeta, int iparam)
{
F_FLOAT tmp = params[iparam].beta * zeta;
if(tmp > params[iparam].c1) return params[iparam].beta * -F_F(0.5) * pow(tmp, -F_F(1.5));
if(tmp > params[iparam].c2)
return params[iparam].beta * (-F_F(0.5) * pow(tmp, -F_F(1.5)) *
(F_F(1.0) - F_F(0.5) * (F_F(1.0) + F_F(1.0) / (F_F(2.0) * params[iparam].powern)) *
pow(tmp, -params[iparam].powern)));
if(tmp < params[iparam].c4) return F_F(0.0);
if(tmp < params[iparam].c3)
return -F_F(0.5) * params[iparam].beta * pow(tmp, params[iparam].powern - F_F(1.0));
F_FLOAT tmp_n = pow(tmp, params[iparam].powern);
return -F_F(0.5) * pow(F_F(1.0) + tmp_n, -F_F(1.0) - (F_F(1.0) / (F_F(2.0) * params[iparam].powern))) * tmp_n / zeta;
}
__device__ void force_zeta(int iparam, F_FLOAT rsq, F_FLOAT zeta_ij,
F_FLOAT &fforce, F_FLOAT &prefactor,
int eflag, F_FLOAT &eng)
{
F_FLOAT r, fa, fa_d, bij;
F_FLOAT ters_R = params[iparam].bigr;
F_FLOAT ters_D = params[iparam].bigd;
r = sqrt(rsq);
fa = ters_fa(r, iparam, ters_R, ters_D);
fa_d = ters_fa_d(r, iparam, ters_R, ters_D);
bij = ters_bij(zeta_ij, iparam);
fforce = F_F(0.5) * bij * fa_d / r;
prefactor = -F_F(0.5) * fa * ters_bij_d(zeta_ij, iparam);
if(eflag) eng += bij * fa;
}
__device__ void force_zeta_prefactor_force(int iparam, F_FLOAT rsq, F_FLOAT zeta_ij,
F_FLOAT &fforce, F_FLOAT &prefactor)
{
F_FLOAT r, fa, fa_d, bij;
F_FLOAT ters_R = params[iparam].bigr;
F_FLOAT ters_D = params[iparam].bigd;
r = sqrt(rsq);
fa = ters_fa(r, iparam, ters_R, ters_D);
fa_d = ters_fa_d(r, iparam, ters_R, ters_D);
bij = ters_bij(zeta_ij, iparam);
fforce = F_F(0.5) * bij * fa_d / r;
prefactor = -F_F(0.5) * fa * ters_bij_d(zeta_ij, iparam);
}
__device__ void force_zeta_prefactor(int iparam, F_FLOAT rsq, F_FLOAT zeta_ij,
F_FLOAT &prefactor)
{
F_FLOAT r, fa;
r = sqrt(rsq);
fa = ters_fa(r, iparam, params[iparam].bigr, params[iparam].bigd);
prefactor = -F_F(0.5) * fa * ters_bij_d(zeta_ij, iparam);
}
__device__ void costheta_d(F_FLOAT3 &rij_hat, F_FLOAT &rij,
F_FLOAT3 &rik_hat, F_FLOAT &rik,
F_FLOAT3 &dri, F_FLOAT3 &drj, F_FLOAT3 &drk)
{
// first element is derivative wrt Ri, second wrt Rj, third wrt Rk
F_FLOAT cos_theta = vec3_dot(rij_hat, rik_hat);
vec3_scaleadd(-cos_theta, rij_hat, rik_hat, drj);
vec3_scale(F_F(1.0) / rij, drj, drj);
vec3_scaleadd(-cos_theta, rik_hat, rij_hat, drk);
vec3_scale(F_F(1.0) / rik, drk, drk);
vec3_add(drj, drk, dri);
vec3_scale(-F_F(1.0), dri, dri);
}
__device__ void ters_zetaterm_d(F_FLOAT prefactor,
F_FLOAT3 &rij_hat, F_FLOAT rij,
F_FLOAT3 &rik_hat, F_FLOAT rik,
F_FLOAT3 &dri, F_FLOAT3 &drj, F_FLOAT3 &drk,
int iparam)
{
F_FLOAT ex_delr, ex_delr_d, tmp;
F_FLOAT3 dcosdri, dcosdrj, dcosdrk;
if(params[iparam].powermint == 3) tmp = (params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik));
else tmp = params[iparam].lam3 * (rij - rik);
if(tmp > F_F(69.0776)) ex_delr = F_F(1.e30);
else if(tmp < -F_F(69.0776)) ex_delr = F_F(0.0);
else ex_delr = exp(tmp);
if(params[iparam].powermint == 3)
ex_delr_d = F_F(3.0) * (params[iparam].lam3 * params[iparam].lam3 * params[iparam].lam3) * (rij - rik) * (rij - rik) * ex_delr;
else ex_delr_d = params[iparam].lam3 * ex_delr;
const F_FLOAT cos_theta = vec3_dot(rij_hat, rik_hat);
costheta_d(rij_hat, rij, rik_hat, rik, dcosdri, dcosdrj, dcosdrk);
const F_FLOAT gijk = params[iparam].gamma * (F_F(1.0) + (params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d) -
(params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d + (params[iparam].h - cos_theta) * (params[iparam].h - cos_theta)));
const F_FLOAT numerator = -F_F(2.0) * params[iparam].c * params[iparam].c * (params[iparam].h - cos_theta);
const F_FLOAT denominator = (params[iparam].d * params[iparam].d) +
(params[iparam].h - cos_theta) * (params[iparam].h - cos_theta);
const F_FLOAT gijk_d = params[iparam].gamma * numerator / (denominator * denominator); // compute the derivative wrt Ri
// dri = -dfc*gijk*ex_delr*rik_hat;
// dri += fc*gijk_d*ex_delr*dcosdri;
// dri += fc*gijk*ex_delr_d*(rik_hat - rij_hat);
const F_FLOAT fc = ters_fc(rik, params[iparam].bigr, params[iparam].bigd);
const F_FLOAT dfc = ters_fc_d(rik, params[iparam].bigr, params[iparam].bigd);
vec3_scale(-dfc * gijk * ex_delr, rik_hat, dri);
vec3_scaleadd(fc * gijk_d * ex_delr, dcosdri, dri, dri);
vec3_scaleadd(fc * gijk * ex_delr_d, rik_hat, dri, dri);
vec3_scaleadd(-fc * gijk * ex_delr_d, rij_hat, dri, dri);
vec3_scale(prefactor, dri, dri);
// compute the derivative wrt Rj
// drj = fc*gijk_d*ex_delr*dcosdrj;
// drj += fc*gijk*ex_delr_d*rij_hat;
vec3_scale(fc * gijk_d * ex_delr, dcosdrj, drj);
vec3_scaleadd(fc * gijk * ex_delr_d, rij_hat, drj, drj);
vec3_scale(prefactor, drj, drj);
// compute the derivative wrt Rk
// drk = dfc*gijk*ex_delr*rik_hat;
// drk += fc*gijk_d*ex_delr*dcosdrk;
// drk += -fc*gijk*ex_delr_d*rik_hat;
vec3_scale(dfc * gijk * ex_delr, rik_hat, drk);
vec3_scaleadd(fc * gijk_d * ex_delr, dcosdrk, drk, drk);
vec3_scaleadd(-fc * gijk * ex_delr_d, rik_hat, drk, drk);
vec3_scale(prefactor, drk, drk);
}
__device__ void ters_zetaterm_d_fi(F_FLOAT &prefactor,
F_FLOAT3 &rij_hat, F_FLOAT &rij,
F_FLOAT3 &rik_hat, F_FLOAT &rik,
F_FLOAT3 &dri, int &iparam)
{
F_FLOAT ex_delr, ex_delr_d, tmp;
if(params[iparam].powermint == 3) tmp = (params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik));
else tmp = params[iparam].lam3 * (rij - rik);
if(tmp > F_F(69.0776)) ex_delr = F_F(1.e30);
else if(tmp < -F_F(69.0776)) ex_delr = F_F(0.0);
else ex_delr = exp(tmp);
if(params[iparam].powermint == 3)
ex_delr_d = F_F(3.0) * (params[iparam].lam3 * params[iparam].lam3 * params[iparam].lam3) * (rij - rik) * (rij - rik) * ex_delr;
else ex_delr_d = params[iparam].lam3 * ex_delr;
const F_FLOAT cos_theta = vec3_dot(rij_hat, rik_hat);
//costheta_d(rij_hat,rij,rik_hat,rik,dcosdri,dcosdrj,dcosdrk);
F_FLOAT3 dcosdri;
vec3_scaleadd(-cos_theta, rij_hat, rik_hat, dri);
vec3_scale(F_F(1.0) / rij, dri, dri);
vec3_scaleadd(-cos_theta, rik_hat, rij_hat, dcosdri);
vec3_scale(F_F(1.0) / rik, dcosdri, dcosdri);
vec3_add(dri, dcosdri, dcosdri);
vec3_scale(-F_F(1.0), dcosdri, dcosdri);
const F_FLOAT gijk = params[iparam].gamma * (F_F(1.0) + (params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d) -
(params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d + (params[iparam].h - cos_theta) * (params[iparam].h - cos_theta)));
const F_FLOAT numerator = -F_F(2.0) * params[iparam].c * params[iparam].c * (params[iparam].h - cos_theta);
const F_FLOAT denominator = (params[iparam].d * params[iparam].d) +
(params[iparam].h - cos_theta) * (params[iparam].h - cos_theta);
const F_FLOAT gijk_d = params[iparam].gamma * numerator / (denominator * denominator); // compute the derivative wrt Ri
//
const F_FLOAT fc = ters_fc(rik, params[iparam].bigr, params[iparam].bigd);
const F_FLOAT dfc = ters_fc_d(rik, params[iparam].bigr, params[iparam].bigd);
vec3_scale(-dfc * gijk * ex_delr, rik_hat, dri);
vec3_scaleadd(fc * gijk_d * ex_delr, dcosdri, dri, dri);
vec3_scaleadd(fc * gijk * ex_delr_d, rik_hat, dri, dri);
vec3_scaleadd(-fc * gijk * ex_delr_d, rij_hat, dri, dri);
vec3_scale(prefactor, dri, dri);
}
__device__ void ters_zetaterm_d_fj(F_FLOAT &prefactor,
F_FLOAT3 &rij_hat, F_FLOAT &rij,
F_FLOAT3 &rik_hat, F_FLOAT &rik,
F_FLOAT3 &drj, int &iparam)
{
F_FLOAT ex_delr, ex_delr_d, tmp;
if(params[iparam].powermint == 3) tmp = (params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik));
else tmp = params[iparam].lam3 * (rij - rik);
if(tmp > F_F(69.0776)) ex_delr = F_F(1.e30);
else if(tmp < -F_F(69.0776)) ex_delr = F_F(0.0);
else ex_delr = exp(tmp);
if(params[iparam].powermint == 3)
ex_delr_d = F_F(3.0) * (params[iparam].lam3 * params[iparam].lam3 * params[iparam].lam3) * (rij - rik) * (rij - rik) * ex_delr;
else ex_delr_d = params[iparam].lam3 * ex_delr;
const F_FLOAT cos_theta = vec3_dot(rij_hat, rik_hat);
vec3_scaleadd(-cos_theta, rij_hat, rik_hat, drj);
vec3_scale(F_F(1.0) / rij, drj, drj);
const F_FLOAT gijk = params[iparam].gamma * (F_F(1.0) + (params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d) -
(params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d + (params[iparam].h - cos_theta) * (params[iparam].h - cos_theta)));
const F_FLOAT numerator = -F_F(2.0) * params[iparam].c * params[iparam].c * (params[iparam].h - cos_theta);
const F_FLOAT denominator = (params[iparam].d * params[iparam].d) +
(params[iparam].h - cos_theta) * (params[iparam].h - cos_theta);
const F_FLOAT gijk_d = params[iparam].gamma * numerator / (denominator * denominator); // compute the derivative wrt Ri
const F_FLOAT fc = ters_fc(rik, params[iparam].bigr, params[iparam].bigd);
vec3_scale(fc * gijk_d * ex_delr, drj, drj);
vec3_scaleadd(fc * gijk * ex_delr_d, rij_hat, drj, drj);
vec3_scale(prefactor, drj, drj);
}
__device__ void ters_zetaterm_d_fk(F_FLOAT &prefactor,
F_FLOAT3 &rij_hat, F_FLOAT &rij,
F_FLOAT3 &rik_hat, F_FLOAT &rik,
F_FLOAT3 &drk, int &iparam)
{
F_FLOAT ex_delr, ex_delr_d, tmp;
if(params[iparam].powermint == 3) tmp = (params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik) * params[iparam].lam3 * (rij - rik));
else tmp = params[iparam].lam3 * (rij - rik);
if(tmp > F_F(69.0776)) ex_delr = F_F(1.e30);
else if(tmp < -F_F(69.0776)) ex_delr = F_F(0.0);
else ex_delr = exp(tmp);
if(params[iparam].powermint == 3)
ex_delr_d = F_F(3.0) * (params[iparam].lam3 * params[iparam].lam3 * params[iparam].lam3) * (rij - rik) * (rij - rik) * ex_delr;
else ex_delr_d = params[iparam].lam3 * ex_delr;
const F_FLOAT cos_theta = vec3_dot(rij_hat, rik_hat);
vec3_scaleadd(-cos_theta, rik_hat, rij_hat, drk);
vec3_scale(F_F(1.0) / rik, drk, drk);
const F_FLOAT gijk = params[iparam].gamma * (F_F(1.0) + (params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d) -
(params[iparam].c * params[iparam].c) / (params[iparam].d * params[iparam].d + (params[iparam].h - cos_theta) * (params[iparam].h - cos_theta)));
const F_FLOAT numerator = -F_F(2.0) * params[iparam].c * params[iparam].c * (params[iparam].h - cos_theta);
const F_FLOAT denominator = (params[iparam].d * params[iparam].d) +
(params[iparam].h - cos_theta) * (params[iparam].h - cos_theta);
const F_FLOAT gijk_d = params[iparam].gamma * numerator / (denominator * denominator); // compute the derivative wrt Ri
const F_FLOAT fc = ters_fc(rik, params[iparam].bigr, params[iparam].bigd);
const F_FLOAT dfc = ters_fc_d(rik, params[iparam].bigr, params[iparam].bigd);
vec3_scale(fc * gijk_d * ex_delr, drk, drk);
vec3_scaleadd(dfc * gijk * ex_delr, rik_hat, drk, drk);
vec3_scaleadd(-fc * gijk * ex_delr_d, rik_hat, drk, drk);
vec3_scale(prefactor, drk, drk);
}
__device__ void attractive(int iparam, F_FLOAT prefactor,
F_FLOAT4 &delij,
F_FLOAT4 &delik,
F_FLOAT3 &fi, F_FLOAT3 &fj, F_FLOAT3 &fk)
{
F_FLOAT3 rij_hat, rik_hat;
F_FLOAT rij, rijinv, rik, rikinv;
rij = sqrt(delij.w);
rijinv = F_F(1.0) / rij;
vec3_scale(rijinv, delij, rij_hat);
rik = sqrt(delik.w);
rikinv = F_F(1.0) / rik;
vec3_scale(rikinv, delik, rik_hat);
ters_zetaterm_d(prefactor, rij_hat, rij, rik_hat, rik, fi, fj, fk, iparam);
}
__device__ void attractive_fi(int &iparam, F_FLOAT &prefactor,
F_FLOAT4 &delij,
F_FLOAT4 &delik,
F_FLOAT3 &f)
{
F_FLOAT3 rij_hat, rik_hat;
F_FLOAT rij, rijinv, rik, rikinv;
rij = sqrt(delij.w);
rijinv = F_F(1.0) / rij;
vec3_scale(rijinv, delij, rij_hat);
rik = sqrt(delik.w);
rikinv = F_F(1.0) / rik;
vec3_scale(rikinv, delik, rik_hat);
ters_zetaterm_d_fi(prefactor, rij_hat, rij, rik_hat, rik, f, iparam);
}
__device__ void attractive_fj(int iparam, F_FLOAT prefactor,
F_FLOAT4 &delij,
F_FLOAT4 &delik,
F_FLOAT3 &f)
{
F_FLOAT3 rij_hat, rik_hat;
F_FLOAT rij, rijinv, rik, rikinv;
rij = sqrt(delij.w);
rijinv = F_F(1.0) / rij;
vec3_scale(rijinv, delij, rij_hat);
rik = sqrt(delik.w);
rikinv = F_F(1.0) / rik;
vec3_scale(rikinv, delik, rik_hat);
ters_zetaterm_d_fj(prefactor, rij_hat, rij, rik_hat, rik, f, iparam);
}
__device__ void attractive_fk(int iparam, F_FLOAT prefactor,
F_FLOAT4 &delij,
F_FLOAT4 &delik,
F_FLOAT3 &f)
{
F_FLOAT3 rij_hat, rik_hat;
F_FLOAT rij, rijinv, rik, rikinv;
rij = sqrt(delij.w);
rijinv = F_F(1.0) / rij;
vec3_scale(rijinv, delij, rij_hat);
rik = sqrt(delik.w);
rikinv = F_F(1.0) / rik;
vec3_scale(rikinv, delik, rik_hat);
ters_zetaterm_d_fk(prefactor, rij_hat, rij, rik_hat, rik, f, iparam);
}
__global__ void Pair_Tersoff_Kernel_TpA_RIJ()//F_FLOAT4* _glob_r_ij,int* _glob_numneigh_red,int* _glob_neighbors_red,int* _glob_neightype_red)
{
int ii = (blockIdx.x * gridDim.y + blockIdx.y) * blockDim.x + threadIdx.x;
if(ii >= _nall) return;
X_FLOAT4 myxtype;
F_FLOAT4 delij;
F_FLOAT xtmp, ytmp, ztmp;
int itype, jnum, i, j;
int* jlist;
int neigh_red = 0;
i = ii;//_ilist[ii];
myxtype = fetchXType(i);
xtmp = myxtype.x;
ytmp = myxtype.y;
ztmp = myxtype.z;
itype = map[(static_cast <int>(myxtype.w))];
jnum = _numneigh[i];
jlist = &_neighbors[i];
__syncthreads();
for(int jj = 0; jj < jnum; jj++) {
if(jj < jnum) {
j = jlist[jj * _nall];
j &= NEIGHMASK;
myxtype = fetchXType(j);
delij.x = xtmp - myxtype.x;
delij.y = ytmp - myxtype.y;
delij.z = ztmp - myxtype.z;
int jtype = map[(static_cast <int>(myxtype.w))];
int iparam_ij = elem2param[(itype * nelements + jtype) * nelements + jtype];
delij.w = vec3_dot(delij, delij);
if(delij.w < params[iparam_ij].cutsq) {
_glob_neighbors_red[i + neigh_red * _nall] = j;
_glob_neightype_red[i + neigh_red * _nall] = jtype;
_glob_r_ij[i + neigh_red * _nall] = delij;
neigh_red++;
}
}
}
_glob_numneigh_red[i] = neigh_red;
}
__global__ void Pair_Tersoff_Kernel_TpA_ZetaIJ()//F_FLOAT* _glob_zeta_ij,F_FLOAT4* _glob_r_ij,int* _glob_numneigh_red,int* _glob_neighbors_red,int* _glob_neightype_red)
{
int ii = (blockIdx.x * gridDim.y + blockIdx.y) * blockDim.x + threadIdx.x;
if(ii >= _nall) return;
F_FLOAT4 delij;
F_FLOAT4 delik;
int itype, jnum, i, j;
int* jlist;
i = ii;
itype = map[(static_cast <int>(_type[i]))];
jnum = _glob_numneigh_red[i];
jlist = &_glob_neighbors_red[i];
__syncthreads();
for(int jj = 0; jj < jnum; jj++) {
if(jj < jnum) {
j = jlist[jj * _nall];
j &= NEIGHMASK;
int jtype = _glob_neightype_red[i + jj * _nall];
delij = _glob_r_ij[i + jj * _nall];
int iparam_ij = elem2param[(itype * nelements + jtype) * nelements + jtype];
if(delij.w < params[iparam_ij].cutsq) {
F_FLOAT zeta_ij = 0.0;
F_FLOAT3 delij3 = {delij.x, delij.y, delij.z};
for(int kk = 0; kk < jnum; kk++) {
if(jj == kk) continue;
int k = jlist[kk * _nall];
k &= NEIGHMASK;
int ktype = _glob_neightype_red[i + kk * _nall];
delik = _glob_r_ij[i + kk * _nall];
F_FLOAT3 delik3 = {delik.x, delik.y, delik.z};
int iparam_ijk = elem2param[(itype * nelements + jtype) * nelements + ktype];
const F_FLOAT rsqki = delik.w;
if(rsqki <= params[iparam_ijk].cutsq)
zeta_ij += zeta(iparam_ijk, delij.w, rsqki, delij3, delik3);
}
_glob_zeta_ij[i + jj * _nall] = zeta_ij;
}
}
}
}
//back3: num 12 steps 10: ZetaIJ/TPA 0.255/0.106
//back5: num 12 steps 10: ZetaIJ/TPA 0.257/0.098
//back6: num 12 steps 10: ZetaIJ/TPA 0.027/0.097 /rij berechnung extra
//back12: num 12 steps 10: ZetaIJ/TPA 0.026/0.070
//back15: num 12 steps 10: ZetaIJ/TPA 0.0137/0.0287 //pow beseitigt
// num 12 steps 10: ZetaIJ/TPA 0.0137/0.027
template <int eflag, int vflagm>
__global__ void Pair_Tersoff_Kernel_TpA(int eflag_atom, int vflag_atom) //,F_FLOAT* _glob_zeta_ij,F_FLOAT4* _glob_r_ij,int* _glob_numneigh_red,int* _glob_neighbors_red,int* _glob_neightype_red)
{
ENERGY_FLOAT evdwl = ENERGY_F(0.0);
ENERGY_FLOAT* sharedE = &sharedmem[threadIdx.x];
ENERGY_FLOAT* sharedV = &sharedmem[threadIdx.x];
F_FLOAT* shared_F_F = (F_FLOAT*) sharedmem;
if((eflag || eflag_atom) && (vflagm || vflag_atom)) shared_F_F = (F_FLOAT*) &sharedmem[7 * blockDim.x];
else if(eflag) shared_F_F = (F_FLOAT*) &sharedmem[blockDim.x];
else if(vflagm) shared_F_F = (F_FLOAT*) &sharedmem[6 * blockDim.x];
shared_F_F += threadIdx.x;
if(eflag_atom || eflag) {
sharedE[0] = ENERGY_F(0.0);
sharedV += blockDim.x;
}
if(vflagm || vflag_atom) {
sharedV[0 * blockDim.x] = ENERGY_F(0.0);
sharedV[1 * blockDim.x] = ENERGY_F(0.0);
sharedV[2 * blockDim.x] = ENERGY_F(0.0);
sharedV[3 * blockDim.x] = ENERGY_F(0.0);
sharedV[4 * blockDim.x] = ENERGY_F(0.0);
sharedV[5 * blockDim.x] = ENERGY_F(0.0);
}
int jnum_red = 0;
#define fxtmp shared_F_F[0]
#define fytmp shared_F_F[blockDim.x]
#define fztmp shared_F_F[2*blockDim.x]
//#define jnum_red (static_cast <int> (shared_F_F[3*blockDim.x]))
int ii = (blockIdx.x * gridDim.y + blockIdx.y) * blockDim.x + threadIdx.x;
X_FLOAT4 myxtype_i, myxtype_j, myxtype_k;
F_FLOAT4 delij, delik, deljk;
F_FLOAT fpair;
F_FLOAT prefactor_ij, prefactor_ji;
int itype, i, j;
int* jlist_red;
if(ii < _inum) {
i = _ilist[ii];
if(vflagm)
myxtype_i = fetchXType(i);
//itype=map[(static_cast <int> (myxtype_i.w))];
itype = map[_type[i]];
fxtmp = F_F(0.0);
fytmp = F_F(0.0);
fztmp = F_F(0.0);
//shared_F_F[3*blockDim.x] = _glob_numneigh_red[i];
jnum_red = _glob_numneigh_red[i];
jlist_red = &_glob_neighbors_red[i];
}
__syncthreads();
#pragma unroll 1
for(int jj = 0; jj < jnum_red; jj++) {
if(i < _nlocal) {
fpair = F_F(0.0);
j = jlist_red[jj * _nall];
j &= NEIGHMASK;
if(vflagm)
myxtype_j = fetchXType(j);
int jtype = _glob_neightype_red[i + jj * _nall];
delij = _glob_r_ij[i + jj * _nall];
volatile int iparam_ij = elem2param[(itype * nelements + jtype) * nelements + jtype];
volatile int iparam_ji = elem2param[(jtype * nelements + itype) * nelements + itype];
if(delij.w < params[iparam_ij].cutsq) {
F_FLOAT dxfp, dyfp, dzfp;
repulsive(iparam_ij, delij.w, fpair, eflag, evdwl);
fxtmp += dxfp = delij.x * fpair;
fytmp += dyfp = delij.y * fpair;
fztmp += dzfp = delij.z * fpair;
if(vflagm) {
sharedV[0 * blockDim.x] += delij.x * dxfp;
sharedV[1 * blockDim.x] += delij.y * dyfp;
sharedV[2 * blockDim.x] += delij.z * dzfp;
sharedV[3 * blockDim.x] += delij.x * dyfp;
sharedV[4 * blockDim.x] += delij.x * dzfp;
sharedV[5 * blockDim.x] += delij.y * dzfp;
}
force_zeta(iparam_ij, delij.w, _glob_zeta_ij[i + jj * _nall], fpair, prefactor_ij, eflag, evdwl);
fxtmp -=
dxfp = delij.x * fpair;
fytmp -=
dyfp = delij.y * fpair;
fztmp -=
dzfp = delij.z * fpair;
if(vflagm) {
sharedV[0 * blockDim.x] -= ENERGY_F(2.0) * delij.x * dxfp;
sharedV[1 * blockDim.x] -= ENERGY_F(2.0) * delij.y * dyfp;
sharedV[2 * blockDim.x] -= ENERGY_F(2.0) * delij.z * dzfp;
sharedV[3 * blockDim.x] -= ENERGY_F(2.0) * delij.x * dyfp;
sharedV[4 * blockDim.x] -= ENERGY_F(2.0) * delij.x * dzfp;
sharedV[5 * blockDim.x] -= ENERGY_F(2.0) * delij.y * dzfp;
}
int j_jj = 0;
//#pragma unroll 1
for(int kk = 0; kk < _glob_numneigh_red[j]; kk++) {
if(_glob_neighbors_red[j + kk * _nall] == i) j_jj = kk;
}
force_zeta_prefactor_force(iparam_ji, delij.w, _glob_zeta_ij[j + j_jj * _nall], fpair, prefactor_ji);
fxtmp -=
dxfp = delij.x * fpair;
fytmp -=
dyfp = delij.y * fpair;
fztmp -=
dzfp = delij.z * fpair;
vec3_scale(F_F(-1.0), delij, delij);
#pragma unroll 1
for(int kk = 0; kk < jnum_red; kk++) {
if(jj == kk) continue;
int k = jlist_red[kk * _nall];
k &= NEIGHMASK;
if(vflagm)
myxtype_k = fetchXType(k);
delik = _glob_r_ij[i + kk * _nall];
int ktype = _glob_neightype_red[i + kk * _nall];
int iparam_ijk = elem2param[(itype * nelements + jtype) * nelements + ktype];
vec3_scale(F_F(-1.0), delik, delik);
if(delik.w <= params[iparam_ijk].cutsq) {
if(vflagm) {
F_FLOAT3 fi, fj, fk;
attractive(iparam_ijk, prefactor_ij,
delij, delik, fi, fj, fk);
fxtmp += fi.x;
fytmp += fi.y;
fztmp += fi.z;
sharedV[0 * blockDim.x] += ENERGY_F(2.0) * myxtype_i.x * fi.x;
sharedV[1 * blockDim.x] += ENERGY_F(2.0) * myxtype_i.y * fi.y;
sharedV[2 * blockDim.x] += ENERGY_F(2.0) * myxtype_i.z * fi.z;
sharedV[3 * blockDim.x] += ENERGY_F(2.0) * myxtype_i.x * fi.y;
sharedV[4 * blockDim.x] += ENERGY_F(2.0) * myxtype_i.x * fi.z;
sharedV[5 * blockDim.x] += ENERGY_F(2.0) * myxtype_i.y * fi.z;
sharedV[0 * blockDim.x] += ENERGY_F(2.0) * myxtype_j.x * fj.x;
sharedV[1 * blockDim.x] += ENERGY_F(2.0) * myxtype_j.y * fj.y;
sharedV[2 * blockDim.x] += ENERGY_F(2.0) * myxtype_j.z * fj.z;
sharedV[3 * blockDim.x] += ENERGY_F(2.0) * myxtype_j.x * fj.y;
sharedV[4 * blockDim.x] += ENERGY_F(2.0) * myxtype_j.x * fj.z;
sharedV[5 * blockDim.x] += ENERGY_F(2.0) * myxtype_j.y * fj.z;
sharedV[0 * blockDim.x] += ENERGY_F(2.0) * myxtype_k.x * fk.x;
sharedV[1 * blockDim.x] += ENERGY_F(2.0) * myxtype_k.y * fk.y;
sharedV[2 * blockDim.x] += ENERGY_F(2.0) * myxtype_k.z * fk.z;
sharedV[3 * blockDim.x] += ENERGY_F(2.0) * myxtype_k.x * fk.y;
sharedV[4 * blockDim.x] += ENERGY_F(2.0) * myxtype_k.x * fk.z;
sharedV[5 * blockDim.x] += ENERGY_F(2.0) * myxtype_k.y * fk.z;
} else {
F_FLOAT3 fi; //local variable
attractive_fi(iparam_ijk, prefactor_ij,
delij, delik, fi);
fxtmp += fi.x;
fytmp += fi.y;
fztmp += fi.z;
}
}
}
int j_jnum_red = _glob_numneigh_red[j];
int* j_jlist_red = &_glob_neighbors_red[j];
int j_ii = 0;
//#pragma unroll 1
for(int j_kk = 0; j_kk < j_jnum_red; j_kk++) {
if(j_jlist_red[j_kk * _nall] == i) j_ii = j_kk;
}
#pragma unroll 1
for(int kk = 0; kk < j_jnum_red; kk++) {
if(j_ii == kk) continue;
int k = j_jlist_red[kk * _nall];
k &= NEIGHMASK;
deljk = _glob_r_ij[j + kk * _nall];
vec3_scale(F_F(-1.0), deljk, deljk);
int ktype = _glob_neightype_red[j + kk * _nall];
int iparam_jik = elem2param[(jtype * nelements + itype) * nelements + ktype];
int iparam_jki = elem2param[(jtype * nelements + ktype) * nelements + itype];
vec3_scale(F_F(-1.0), delij, delij);
if(deljk.w <= params[iparam_jik].cutsq) {
F_FLOAT3 ftmp; //local variable
attractive_fj(iparam_jik, prefactor_ji,
delij, deljk, ftmp);
fxtmp += ftmp.x;
fytmp += ftmp.y;
fztmp += ftmp.z;
int iparam_jk = elem2param[(jtype * nelements + ktype) * nelements + ktype];
F_FLOAT prefactor_jk;
force_zeta_prefactor(iparam_jk, deljk.w, _glob_zeta_ij[j + kk * _nall], prefactor_jk);
attractive_fk(iparam_jki, prefactor_jk,
deljk, delij, ftmp);
fxtmp += ftmp.x;
fytmp += ftmp.y;
fztmp += ftmp.z;
}
vec3_scale(F_F(-1.0), delij, delij);
}
}
}
}
__syncthreads();
if(ii < _inum) {
F_FLOAT* my_f;
if(_collect_forces_later) {
ENERGY_FLOAT* buffer = (ENERGY_FLOAT*) _buffer;
if(eflag) {
buffer = &buffer[1 * gridDim.x * gridDim.y];
}
if(vflagm) {
buffer = &buffer[6 * gridDim.x * gridDim.y];
}
my_f = (F_FLOAT*) buffer;
my_f += i;
*my_f = fxtmp;
my_f += _nmax;
*my_f = fytmp;
my_f += _nmax;
*my_f = fztmp;
} else {
my_f = _f + i;
*my_f += fxtmp;
my_f += _nmax;
*my_f += fytmp;
my_f += _nmax;
*my_f += fztmp;
}
}
__syncthreads();
if(eflag) {
sharedE[0] = evdwl;
}
if(eflag_atom && i < _nlocal) {
_eatom[i] = ENERGY_F(0.5) * evdwl;
}
if(vflag_atom && i < _nlocal) {
_vatom[i] = ENERGY_F(0.5) * sharedV[0 * blockDim.x];
_vatom[i + _nmax] = ENERGY_F(0.5) * sharedV[1 * blockDim.x];
_vatom[i + 2 * _nmax] = ENERGY_F(0.5) * sharedV[2 * blockDim.x];
_vatom[i + 3 * _nmax] = ENERGY_F(0.5) * sharedV[3 * blockDim.x];
_vatom[i + 4 * _nmax] = ENERGY_F(0.5) * sharedV[4 * blockDim.x];
_vatom[i + 5 * _nmax] = ENERGY_F(0.5) * sharedV[5 * blockDim.x];
}
if(vflagm && eflag) PairVirialCompute_A_Kernel_Template<1, 1>();
else if(eflag) PairVirialCompute_A_Kernel_Template<1, 0>();
else if(vflagm) PairVirialCompute_A_Kernel_Template<0, 1>();
#undef fxtmp
#undef fytmp
#undef fztmp
//#undef jnum_red
}

Event Timeline

c4science · Help