forked from lijiext/lammps
git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@13305 f3b2605a-c512-4ea7-a41b-209d697bcdaa
This commit is contained in:
sjplimp
parent
185b8197d5
commit
f1acd4762f
|
|
@ -0,0 +1,373 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_buck_coul_cut_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairBuckCoulCutKokkos<DeviceType>::PairBuckCoulCutKokkos(LAMMPS *lmp):PairBuckCoulCut(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = NULL;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairBuckCoulCutKokkos<DeviceType>::~PairBuckCoulCutKokkos()
|
||||
{
|
||||
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_ljsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_coulsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
memory->sfree(cut_ljsq);
|
||||
memory->sfree(cut_coulsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = NULL;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
if (eflag_atom) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->create_kokkos(k_eatom,eatom,maxeatom,"pair:eatom");
|
||||
d_eatom = k_eatom.view<DeviceType>();
|
||||
}
|
||||
if (vflag_atom) {
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
memory->create_kokkos(k_vatom,vatom,maxvatom,6,"pair:vatom");
|
||||
d_vatom = k_vatom.view<DeviceType>();
|
||||
}
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev = pair_compute<PairBuckCoulCutKokkos<DeviceType>,void >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) virial_fdotr_compute();
|
||||
|
||||
if (eflag_atom) {
|
||||
k_eatom.template modify<DeviceType>();
|
||||
k_eatom.template sync<LMPHostType>();
|
||||
}
|
||||
|
||||
if (vflag_atom) {
|
||||
k_vatom.template modify<DeviceType>();
|
||||
k_vatom.template sync<LMPHostType>();
|
||||
}
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute Buckingham pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulCutKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT rexp = exp(-r*(STACKPARAMS?m_params[itype][jtype].rhoinv:params(itype,jtype).rhoinv));
|
||||
|
||||
const F_FLOAT forcebuck =
|
||||
(STACKPARAMS?m_params[itype][jtype].buck1:params(itype,jtype).buck1)*r*rexp -
|
||||
(STACKPARAMS?m_params[itype][jtype].buck2:params(itype,jtype).buck2)*r6inv;
|
||||
|
||||
return forcebuck*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute Buckingham pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulCutKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT rexp = exp(-r*(STACKPARAMS?m_params[itype][jtype].rhoinv:params(itype,jtype).rhoinv));
|
||||
|
||||
return (STACKPARAMS?m_params[itype][jtype].a:params(itype,jtype).a)*rexp -
|
||||
(STACKPARAMS?m_params[itype][jtype].c:params(itype,jtype).c)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulCutKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
F_FLOAT forcecoul;
|
||||
|
||||
forcecoul = qqrd2e*qtmp*q(j) *rinv;
|
||||
|
||||
return factor_coul*forcecoul*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulCutKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
|
||||
return factor_coul*qqrd2e*qtmp*q(j)*rinv;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulCutKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairBuckCoulCut::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
memory->destroy(cut_coulsq);
|
||||
memory->create_kokkos(k_cut_coulsq,cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_buck_coul**,Kokkos::LayoutRight,DeviceType>("PairBuckCoulCut::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulCutKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairBuckCoulCut::settings(1,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulCutKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairBuckCoulCut::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == N2) {
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
} else if (neighflag == FULLCLUSTER) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 1;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with buck/coul/cut/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairBuckCoulCutKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairBuckCoulCut::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq[i][j];
|
||||
double cut_coulsqm = cut_coulsq[i][j];
|
||||
|
||||
k_params.h_view(i,j).a = a[i][j];
|
||||
k_params.h_view(i,j).c = c[i][j];
|
||||
k_params.h_view(i,j).rhoinv = rhoinv[i][j];
|
||||
k_params.h_view(i,j).buck1 = buck1[i][j];
|
||||
k_params.h_view(i,j).buck2 = buck2[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
template class PairBuckCoulCutKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairBuckCoulCutKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(buck/coul/cut/kk,PairBuckCoulCutKokkos<LMPDeviceType>)
|
||||
PairStyle(buck/coul/cut/kk/device,PairBuckCoulCutKokkos<LMPDeviceType>)
|
||||
PairStyle(buck/coul/cut/kk/host,PairBuckCoulCutKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_BUCK_COUL_CUT_KOKKOS_H
|
||||
#define LMP_PAIR_BUCK_COUL_CUT_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_buck_coul_cut.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairBuckCoulCutKokkos : public PairBuckCoulCut {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairBuckCoulCutKokkos(class LAMMPS *);
|
||||
~PairBuckCoulCutKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_buck_coul{
|
||||
params_buck_coul(){cut_ljsq=0;cut_coulsq=0;a=0;c=0;rhoinv=0;buck1=0;buck2=0;offset=0;};
|
||||
params_buck_coul(int i){cut_ljsq=0;cut_coulsq=0;a=0;c=0;rhoinv=0;buck1=0;buck2=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,a,c,rhoinv,buck1,buck2,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy() {}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_buck_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_buck_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_buck_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_lj[4], special_coul[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairBuckCoulCutKokkos,FULL,true>;
|
||||
friend class PairComputeFunctor<PairBuckCoulCutKokkos,HALF,true>;
|
||||
friend class PairComputeFunctor<PairBuckCoulCutKokkos,HALFTHREAD,true>;
|
||||
friend class PairComputeFunctor<PairBuckCoulCutKokkos,FULL,false>;
|
||||
friend class PairComputeFunctor<PairBuckCoulCutKokkos,HALF,false>;
|
||||
friend class PairComputeFunctor<PairBuckCoulCutKokkos,HALFTHREAD,false>;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulCutKokkos,FULL,void>(PairBuckCoulCutKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulCutKokkos,HALF,void>(PairBuckCoulCutKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulCutKokkos,HALFTHREAD,void>(PairBuckCoulCutKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairBuckCoulCutKokkos,void>(PairBuckCoulCutKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,517 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_buck_coul_long_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
|
||||
#define EWALD_F 1.12837917
|
||||
#define EWALD_P 0.3275911
|
||||
#define A1 0.254829592
|
||||
#define A2 -0.284496736
|
||||
#define A3 1.421413741
|
||||
#define A4 -1.453152027
|
||||
#define A5 1.061405429
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairBuckCoulLongKokkos<DeviceType>::PairBuckCoulLongKokkos(LAMMPS *lmp):PairBuckCoulLong(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = 0.0;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairBuckCoulLongKokkos<DeviceType>::~PairBuckCoulLongKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_ljsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_coulsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
memory->sfree(cut_ljsq);
|
||||
//memory->sfree(cut_coulsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
//cut_coulsq = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulLongKokkos<DeviceType>::cleanup_copy() {
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
ftable = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev;
|
||||
if(ncoultablebits)
|
||||
ev = pair_compute<PairBuckCoulLongKokkos<DeviceType>,CoulLongTable<1> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
else
|
||||
ev = pair_compute<PairBuckCoulLongKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute Buckingham pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulLongKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT rexp = exp(-r*(STACKPARAMS?m_params[itype][jtype].rhoinv:params(itype,jtype).rhoinv));
|
||||
|
||||
const F_FLOAT forcebuck =
|
||||
(STACKPARAMS?m_params[itype][jtype].buck1:params(itype,jtype).buck1)*r*rexp -
|
||||
(STACKPARAMS?m_params[itype][jtype].buck2:params(itype,jtype).buck2)*r6inv;
|
||||
|
||||
return forcebuck*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute Buckingham pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulLongKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT rexp = exp(-r*(STACKPARAMS?m_params[itype][jtype].rhoinv:params(itype,jtype).rhoinv));
|
||||
|
||||
return (STACKPARAMS?m_params[itype][jtype].a:params(itype,jtype).a)*rexp -
|
||||
(STACKPARAMS?m_params[itype][jtype].c:params(itype,jtype).c)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulLongKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable && rsq > tabinnersq) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_ftable[itable] + fraction*d_dftable[itable];
|
||||
F_FLOAT forcecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return forcecoul/rsq;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT rinv = 1.0/r;
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]*rinv;
|
||||
F_FLOAT forcecoul = prefactor * (erfc + EWALD_F*grij*expm2);
|
||||
if (factor_coul < 1.0) forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
|
||||
return forcecoul*rinv*rinv;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairBuckCoulLongKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_etable[itable] + fraction*d_detable[itable];
|
||||
F_FLOAT ecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
ecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return ecoul;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]/r;
|
||||
F_FLOAT ecoul = prefactor * erfc;
|
||||
if (factor_coul < 1.0) ecoul -= (1.0-factor_coul)*prefactor;
|
||||
return ecoul;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulLongKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairBuckCoulLong::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
|
||||
memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
|
||||
k_params = Kokkos::DualView<params_buck_coul**,Kokkos::LayoutRight,DeviceType>("PairBuckCoulLong::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulLongKokkos<DeviceType>::init_tables(double cut_coul, double *cut_respa)
|
||||
{
|
||||
Pair::init_tables(cut_coul,cut_respa);
|
||||
|
||||
typedef typename ArrayTypes<DeviceType>::t_ffloat_1d table_type;
|
||||
typedef typename ArrayTypes<LMPHostType>::t_ffloat_1d host_table_type;
|
||||
|
||||
int ntable = 1;
|
||||
for (int i = 0; i < ncoultablebits; i++) ntable *= 2;
|
||||
|
||||
|
||||
// Copy rtable and drtable
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = rtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_rtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = drtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_drtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ftable and dftable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ctable and dctable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy etable and detable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = etable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_etable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = detable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_detable = d_table;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulLongKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairBuckCoulLong::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairBuckCoulLongKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairBuckCoulLong::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with buck/coul/long/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairBuckCoulLongKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairBuckCoulLong::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq[i][j];
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).a = a[i][j];
|
||||
k_params.h_view(i,j).c = c[i][j];
|
||||
k_params.h_view(i,j).rhoinv = rhoinv[i][j];
|
||||
k_params.h_view(i,j).buck1 = buck1[i][j];
|
||||
k_params.h_view(i,j).buck2 = buck2[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
|
||||
}
|
||||
|
||||
|
||||
template class PairBuckCoulLongKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairBuckCoulLongKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,150 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(buck/coul/long/kk,PairBuckCoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(buck/coul/long/kk/device,PairBuckCoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(buck/coul/long/kk/host,PairBuckCoulLongKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_BUCK_COUL_LONG_KOKKOS_H
|
||||
#define LMP_PAIR_BUCK_COUL_LONG_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_buck_coul_long.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairBuckCoulLongKokkos : public PairBuckCoulLong {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairBuckCoulLongKokkos(class LAMMPS *);
|
||||
~PairBuckCoulLongKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_tables(double cut_coul, double *cut_respa);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_buck_coul{
|
||||
params_buck_coul(){cut_ljsq=0;cut_coulsq=0;a=0;c=0;rhoinv=0;buck1=0;buck2=0;offset=0;};
|
||||
params_buck_coul(int i){cut_ljsq=0;cut_coulsq=0;a=0;c=0;rhoinv=0;buck1=0;buck2=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,a,c,rhoinv,buck1,buck2,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_buck_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_buck_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_buck_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_lj[4], special_coul[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulLongKokkos,FULL,CoulLongTable<1> >(PairBuckCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulLongKokkos,HALF,CoulLongTable<1> >(PairBuckCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulLongKokkos,HALFTHREAD,CoulLongTable<1> >(PairBuckCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairBuckCoulLongKokkos,CoulLongTable<1> >(PairBuckCoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairBuckCoulLongKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulLongKokkos,FULL,CoulLongTable<0> >(PairBuckCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulLongKokkos,HALF,CoulLongTable<0> >(PairBuckCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairBuckCoulLongKokkos,HALFTHREAD,CoulLongTable<0> >(PairBuckCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairBuckCoulLongKokkos,CoulLongTable<0> >(PairBuckCoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairBuckCoulLongKokkos>(PairBuckCoulLongKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,313 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_coul_debye_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairCoulDebyeKokkos<DeviceType>::PairCoulDebyeKokkos(LAMMPS *lmp):PairCoulDebye(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairCoulDebyeKokkos<DeviceType>::~PairCoulDebyeKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_cutsq, cutsq);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulDebyeKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulDebyeKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev = pair_compute<PairCoulDebyeKokkos<DeviceType>,void >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) virial_fdotr_compute();
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairCoulDebyeKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r = 1.0/rinv;
|
||||
const F_FLOAT screening = exp(-kappa*r);
|
||||
F_FLOAT forcecoul;
|
||||
|
||||
forcecoul = qqrd2e * qtmp * q(j) * screening * (kappa + rinv) *
|
||||
(STACKPARAMS?m_params[itype][jtype].scale:params(itype,jtype).scale);
|
||||
|
||||
return factor_coul*forcecoul*r2inv;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairCoulDebyeKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r = 1.0/rinv;
|
||||
const F_FLOAT screening = exp(-kappa*r);
|
||||
|
||||
return factor_coul * qqrd2e * qtmp * q(j) * rinv * screening *
|
||||
(STACKPARAMS?m_params[itype][jtype].scale:params(itype,jtype).scale);
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulDebyeKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairCoulDebye::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_coul**,Kokkos::LayoutRight,DeviceType>("PairCoulDebye::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulDebyeKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
kappa = force->numeric(FLERR,arg[0]);
|
||||
cut_global = force->numeric(FLERR,arg[1]);
|
||||
|
||||
// reset cutoffs that have been explicitly set
|
||||
|
||||
if (allocated) {
|
||||
int i,j;
|
||||
for (i = 1; i <= atom->ntypes; i++)
|
||||
for (j = i+1; j <= atom->ntypes; j++)
|
||||
if (setflag[i][j]) cut[i][j] = cut_global;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulDebyeKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairCoulDebye::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == N2) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == FULLCLUSTER) {
|
||||
neighbor->requests[irequest]->full_cluster = 1;
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with coul/debye/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairCoulDebyeKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairCoulDebye::init_one(i,j);
|
||||
|
||||
k_params.h_view(i,j).scale = scale[i][j];
|
||||
k_params.h_view(i,j).cutsq = cutone*cutone;
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cutone*cutone;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cutone*cutone;
|
||||
}
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
//k_cut_ljsq.h_view(i,j) = cutone*cutone;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
//k_cut_coulsq.h_view(i,j) = cutone*cutone;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
template class PairCoulDebyeKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairCoulDebyeKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(coul/debye/kk,PairCoulDebyeKokkos<LMPDeviceType>)
|
||||
PairStyle(coul/debye/kk/device,PairCoulDebyeKokkos<LMPDeviceType>)
|
||||
PairStyle(coul/debye/kk/host,PairCoulDebyeKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_COUL_DEBYE_KOKKOS_H
|
||||
#define LMP_PAIR_COUL_DEBYE_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_coul_debye.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairCoulDebyeKokkos : public PairCoulDebye {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairCoulDebyeKokkos(class LAMMPS *);
|
||||
~PairCoulDebyeKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_coul{
|
||||
params_coul(){cutsq=0,scale=0;};
|
||||
params_coul(int i){cutsq=0,scale=0;};
|
||||
F_FLOAT cutsq, scale;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
friend class PairComputeFunctor<PairCoulDebyeKokkos,FULL,true>;
|
||||
friend class PairComputeFunctor<PairCoulDebyeKokkos,HALF,true>;
|
||||
friend class PairComputeFunctor<PairCoulDebyeKokkos,HALFTHREAD,true>;
|
||||
friend class PairComputeFunctor<PairCoulDebyeKokkos,FULL,false>;
|
||||
friend class PairComputeFunctor<PairCoulDebyeKokkos,HALF,false>;
|
||||
friend class PairComputeFunctor<PairCoulDebyeKokkos,HALFTHREAD,false>;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulDebyeKokkos,FULL,void>(PairCoulDebyeKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulDebyeKokkos,HALF,void>(PairCoulDebyeKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulDebyeKokkos,HALFTHREAD,void>(PairCoulDebyeKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairCoulDebyeKokkos,void>(PairCoulDebyeKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,456 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_coul_long_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
|
||||
#define EWALD_F 1.12837917
|
||||
#define EWALD_P 0.3275911
|
||||
#define A1 0.254829592
|
||||
#define A2 -0.284496736
|
||||
#define A3 1.421413741
|
||||
#define A4 -1.453152027
|
||||
#define A5 1.061405429
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairCoulLongKokkos<DeviceType>::PairCoulLongKokkos(LAMMPS *lmp):PairCoulLong(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_coulsq = 0.0;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairCoulLongKokkos<DeviceType>::~PairCoulLongKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_coulsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulLongKokkos<DeviceType>::cleanup_copy() {
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
ftable = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev;
|
||||
if(ncoultablebits)
|
||||
ev = pair_compute<PairCoulLongKokkos<DeviceType>,CoulLongTable<1> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
else
|
||||
ev = pair_compute<PairCoulLongKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairCoulLongKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable && rsq > tabinnersq) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_ftable[itable] + fraction*d_dftable[itable];
|
||||
F_FLOAT forcecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return forcecoul/rsq;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT rinv = 1.0/r;
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]*rinv;
|
||||
F_FLOAT forcecoul = prefactor * (erfc + EWALD_F*grij*expm2);
|
||||
if (factor_coul < 1.0) forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
|
||||
return forcecoul*rinv*rinv;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairCoulLongKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_etable[itable] + fraction*d_detable[itable];
|
||||
F_FLOAT ecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
ecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return ecoul;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]/r;
|
||||
F_FLOAT ecoul = prefactor * erfc;
|
||||
if (factor_coul < 1.0) ecoul -= (1.0-factor_coul)*prefactor;
|
||||
return ecoul;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulLongKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairCoulLong::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
|
||||
k_params = Kokkos::DualView<params_coul**,Kokkos::LayoutRight,DeviceType>("PairCoulLong::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulLongKokkos<DeviceType>::init_tables(double cut_coul, double *cut_respa)
|
||||
{
|
||||
Pair::init_tables(cut_coul,cut_respa);
|
||||
|
||||
typedef typename ArrayTypes<DeviceType>::t_ffloat_1d table_type;
|
||||
typedef typename ArrayTypes<LMPHostType>::t_ffloat_1d host_table_type;
|
||||
|
||||
int ntable = 1;
|
||||
for (int i = 0; i < ncoultablebits; i++) ntable *= 2;
|
||||
|
||||
|
||||
// Copy rtable and drtable
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = rtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_rtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = drtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_drtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ftable and dftable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ctable and dctable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy etable and detable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = etable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_etable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = detable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_detable = d_table;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulLongKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairCoulLong::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairCoulLongKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairCoulLong::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with buck/coul/long/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairCoulLongKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairCoulLong::init_one(i,j);
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
|
||||
}
|
||||
|
||||
|
||||
template class PairCoulLongKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairCoulLongKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,154 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(coul/long/kk,PairCoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(coul/long/kk/device,PairCoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(coul/long/kk/host,PairCoulLongKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_COUL_LONG_KOKKOS_H
|
||||
#define LMP_PAIR_COUL_LONG_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_coul_long.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairCoulLongKokkos : public PairCoulLong {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairCoulLongKokkos(class LAMMPS *);
|
||||
~PairCoulLongKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_tables(double cut_coul, double *cut_respa);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_coul{
|
||||
params_coul(){cut_coulsq=0;};
|
||||
params_coul(int i){cut_coulsq=0;};
|
||||
F_FLOAT cut_coulsq;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_lj[4], special_coul[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulLongKokkos,FULL,CoulLongTable<1> >(PairCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulLongKokkos,HALF,CoulLongTable<1> >(PairCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulLongKokkos,HALFTHREAD,CoulLongTable<1> >(PairCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairCoulLongKokkos,CoulLongTable<1> >(PairCoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairCoulLongKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulLongKokkos,FULL,CoulLongTable<0> >(PairCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulLongKokkos,HALF,CoulLongTable<0> >(PairCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairCoulLongKokkos,HALFTHREAD,CoulLongTable<0> >(PairCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairCoulLongKokkos,CoulLongTable<0> >(PairCoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairCoulLongKokkos>(PairCoulLongKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,513 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_charmm_coul_charmm_implicit_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
|
||||
#define EWALD_F 1.12837917
|
||||
#define EWALD_P 0.3275911
|
||||
#define A1 0.254829592
|
||||
#define A2 -0.284496736
|
||||
#define A3 1.421413741
|
||||
#define A4 -1.453152027
|
||||
#define A5 1.061405429
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::PairLJCharmmCoulCharmmImplicitKokkos(LAMMPS *lmp):PairLJCharmmCoulCharmmImplicit(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::~PairLJCharmmCoulCharmmImplicitKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_ljsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_coulsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
//memory->sfree(cut_ljsq);
|
||||
//memory->sfree(cut_coulsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
ftable = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev;
|
||||
if(ncoultablebits)
|
||||
ev = pair_compute<PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>,CoulLongTable<1> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
else
|
||||
ev = pair_compute<PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ CHARMM pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT forcelj, switch1, switch2, englj;
|
||||
|
||||
forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
switch1 = (cut_ljsq-rsq) * (cut_ljsq-rsq) *
|
||||
(cut_ljsq + 2.0*rsq - 3.0*cut_lj_innersq) / denom_lj;
|
||||
switch2 = 12.0*rsq * (cut_ljsq-rsq) * (rsq-cut_lj_innersq) / denom_lj;
|
||||
englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
forcelj = forcelj*switch1 + englj*switch2;
|
||||
}
|
||||
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ CHARMM pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT englj, switch1;
|
||||
|
||||
englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
switch1 = (cut_ljsq-rsq) * (cut_ljsq-rsq) *
|
||||
(cut_ljsq + 2.0*rsq - 3.0*cut_lj_innersq) / denom_lj;
|
||||
englj *= switch1;
|
||||
}
|
||||
|
||||
return englj;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
F_FLOAT forcecoul, switch1, switch2;
|
||||
|
||||
forcecoul = 2.0 * qqrd2e * qtmp*q(j) * r2inv;
|
||||
|
||||
if (rsq > cut_coul_innersq) {
|
||||
switch1 = (cut_coulsq-rsq) * (cut_coulsq-rsq) *
|
||||
(cut_coulsq + 2.0*rsq - 3.0*cut_coul_innersq) / denom_coul;
|
||||
switch2 = 12.0*rsq * (cut_coulsq-rsq) * (rsq-cut_coul_innersq) / denom_coul;
|
||||
forcecoul *= switch1 + 0.5*switch2;
|
||||
}
|
||||
|
||||
return forcecoul * r2inv * factor_coul;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
F_FLOAT ecoul, switch1;
|
||||
|
||||
ecoul = qqrd2e * qtmp * q(j) * r2inv;
|
||||
if (rsq > cut_coul_innersq) {
|
||||
switch1 = (cut_coulsq-rsq) * (cut_coulsq-rsq) *
|
||||
(cut_coulsq + 2.0*rsq - 3.0*cut_coul_innersq) /
|
||||
denom_coul;
|
||||
ecoul *= switch1;
|
||||
}
|
||||
|
||||
return ecoul * factor_coul;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJCharmmCoulCharmmImplicit::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
|
||||
//memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCharmmCoulCharmmImplicit::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::init_tables(double cut_coul, double *cut_respa)
|
||||
{
|
||||
Pair::init_tables(cut_coul,cut_respa);
|
||||
|
||||
typedef typename ArrayTypes<DeviceType>::t_ffloat_1d table_type;
|
||||
typedef typename ArrayTypes<LMPHostType>::t_ffloat_1d host_table_type;
|
||||
|
||||
int ntable = 1;
|
||||
for (int i = 0; i < ncoultablebits; i++) ntable *= 2;
|
||||
|
||||
|
||||
// Copy rtable and drtable
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = rtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_rtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = drtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_drtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ftable and dftable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ctable and dctable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy etable and detable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = etable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_etable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = detable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_detable = d_table;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJCharmmCoulCharmmImplicit::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJCharmmCoulCharmmImplicit::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/charmm/coul/charmm/implicit/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJCharmmCoulCharmmImplicit::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq;
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
//k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJCharmmCoulCharmmImplicitKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJCharmmCoulCharmmImplicitKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/charmm/coul/charmm/implicit/kk,PairLJCharmmCoulCharmmImplicitKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/charmm/coul/charmm/implicit/kk/device,PairLJCharmmCoulCharmmImplicitKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/charmm/coul/charmm/implicit/kk/host,PairLJCharmmCoulCharmmImplicitKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CHARMM_COUL_CHARMM_IMPLICIT_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CHARMM_COUL_CHARMM_IMPLICIT_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_charmm_coul_charmm_implicit.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJCharmmCoulCharmmImplicitKokkos : public PairLJCharmmCoulCharmmImplicit {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJCharmmCoulCharmmImplicitKokkos(class LAMMPS *);
|
||||
~PairLJCharmmCoulCharmmImplicitKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_tables(double cut_coul, double *cut_respa);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmImplicitKokkos,FULL,CoulLongTable<1> >(PairLJCharmmCoulCharmmImplicitKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmImplicitKokkos,HALF,CoulLongTable<1> >(PairLJCharmmCoulCharmmImplicitKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmImplicitKokkos,HALFTHREAD,CoulLongTable<1> >(PairLJCharmmCoulCharmmImplicitKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCharmmCoulCharmmImplicitKokkos,CoulLongTable<1> >(PairLJCharmmCoulCharmmImplicitKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmImplicitKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmImplicitKokkos,FULL,CoulLongTable<0> >(PairLJCharmmCoulCharmmImplicitKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmImplicitKokkos,HALF,CoulLongTable<0> >(PairLJCharmmCoulCharmmImplicitKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmImplicitKokkos,HALFTHREAD,CoulLongTable<0> >(PairLJCharmmCoulCharmmImplicitKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCharmmCoulCharmmImplicitKokkos,CoulLongTable<0> >(PairLJCharmmCoulCharmmImplicitKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJCharmmCoulCharmmImplicitKokkos>(PairLJCharmmCoulCharmmImplicitKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,515 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_charmm_coul_charmm_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
|
||||
#define EWALD_F 1.12837917
|
||||
#define EWALD_P 0.3275911
|
||||
#define A1 0.254829592
|
||||
#define A2 -0.284496736
|
||||
#define A3 1.421413741
|
||||
#define A4 -1.453152027
|
||||
#define A5 1.061405429
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCharmmCoulCharmmKokkos<DeviceType>::PairLJCharmmCoulCharmmKokkos(LAMMPS *lmp):PairLJCharmmCoulCharmm(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCharmmCoulCharmmKokkos<DeviceType>::~PairLJCharmmCoulCharmmKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_ljsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_coulsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
//memory->sfree(cut_ljsq);
|
||||
//memory->sfree(cut_coulsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
ftable = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev;
|
||||
if(ncoultablebits)
|
||||
ev = pair_compute<PairLJCharmmCoulCharmmKokkos<DeviceType>,CoulLongTable<1> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
else
|
||||
ev = pair_compute<PairLJCharmmCoulCharmmKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ CHARMM pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT forcelj, switch1, switch2, englj;
|
||||
|
||||
forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
switch1 = (cut_ljsq-rsq) * (cut_ljsq-rsq) *
|
||||
(cut_ljsq + 2.0*rsq - 3.0*cut_lj_innersq) / denom_lj;
|
||||
switch2 = 12.0*rsq * (cut_ljsq-rsq) * (rsq-cut_lj_innersq) / denom_lj;
|
||||
englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
forcelj = forcelj*switch1 + englj*switch2;
|
||||
}
|
||||
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ CHARMM pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT englj, switch1;
|
||||
|
||||
englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
switch1 = (cut_ljsq-rsq) * (cut_ljsq-rsq) *
|
||||
(cut_ljsq + 2.0*rsq - 3.0*cut_lj_innersq) / denom_lj;
|
||||
englj *= switch1;
|
||||
}
|
||||
|
||||
return englj;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
F_FLOAT forcecoul, switch1, switch2;
|
||||
|
||||
forcecoul = qqrd2e*qtmp*q(j) *rinv;
|
||||
|
||||
if (rsq > cut_coul_innersq) {
|
||||
switch1 = (cut_coulsq-rsq) * (cut_coulsq-rsq) *
|
||||
(cut_coulsq + 2.0*rsq - 3.0*cut_coul_innersq) / denom_coul;
|
||||
switch2 = 12.0*rsq * (cut_coulsq-rsq) * (rsq-cut_coul_innersq) / denom_coul;
|
||||
forcecoul *= switch1 + switch2;
|
||||
}
|
||||
|
||||
return forcecoul * r2inv * factor_coul;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulCharmmKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
F_FLOAT ecoul, switch1;
|
||||
|
||||
ecoul = qqrd2e * qtmp * q(j) * rinv;
|
||||
if (rsq > cut_coul_innersq) {
|
||||
switch1 = (cut_coulsq-rsq) * (cut_coulsq-rsq) *
|
||||
(cut_coulsq + 2.0*rsq - 3.0*cut_coul_innersq) /
|
||||
denom_coul;
|
||||
ecoul *= switch1;
|
||||
}
|
||||
|
||||
return ecoul * factor_coul;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJCharmmCoulCharmm::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
|
||||
//memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCharmmCoulCharmm::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmKokkos<DeviceType>::init_tables(double cut_coul, double *cut_respa)
|
||||
{
|
||||
Pair::init_tables(cut_coul,cut_respa);
|
||||
|
||||
typedef typename ArrayTypes<DeviceType>::t_ffloat_1d table_type;
|
||||
typedef typename ArrayTypes<LMPHostType>::t_ffloat_1d host_table_type;
|
||||
|
||||
int ntable = 1;
|
||||
for (int i = 0; i < ncoultablebits; i++) ntable *= 2;
|
||||
|
||||
|
||||
// Copy rtable and drtable
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = rtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_rtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = drtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_drtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ftable and dftable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ctable and dctable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy etable and detable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = etable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_etable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = detable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_detable = d_table;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJCharmmCoulCharmm::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulCharmmKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJCharmmCoulCharmm::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/charmm/coul/charmm/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJCharmmCoulCharmmKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJCharmmCoulCharmm::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq;
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
//k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJCharmmCoulCharmmKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJCharmmCoulCharmmKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/charmm/coul/charmm/kk,PairLJCharmmCoulCharmmKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/charmm/coul/charmm/kk/device,PairLJCharmmCoulCharmmKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/charmm/coul/charmm/kk/host,PairLJCharmmCoulCharmmKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CHARMM_COUL_CHARMM_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CHARMM_COUL_CHARMM_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_charmm_coul_charmm.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJCharmmCoulCharmmKokkos : public PairLJCharmmCoulCharmm {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJCharmmCoulCharmmKokkos(class LAMMPS *);
|
||||
~PairLJCharmmCoulCharmmKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_tables(double cut_coul, double *cut_respa);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmKokkos,FULL,CoulLongTable<1> >(PairLJCharmmCoulCharmmKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmKokkos,HALF,CoulLongTable<1> >(PairLJCharmmCoulCharmmKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmKokkos,HALFTHREAD,CoulLongTable<1> >(PairLJCharmmCoulCharmmKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCharmmCoulCharmmKokkos,CoulLongTable<1> >(PairLJCharmmCoulCharmmKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulCharmmKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmKokkos,FULL,CoulLongTable<0> >(PairLJCharmmCoulCharmmKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmKokkos,HALF,CoulLongTable<0> >(PairLJCharmmCoulCharmmKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulCharmmKokkos,HALFTHREAD,CoulLongTable<0> >(PairLJCharmmCoulCharmmKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCharmmCoulCharmmKokkos,CoulLongTable<0> >(PairLJCharmmCoulCharmmKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJCharmmCoulCharmmKokkos>(PairLJCharmmCoulCharmmKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,534 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_charmm_coul_long_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
|
||||
#define EWALD_F 1.12837917
|
||||
#define EWALD_P 0.3275911
|
||||
#define A1 0.254829592
|
||||
#define A2 -0.284496736
|
||||
#define A3 1.421413741
|
||||
#define A4 -1.453152027
|
||||
#define A5 1.061405429
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCharmmCoulLongKokkos<DeviceType>::PairLJCharmmCoulLongKokkos(LAMMPS *lmp):PairLJCharmmCoulLong(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCharmmCoulLongKokkos<DeviceType>::~PairLJCharmmCoulLongKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_ljsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_coulsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
//memory->sfree(cut_ljsq);
|
||||
//memory->sfree(cut_coulsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulLongKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
ftable = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev;
|
||||
if(ncoultablebits)
|
||||
ev = pair_compute<PairLJCharmmCoulLongKokkos<DeviceType>,CoulLongTable<1> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
else
|
||||
ev = pair_compute<PairLJCharmmCoulLongKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ CHARMM pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulLongKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT forcelj, switch1, switch2, englj;
|
||||
|
||||
forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
switch1 = (cut_ljsq-rsq) * (cut_ljsq-rsq) *
|
||||
(cut_ljsq + 2.0*rsq - 3.0*cut_lj_innersq) / denom_lj;
|
||||
switch2 = 12.0*rsq * (cut_ljsq-rsq) * (rsq-cut_lj_innersq) / denom_lj;
|
||||
englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
forcelj = forcelj*switch1 + englj*switch2;
|
||||
}
|
||||
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ CHARMM pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulLongKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT englj, switch1;
|
||||
|
||||
englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
switch1 = (cut_ljsq-rsq) * (cut_ljsq-rsq) *
|
||||
(cut_ljsq + 2.0*rsq - 3.0*cut_lj_innersq) / denom_lj;
|
||||
englj *= switch1;
|
||||
}
|
||||
|
||||
return englj;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulLongKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable && rsq > tabinnersq) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_ftable[itable] + fraction*d_dftable[itable];
|
||||
F_FLOAT forcecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return forcecoul/rsq;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT rinv = 1.0/r;
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]*rinv;
|
||||
F_FLOAT forcecoul = prefactor * (erfc + EWALD_F*grij*expm2);
|
||||
if (factor_coul < 1.0) forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
|
||||
return forcecoul*rinv*rinv;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCharmmCoulLongKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_etable[itable] + fraction*d_detable[itable];
|
||||
F_FLOAT ecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
ecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return ecoul;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]/r;
|
||||
F_FLOAT ecoul = prefactor * erfc;
|
||||
if (factor_coul < 1.0) ecoul -= (1.0-factor_coul)*prefactor;
|
||||
return ecoul;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulLongKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJCharmmCoulLong::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
|
||||
//memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCharmmCoulLong::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulLongKokkos<DeviceType>::init_tables(double cut_coul, double *cut_respa)
|
||||
{
|
||||
Pair::init_tables(cut_coul,cut_respa);
|
||||
|
||||
typedef typename ArrayTypes<DeviceType>::t_ffloat_1d table_type;
|
||||
typedef typename ArrayTypes<LMPHostType>::t_ffloat_1d host_table_type;
|
||||
|
||||
int ntable = 1;
|
||||
for (int i = 0; i < ncoultablebits; i++) ntable *= 2;
|
||||
|
||||
|
||||
// Copy rtable and drtable
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = rtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_rtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = drtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_drtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ftable and dftable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ctable and dctable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy etable and detable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = etable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_etable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = detable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_detable = d_table;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulLongKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJCharmmCoulLong::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCharmmCoulLongKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJCharmmCoulLong::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/charmm/coul/long/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJCharmmCoulLongKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJCharmmCoulLong::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq;
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
//k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJCharmmCoulLongKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJCharmmCoulLongKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/charmm/coul/long/kk,PairLJCharmmCoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/charmm/coul/long/kk/device,PairLJCharmmCoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/charmm/coul/long/kk/host,PairLJCharmmCoulLongKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CHARMM_COUL_LONG_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CHARMM_COUL_LONG_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_charmm_coul_long.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJCharmmCoulLongKokkos : public PairLJCharmmCoulLong {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJCharmmCoulLongKokkos(class LAMMPS *);
|
||||
~PairLJCharmmCoulLongKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_tables(double cut_coul, double *cut_respa);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulLongKokkos,FULL,CoulLongTable<1> >(PairLJCharmmCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulLongKokkos,HALF,CoulLongTable<1> >(PairLJCharmmCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulLongKokkos,HALFTHREAD,CoulLongTable<1> >(PairLJCharmmCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCharmmCoulLongKokkos,CoulLongTable<1> >(PairLJCharmmCoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJCharmmCoulLongKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulLongKokkos,FULL,CoulLongTable<0> >(PairLJCharmmCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulLongKokkos,HALF,CoulLongTable<0> >(PairLJCharmmCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCharmmCoulLongKokkos,HALFTHREAD,CoulLongTable<0> >(PairLJCharmmCoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCharmmCoulLongKokkos,CoulLongTable<0> >(PairLJCharmmCoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJCharmmCoulLongKokkos>(PairLJCharmmCoulLongKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,354 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_class2_coul_cut_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJClass2CoulCutKokkos<DeviceType>::PairLJClass2CoulCutKokkos(LAMMPS *lmp):PairLJClass2CoulCut(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = NULL;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJClass2CoulCutKokkos<DeviceType>::~PairLJClass2CoulCutKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_cutsq, cutsq);
|
||||
memory->destroy_kokkos(k_cut_ljsq, cut_ljsq);
|
||||
memory->destroy_kokkos(k_cut_coulsq, cut_coulsq);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulCutKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev = pair_compute<PairLJClass2CoulCutKokkos<DeviceType>,void >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) virial_fdotr_compute();
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulCutKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
(void) i;
|
||||
(void) j;
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r3inv = r2inv*rinv;
|
||||
const F_FLOAT r6inv = r3inv*r3inv;
|
||||
|
||||
const F_FLOAT forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r3inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulCutKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
F_FLOAT forcecoul;
|
||||
|
||||
forcecoul = qqrd2e*qtmp*q(j) *rinv;
|
||||
|
||||
return factor_coul*forcecoul*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulCutKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
(void) i;
|
||||
(void) j;
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r3inv = r2inv*rinv;
|
||||
const F_FLOAT r6inv = r3inv*r3inv;
|
||||
|
||||
return r6inv*((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r3inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4)) -
|
||||
(STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulCutKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
|
||||
return factor_coul*qqrd2e*qtmp*q(j)*rinv;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulCutKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJClass2CoulCut::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
memory->destroy(cut_coulsq);
|
||||
memory->create_kokkos(k_cut_coulsq,cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJClass2CoulCut::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulCutKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJClass2CoulCut::settings(1,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulCutKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJClass2CoulCut::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == N2) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == FULLCLUSTER) {
|
||||
neighbor->requests[irequest]->full_cluster = 1;
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/class2/coul/cut/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJClass2CoulCutKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJClass2CoulCut::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq[i][j];
|
||||
double cut_coulsqm = cut_coulsq[i][j];
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJClass2CoulCutKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJClass2CoulCutKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/class2/coul/cut/kk,PairLJClass2CoulCutKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/class2/coul/cut/kk/device,PairLJClass2CoulCutKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/class2/coul/cut/kk/host,PairLJClass2CoulCutKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CLASS2_COUL_CUT_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CLASS2_COUL_CUT_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_class2_coul_cut.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJClass2CoulCutKokkos : public PairLJClass2CoulCut {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJClass2CoulCutKokkos(class LAMMPS *);
|
||||
~PairLJClass2CoulCutKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
friend class PairComputeFunctor<PairLJClass2CoulCutKokkos,FULL,true>;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulCutKokkos,HALF,true>;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulCutKokkos,HALFTHREAD,true>;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulCutKokkos,FULL,false>;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulCutKokkos,HALF,false>;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulCutKokkos,HALFTHREAD,false>;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulCutKokkos,FULL,void>(PairLJClass2CoulCutKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulCutKokkos,HALF,void>(PairLJClass2CoulCutKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulCutKokkos,HALFTHREAD,void>(PairLJClass2CoulCutKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJClass2CoulCutKokkos,void>(PairLJClass2CoulCutKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,503 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_class2_coul_long_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
|
||||
#define EWALD_F 1.12837917
|
||||
#define EWALD_P 0.3275911
|
||||
#define A1 0.254829592
|
||||
#define A2 -0.284496736
|
||||
#define A3 1.421413741
|
||||
#define A4 -1.453152027
|
||||
#define A5 1.061405429
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJClass2CoulLongKokkos<DeviceType>::PairLJClass2CoulLongKokkos(LAMMPS *lmp):PairLJClass2CoulLong(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = 0.0;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJClass2CoulLongKokkos<DeviceType>::~PairLJClass2CoulLongKokkos()
|
||||
{
|
||||
if (!copymode){
|
||||
memory->destroy_kokkos(k_cutsq, cutsq);
|
||||
memory->destroy_kokkos(k_cut_ljsq, cut_ljsq);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulLongKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
ftable = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev;
|
||||
if(ncoultablebits)
|
||||
ev = pair_compute<PairLJClass2CoulLongKokkos<DeviceType>,CoulLongTable<1> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
else
|
||||
ev = pair_compute<PairLJClass2CoulLongKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulLongKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
(void) i;
|
||||
(void) j;
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r3inv = r2inv*rinv;
|
||||
const F_FLOAT r6inv = r3inv*r3inv;
|
||||
|
||||
const F_FLOAT forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r3inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulLongKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable && rsq > tabinnersq) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_ftable[itable] + fraction*d_dftable[itable];
|
||||
F_FLOAT forcecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return forcecoul/rsq;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT rinv = 1.0/r;
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]*rinv;
|
||||
F_FLOAT forcecoul = prefactor * (erfc + EWALD_F*grij*expm2);
|
||||
if (factor_coul < 1.0) forcecoul -= (1.0-factor_coul)*prefactor;
|
||||
|
||||
return forcecoul*rinv*rinv;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulLongKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
(void) i;
|
||||
(void) j;
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r3inv = r2inv*rinv;
|
||||
const F_FLOAT r6inv = r3inv*r3inv;
|
||||
|
||||
return r6inv*((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r3inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4)) -
|
||||
(STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2CoulLongKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
if(Specialisation::DoTable) {
|
||||
union_int_float_t rsq_lookup;
|
||||
rsq_lookup.f = rsq;
|
||||
const int itable = (rsq_lookup.i & ncoulmask) >> ncoulshiftbits;
|
||||
const F_FLOAT fraction = (rsq_lookup.f - d_rtable[itable]) * d_drtable[itable];
|
||||
const F_FLOAT table = d_etable[itable] + fraction*d_detable[itable];
|
||||
F_FLOAT ecoul = qtmp*q[j] * table;
|
||||
if (factor_coul < 1.0) {
|
||||
const F_FLOAT table = d_ctable[itable] + fraction*d_dctable[itable];
|
||||
const F_FLOAT prefactor = qtmp*q[j] * table;
|
||||
ecoul -= (1.0-factor_coul)*prefactor;
|
||||
}
|
||||
return ecoul;
|
||||
} else {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT grij = g_ewald * r;
|
||||
const F_FLOAT expm2 = exp(-grij*grij);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*grij);
|
||||
const F_FLOAT erfc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * expm2;
|
||||
const F_FLOAT prefactor = qqrd2e * qtmp*q[j]/r;
|
||||
F_FLOAT ecoul = prefactor * erfc;
|
||||
if (factor_coul < 1.0) ecoul -= (1.0-factor_coul)*prefactor;
|
||||
return ecoul;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulLongKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJClass2CoulLong::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJClass2CoulLong::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulLongKokkos<DeviceType>::init_tables(double cut_coul, double *cut_respa)
|
||||
{
|
||||
Pair::init_tables(cut_coul,cut_respa);
|
||||
|
||||
typedef typename ArrayTypes<DeviceType>::t_ffloat_1d table_type;
|
||||
typedef typename ArrayTypes<LMPHostType>::t_ffloat_1d host_table_type;
|
||||
|
||||
int ntable = 1;
|
||||
for (int i = 0; i < ncoultablebits; i++) ntable *= 2;
|
||||
|
||||
|
||||
// Copy rtable and drtable
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = rtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_rtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = drtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_drtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ftable and dftable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ctable and dctable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy etable and detable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = etable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_etable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = detable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_detable = d_table;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulLongKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJClass2CoulLong::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2CoulLongKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJClass2CoulLong::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/class2/coul/long/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJClass2CoulLongKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJClass2CoulLong::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq[i][j];
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJClass2CoulLongKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJClass2CoulLongKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/class2/coul/long/kk,PairLJClass2CoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/class2/coul/long/kk/device,PairLJClass2CoulLongKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/class2/coul/long/kk/host,PairLJClass2CoulLongKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CLASS2_COUL_LONG_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CLASS2_COUL_LONG_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_class2_coul_long.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJClass2CoulLongKokkos : public PairLJClass2CoulLong {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJClass2CoulLongKokkos(class LAMMPS *);
|
||||
~PairLJClass2CoulLongKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_tables(double cut_coul, double *cut_respa);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulLongKokkos,FULL,CoulLongTable<1> >(PairLJClass2CoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulLongKokkos,HALF,CoulLongTable<1> >(PairLJClass2CoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulLongKokkos,HALFTHREAD,CoulLongTable<1> >(PairLJClass2CoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJClass2CoulLongKokkos,CoulLongTable<1> >(PairLJClass2CoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJClass2CoulLongKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulLongKokkos,FULL,CoulLongTable<0> >(PairLJClass2CoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulLongKokkos,HALF,CoulLongTable<0> >(PairLJClass2CoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2CoulLongKokkos,HALFTHREAD,CoulLongTable<0> >(PairLJClass2CoulLongKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJClass2CoulLongKokkos,CoulLongTable<0> >(PairLJClass2CoulLongKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJClass2CoulLongKokkos>(PairLJClass2CoulLongKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,281 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_class2_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJClass2Kokkos<DeviceType>::PairLJClass2Kokkos(LAMMPS *lmp) : PairLJClass2(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJClass2Kokkos<DeviceType>::~PairLJClass2Kokkos()
|
||||
{
|
||||
if (allocated) {
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
cutsq = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2Kokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
tag = atomKK->k_tag.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
newton_pair = force->newton_pair;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
EV_FLOAT ev = pair_compute<PairLJClass2Kokkos<DeviceType>,void >(this,(NeighListKokkos<DeviceType>*)list);
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) eng_vdwl += ev.evdwl;
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2Kokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
(void) i;
|
||||
(void) j;
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r3inv = r2inv*rinv;
|
||||
const F_FLOAT r6inv = r3inv*r3inv;
|
||||
|
||||
const F_FLOAT forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r3inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
return forcelj*r2inv;
|
||||
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJClass2Kokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
(void) i;
|
||||
(void) j;
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r3inv = r2inv*rinv;
|
||||
const F_FLOAT r6inv = r3inv*r3inv;
|
||||
|
||||
return r6inv*((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r3inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4)) -
|
||||
(STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2Kokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJClass2::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType>("PairLJClass2::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2Kokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJClass2::settings(1,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJClass2Kokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJClass2::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == N2) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == FULLCLUSTER) {
|
||||
neighbor->requests[irequest]->full_cluster = 1;
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/class2/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJClass2Kokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJClass2::init_one(i,j);
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cutsq = cutone*cutone;
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
}
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJClass2Kokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJClass2Kokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/class2/kk,PairLJClass2Kokkos<LMPDeviceType>)
|
||||
PairStyle(lj/class2/kk/device,PairLJClass2Kokkos<LMPDeviceType>)
|
||||
PairStyle(lj/class2/kk/host,PairLJClass2Kokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CLASS2_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CLASS2_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_class2.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJClass2Kokkos : public PairLJClass2 {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF|N2|FULLCLUSTER};
|
||||
enum {COUL_FLAG=0};
|
||||
typedef DeviceType device_type;
|
||||
PairLJClass2Kokkos(class LAMMPS *);
|
||||
~PairLJClass2Kokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj{
|
||||
params_lj(){cutsq=0,lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj(int i){cutsq=0,lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cutsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
params_lj m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1]; // hardwired to space for 15 atom types
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_tagint_1d tag;
|
||||
|
||||
int newton_pair;
|
||||
double special_lj[4];
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
void allocate();
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,FULL,true>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,HALF,true>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,HALFTHREAD,true>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,N2,true>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,FULLCLUSTER,true >;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,FULL,false>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,HALF,false>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,HALFTHREAD,false>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,N2,false>;
|
||||
friend class PairComputeFunctor<PairLJClass2Kokkos,FULLCLUSTER,false >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2Kokkos,FULL,void>(PairLJClass2Kokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2Kokkos,HALF,void>(PairLJClass2Kokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2Kokkos,HALFTHREAD,void>(PairLJClass2Kokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJClass2Kokkos,N2,void>(PairLJClass2Kokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_fullcluster<PairLJClass2Kokkos,void>(PairLJClass2Kokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJClass2Kokkos,void>(PairLJClass2Kokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJClass2Kokkos>(PairLJClass2Kokkos*);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,375 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_cut_coul_debye_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCutCoulDebyeKokkos<DeviceType>::PairLJCutCoulDebyeKokkos(LAMMPS *lmp):PairLJCutCoulDebye(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = NULL;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCutCoulDebyeKokkos<DeviceType>::~PairLJCutCoulDebyeKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_cutsq, cutsq);
|
||||
memory->destroy_kokkos(k_cut_ljsq, cut_ljsq);
|
||||
memory->destroy_kokkos(k_cut_coulsq, cut_coulsq);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDebyeKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
cut_coulsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDebyeKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev = pair_compute<PairLJCutCoulDebyeKokkos<DeviceType>,void >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) virial_fdotr_compute();
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDebyeKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT forcelj;
|
||||
|
||||
forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDebyeKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r = 1.0/rinv;
|
||||
const F_FLOAT screening = exp(-kappa*r);
|
||||
F_FLOAT forcecoul;
|
||||
|
||||
forcecoul = qqrd2e * qtmp * q(j) * screening * (kappa + rinv);
|
||||
|
||||
return factor_coul*forcecoul*r2inv;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDebyeKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
|
||||
return r6inv*
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv
|
||||
- (STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4))
|
||||
- (STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDebyeKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
const F_FLOAT r = 1.0/rinv;
|
||||
const F_FLOAT screening = exp(-kappa*r);
|
||||
|
||||
return factor_coul * qqrd2e * qtmp * q(j) * rinv * screening;
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDebyeKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJCutCoulDebye::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
memory->destroy(cut_coulsq);
|
||||
memory->create_kokkos(k_cut_coulsq,cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCutCoulDebye::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDebyeKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg < 2 || narg > 3) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
kappa = force->numeric(FLERR,arg[0]);
|
||||
cut_lj_global = force->numeric(FLERR,arg[1]);
|
||||
if (narg == 2) cut_coul_global = cut_lj_global;
|
||||
else cut_coul_global = force->numeric(FLERR,arg[2]);
|
||||
|
||||
// reset cutoffs that were previously set from data file
|
||||
|
||||
if (allocated) {
|
||||
int i,j;
|
||||
for (i = 1; i <= atom->ntypes; i++)
|
||||
for (j = i+1; j <= atom->ntypes; j++)
|
||||
if (setflag[i][j] == 1) {
|
||||
cut_lj[i][j] = cut_lj_global;
|
||||
cut_coul[i][j] = cut_coul_global;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDebyeKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJCutCoulDebye::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == N2) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == FULLCLUSTER) {
|
||||
neighbor->requests[irequest]->full_cluster = 1;
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/cut/coul/debye/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJCutCoulDebyeKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJCutCoulDebye::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq[i][j];
|
||||
double cut_coulsqm = cut_coulsq[i][j];
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJCutCoulDebyeKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJCutCoulDebyeKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/cut/coul/debye/kk,PairLJCutCoulDebyeKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/cut/coul/debye/kk/device,PairLJCutCoulDebyeKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/cut/coul/debye/kk/host,PairLJCutCoulDebyeKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CUT_COUL_DEBYE_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CUT_COUL_DEBYE_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_cut_coul_debye.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJCutCoulDebyeKokkos : public PairLJCutCoulDebye {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJCutCoulDebyeKokkos(class LAMMPS *);
|
||||
~PairLJCutCoulDebyeKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
friend class PairComputeFunctor<PairLJCutCoulDebyeKokkos,FULL,true>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDebyeKokkos,HALF,true>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDebyeKokkos,HALFTHREAD,true>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDebyeKokkos,FULL,false>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDebyeKokkos,HALF,false>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDebyeKokkos,HALFTHREAD,false>;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCutCoulDebyeKokkos,FULL,void>(PairLJCutCoulDebyeKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCutCoulDebyeKokkos,HALF,void>(PairLJCutCoulDebyeKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCutCoulDebyeKokkos,HALFTHREAD,void>(PairLJCutCoulDebyeKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCutCoulDebyeKokkos,void>(PairLJCutCoulDebyeKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,366 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_cut_coul_dsf_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
#define EWALD_F 1.12837917
|
||||
#define EWALD_P 0.3275911
|
||||
#define A1 0.254829592
|
||||
#define A2 -0.284496736
|
||||
#define A3 1.421413741
|
||||
#define A4 -1.453152027
|
||||
#define A5 1.061405429
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCutCoulDSFKokkos<DeviceType>::PairLJCutCoulDSFKokkos(LAMMPS *lmp):PairLJCutCoulDSF(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
//cut_coulsq = NULL;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJCutCoulDSFKokkos<DeviceType>::~PairLJCutCoulDSFKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_cutsq, cutsq);
|
||||
memory->destroy_kokkos(k_cut_ljsq, cut_ljsq);
|
||||
//memory->destroy_kokkos(k_cut_coulsq, cut_coulsq);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDSFKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = NULL;
|
||||
//cut_coulsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDSFKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
EV_FLOAT ev;
|
||||
|
||||
copymode = 1;
|
||||
|
||||
int inum = list->inum;
|
||||
|
||||
for (int ii = 0; ii < inum; ii ++) {
|
||||
//int i = list->ilist[ii];
|
||||
double qtmp = atom->q[ii];
|
||||
eng_coul += -(e_shift/2.0 + alpha/MY_PIS) * qtmp*qtmp*qqrd2e;
|
||||
}
|
||||
|
||||
ev = pair_compute<PairLJCutCoulDSFKokkos<DeviceType>,void >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) virial_fdotr_compute();
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDSFKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT forcelj;
|
||||
|
||||
forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ 12-6 pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDSFKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
|
||||
return r6inv*
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv
|
||||
- (STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4))
|
||||
- (STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDSFKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT prefactor = factor_coul * qqrd2e * qtmp * q(j);
|
||||
const F_FLOAT erfcd = exp(-alpha*alpha*rsq);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*alpha*r);
|
||||
const F_FLOAT erfcc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * erfcd;
|
||||
|
||||
return prefactor * (erfcc/r + 2.0*alpha/MY_PIS * erfcd + r*f_shift) *
|
||||
r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJCutCoulDSFKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT prefactor = factor_coul * qqrd2e * qtmp * q(j);
|
||||
const F_FLOAT erfcd = exp(-alpha*alpha*rsq);
|
||||
const F_FLOAT t = 1.0 / (1.0 + EWALD_P*alpha*r);
|
||||
const F_FLOAT erfcc = t * (A1+t*(A2+t*(A3+t*(A4+t*A5)))) * erfcd;
|
||||
|
||||
return prefactor * (erfcc - r*e_shift - rsq*f_shift) / r;
|
||||
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDSFKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJCutCoulDSF::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
//memory->destroy(cut_coulsq);
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJCutCoulDSF::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJCutCoulDSFKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJCutCoulDSF::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == N2) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == FULLCLUSTER) {
|
||||
neighbor->requests[irequest]->full_cluster = 1;
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/cut/coul/cut/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJCutCoulDSFKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJCutCoulDSF::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq[i][j];
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJCutCoulDSFKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJCutCoulDSFKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/cut/coul/dsf/kk,PairLJCutCoulDSFKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/cut/coul/dsf/kk/device,PairLJCutCoulDSFKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/cut/coul/dsf/kk/host,PairLJCutCoulDSFKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_CUT_COUL_DSF_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_CUT_COUL_DSF_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_cut_coul_dsf.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJCutCoulDSFKokkos : public PairLJCutCoulDSF {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJCutCoulDSFKokkos(class LAMMPS *);
|
||||
~PairLJCutCoulDSFKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
friend class PairComputeFunctor<PairLJCutCoulDSFKokkos,FULL,true>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDSFKokkos,HALF,true>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDSFKokkos,HALFTHREAD,true>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDSFKokkos,FULL,false>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDSFKokkos,HALF,false>;
|
||||
friend class PairComputeFunctor<PairLJCutCoulDSFKokkos,HALFTHREAD,false>;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCutCoulDSFKokkos,FULL,void>(PairLJCutCoulDSFKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCutCoulDSFKokkos,HALF,void>(PairLJCutCoulDSFKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJCutCoulDSFKokkos,HALFTHREAD,void>(PairLJCutCoulDSFKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJCutCoulDSFKokkos,void>(PairLJCutCoulDSFKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,285 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_expand_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJExpandKokkos<DeviceType>::PairLJExpandKokkos(LAMMPS *lmp) : PairLJExpand(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJExpandKokkos<DeviceType>::~PairLJExpandKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
cutsq = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJExpandKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJExpandKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
tag = atomKK->k_tag.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
newton_pair = force->newton_pair;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev = pair_compute<PairLJExpandKokkos<DeviceType>,void >(this,(NeighListKokkos<DeviceType>*)list);
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) eng_vdwl += ev.evdwl;
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJExpandKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT rshift = r - (STACKPARAMS?m_params[itype][jtype].shift:params(itype,jtype).shift);
|
||||
const F_FLOAT rshiftsq = rshift*rshift;
|
||||
const F_FLOAT r2inv = 1.0/rshiftsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
|
||||
const F_FLOAT forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
return forcelj/rshift/r;
|
||||
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJExpandKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT rshift = r - (STACKPARAMS?m_params[itype][jtype].shift:params(itype,jtype).shift);
|
||||
const F_FLOAT rshiftsq = rshift*rshift;
|
||||
const F_FLOAT r2inv = 1.0/rshiftsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
|
||||
return r6inv*((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4)) -
|
||||
(STACKPARAMS?m_params[itype][jtype].offset:params(itype,jtype).offset);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJExpandKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJExpand::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
k_params = Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType>("PairLJExpand::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJExpandKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg != 1) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJExpand::settings(1,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJExpandKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJExpand::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == N2) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == FULLCLUSTER) {
|
||||
neighbor->requests[irequest]->full_cluster = 1;
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/expand/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJExpandKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJExpand::init_one(i,j);
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).offset = offset[i][j];
|
||||
k_params.h_view(i,j).shift = shift[i][j];
|
||||
k_params.h_view(i,j).cutsq = cutone*cutone;
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
}
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJExpandKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJExpandKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,125 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/expand/kk,PairLJExpandKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/expand/kk/device,PairLJExpandKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/expand/kk/host,PairLJExpandKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_EXPAND_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_EXPAND_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_expand.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJExpandKokkos : public PairLJExpand {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF|N2|FULLCLUSTER};
|
||||
enum {COUL_FLAG=0};
|
||||
typedef DeviceType device_type;
|
||||
PairLJExpandKokkos(class LAMMPS *);
|
||||
~PairLJExpandKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj{
|
||||
params_lj(){cutsq=0,lj1=0;lj2=0;lj3=0;lj4=0;offset=0;shift=0;};
|
||||
params_lj(int i){cutsq=0,lj1=0;lj2=0;lj3=0;lj4=0;offset=0;shift=0;};
|
||||
F_FLOAT cutsq,lj1,lj2,lj3,lj4,offset,shift;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype, const int& jtype) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
params_lj m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1]; // hardwired to space for 15 atom types
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_tagint_1d tag;
|
||||
|
||||
int newton_pair;
|
||||
double special_lj[4];
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
void allocate();
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,FULL,true>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,HALF,true>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,HALFTHREAD,true>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,N2,true>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,FULLCLUSTER,true >;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,FULL,false>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,HALF,false>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,HALFTHREAD,false>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,N2,false>;
|
||||
friend class PairComputeFunctor<PairLJExpandKokkos,FULLCLUSTER,false >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJExpandKokkos,FULL,void>(PairLJExpandKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJExpandKokkos,HALF,void>(PairLJExpandKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJExpandKokkos,HALFTHREAD,void>(PairLJExpandKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJExpandKokkos,N2,void>(PairLJExpandKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_fullcluster<PairLJExpandKokkos,void>(PairLJExpandKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJExpandKokkos,void>(PairLJExpandKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJExpandKokkos>(PairLJExpandKokkos*);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,501 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_gromacs_coul_gromacs_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJGromacsCoulGromacsKokkos<DeviceType>::PairLJGromacsCoulGromacsKokkos(LAMMPS *lmp):PairLJGromacsCoulGromacs(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJGromacsCoulGromacsKokkos<DeviceType>::~PairLJGromacsCoulGromacsKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_ljsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_coulsq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
//memory->sfree(cut_ljsq);
|
||||
//memory->sfree(cut_coulsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
cut_coulsq = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsCoulGromacsKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_ljsq = 0.0;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
ftable = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsCoulGromacsKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_ljsq.template sync<DeviceType>();
|
||||
k_cut_coulsq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
special_coul[0] = force->special_coul[0];
|
||||
special_coul[1] = force->special_coul[1];
|
||||
special_coul[2] = force->special_coul[2];
|
||||
special_coul[3] = force->special_coul[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev;
|
||||
if(ncoultablebits)
|
||||
ev = pair_compute<PairLJGromacsCoulGromacsKokkos<DeviceType>,CoulLongTable<1> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
else
|
||||
ev = pair_compute<PairLJGromacsCoulGromacsKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += ev.ecoul;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ GROMACS pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJGromacsCoulGromacsKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT tlj = r - cut_lj_inner;
|
||||
const F_FLOAT fswitch = r*tlj*tlj*
|
||||
((STACKPARAMS?m_params[itype][jtype].ljsw1:params(itype,jtype).ljsw1) +
|
||||
(STACKPARAMS?m_params[itype][jtype].ljsw2:params(itype,jtype).ljsw2)*tlj);
|
||||
forcelj += fswitch;
|
||||
}
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ GROMACS pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJGromacsCoulGromacsKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
englj += (STACKPARAMS?m_params[itype][jtype].ljsw5:params(itype,jtype).ljsw5);
|
||||
|
||||
if (rsq > cut_lj_innersq) {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT tlj = r - cut_lj_inner;
|
||||
const F_FLOAT eswitch = tlj*tlj*tlj *
|
||||
((STACKPARAMS?m_params[itype][jtype].ljsw3:params(itype,jtype).ljsw3) +
|
||||
(STACKPARAMS?m_params[itype][jtype].ljsw4:params(itype,jtype).ljsw4)*tlj);
|
||||
englj += eswitch;
|
||||
}
|
||||
return englj;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJGromacsCoulGromacsKokkos<DeviceType>::
|
||||
compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
F_FLOAT forcecoul = qqrd2e*qtmp*q(j) *rinv;
|
||||
|
||||
if (rsq > cut_coul_innersq) {
|
||||
const F_FLOAT r = 1.0/rinv;
|
||||
const F_FLOAT tc = r - cut_coul_inner;
|
||||
const F_FLOAT fcoulswitch = qqrd2e * qtmp*q(j)*r*tc*tc*(coulsw1 + coulsw2*tc);
|
||||
forcecoul += fcoulswitch;
|
||||
}
|
||||
return forcecoul * r2inv * factor_coul;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute coulomb pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJGromacsCoulGromacsKokkos<DeviceType>::
|
||||
compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT rinv = sqrt(r2inv);
|
||||
F_FLOAT ecoul = qqrd2e * qtmp * q(j) * (rinv-coulsw5);
|
||||
|
||||
if (rsq > cut_coul_innersq) {
|
||||
const F_FLOAT r = 1.0/rinv;
|
||||
const F_FLOAT tc = r - cut_coul_inner;
|
||||
const F_FLOAT ecoulswitch = tc*tc*tc * (coulsw3 + coulsw4*tc);
|
||||
ecoul += qqrd2e*qtmp*q(j)*ecoulswitch;
|
||||
}
|
||||
return ecoul * factor_coul;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsCoulGromacsKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJGromacsCoulGromacs::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
|
||||
//memory->destroy(cut_ljsq);
|
||||
memory->create_kokkos(k_cut_ljsq,n+1,n+1,"pair:cut_ljsq");
|
||||
d_cut_ljsq = k_cut_ljsq.template view<DeviceType>();
|
||||
|
||||
memory->create_kokkos(k_cut_coulsq,n+1,n+1,"pair:cut_coulsq");
|
||||
d_cut_coulsq = k_cut_coulsq.template view<DeviceType>();
|
||||
|
||||
k_params = Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType>("PairLJGromacsCoulGromacs::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsCoulGromacsKokkos<DeviceType>::init_tables(double cut_coul, double *cut_respa)
|
||||
{
|
||||
Pair::init_tables(cut_coul,cut_respa);
|
||||
|
||||
typedef typename ArrayTypes<DeviceType>::t_ffloat_1d table_type;
|
||||
typedef typename ArrayTypes<LMPHostType>::t_ffloat_1d host_table_type;
|
||||
|
||||
int ntable = 1;
|
||||
for (int i = 0; i < ncoultablebits; i++) ntable *= 2;
|
||||
|
||||
|
||||
// Copy rtable and drtable
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = rtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_rtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = drtable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_drtable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ftable and dftable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dftable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dftable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy ctable and dctable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = ctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_ctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = dctable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_dctable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
// Copy etable and detable
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = etable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_etable = d_table;
|
||||
}
|
||||
|
||||
{
|
||||
host_table_type h_table("HostTable",ntable);
|
||||
table_type d_table("DeviceTable",ntable);
|
||||
|
||||
for(int i = 0; i < ntable; i++) {
|
||||
h_table(i) = detable[i];
|
||||
}
|
||||
Kokkos::deep_copy(d_table,h_table);
|
||||
d_detable = d_table;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsCoulGromacsKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg > 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJGromacsCoulGromacs::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsCoulGromacsKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJGromacsCoulGromacs::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/gromacs/coul/gromacs/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJGromacsCoulGromacsKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJGromacsCoulGromacs::init_one(i,j);
|
||||
double cut_ljsqm = cut_ljsq;
|
||||
double cut_coulsqm = cut_coulsq;
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).ljsw1 = ljsw1[i][j];
|
||||
k_params.h_view(i,j).ljsw2 = ljsw2[i][j];
|
||||
k_params.h_view(i,j).ljsw3 = ljsw3[i][j];
|
||||
k_params.h_view(i,j).ljsw4 = ljsw4[i][j];
|
||||
k_params.h_view(i,j).ljsw5 = ljsw5[i][j];
|
||||
k_params.h_view(i,j).cut_ljsq = cut_ljsqm;
|
||||
k_params.h_view(i,j).cut_coulsq = cut_coulsqm;
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_ljsq[j][i] = m_cut_ljsq[i][j] = cut_ljsqm;
|
||||
m_cut_coulsq[j][i] = m_cut_coulsq[i][j] = cut_coulsqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_ljsq.h_view(i,j) = cut_ljsqm;
|
||||
k_cut_ljsq.template modify<LMPHostType>();
|
||||
k_cut_coulsq.h_view(i,j) = cut_coulsqm;
|
||||
k_cut_coulsq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template class PairLJGromacsCoulGromacsKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJGromacsCoulGromacsKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/gromacs/coul/gromacs/kk,PairLJGromacsCoulGromacsKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/gromacs/coul/gromacs/kk/device,PairLJGromacsCoulGromacsKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/gromacs/coul/gromacs/kk/host,PairLJGromacsCoulGromacsKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_GROMACS_COUL_GROMACS_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_GROMACS_COUL_GROMACS_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_gromacs_coul_gromacs.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJGromacsCoulGromacsKokkos : public PairLJGromacsCoulGromacs {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=1};
|
||||
typedef DeviceType device_type;
|
||||
PairLJGromacsCoulGromacsKokkos(class LAMMPS *);
|
||||
~PairLJGromacsCoulGromacsKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_tables(double cut_coul, double *cut_respa);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj_coul{
|
||||
params_lj_coul(){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;ljsw1=0;ljsw2=0;ljsw3=0;ljsw4=0;ljsw5=0;};
|
||||
params_lj_coul(int i){cut_ljsq=0;cut_coulsq=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;ljsw1=0;ljsw2=0;ljsw3=0;ljsw4=0;ljsw5=0;};
|
||||
F_FLOAT cut_ljsq,cut_coulsq,lj1,lj2,lj3,lj4,offset,ljsw1,ljsw2,ljsw3,ljsw4,ljsw5;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const;
|
||||
|
||||
Kokkos::DualView<params_lj_coul**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj_coul**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj_coul m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_ljsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_coulsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_ljsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_coulsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_coulsq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_coul[4];
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsCoulGromacsKokkos,FULL,CoulLongTable<1> >(PairLJGromacsCoulGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsCoulGromacsKokkos,HALF,CoulLongTable<1> >(PairLJGromacsCoulGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsCoulGromacsKokkos,HALFTHREAD,CoulLongTable<1> >(PairLJGromacsCoulGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJGromacsCoulGromacsKokkos,CoulLongTable<1> >(PairLJGromacsCoulGromacsKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsCoulGromacsKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsCoulGromacsKokkos,FULL,CoulLongTable<0> >(PairLJGromacsCoulGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsCoulGromacsKokkos,HALF,CoulLongTable<0> >(PairLJGromacsCoulGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsCoulGromacsKokkos,HALFTHREAD,CoulLongTable<0> >(PairLJGromacsCoulGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJGromacsCoulGromacsKokkos,CoulLongTable<0> >(PairLJGromacsCoulGromacsKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJGromacsCoulGromacsKokkos>(PairLJGromacsCoulGromacsKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
|
|
@ -0,0 +1,333 @@
|
|||
/* ----------------------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Ray Shan (SNL)
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "math.h"
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "pair_lj_gromacs_kokkos.h"
|
||||
#include "kokkos.h"
|
||||
#include "atom_kokkos.h"
|
||||
#include "comm.h"
|
||||
#include "force.h"
|
||||
#include "neighbor.h"
|
||||
#include "neigh_list.h"
|
||||
#include "neigh_request.h"
|
||||
#include "update.h"
|
||||
#include "integrate.h"
|
||||
#include "respa.h"
|
||||
#include "math_const.h"
|
||||
#include "memory.h"
|
||||
#include "error.h"
|
||||
#include "atom_masks.h"
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
using namespace MathConst;
|
||||
|
||||
#define KOKKOS_CUDA_MAX_THREADS 256
|
||||
#define KOKKOS_CUDA_MIN_BLOCKS 8
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJGromacsKokkos<DeviceType>::PairLJGromacsKokkos(LAMMPS *lmp):PairLJGromacs(lmp)
|
||||
{
|
||||
respa_enable = 0;
|
||||
|
||||
atomKK = (AtomKokkos *) atom;
|
||||
execution_space = ExecutionSpaceFromDevice<DeviceType>::space;
|
||||
datamask_read = X_MASK | F_MASK | TYPE_MASK | Q_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
datamask_modify = F_MASK | ENERGY_MASK | VIRIAL_MASK;
|
||||
cutsq = NULL;
|
||||
cut_inner = NULL;
|
||||
cut_inner_sq = NULL;
|
||||
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
PairLJGromacsKokkos<DeviceType>::~PairLJGromacsKokkos()
|
||||
{
|
||||
if (!copymode) {
|
||||
memory->destroy_kokkos(k_eatom,eatom);
|
||||
memory->destroy_kokkos(k_vatom,vatom);
|
||||
k_cutsq = DAT::tdual_ffloat_2d();
|
||||
k_cut_inner_sq = DAT::tdual_ffloat_2d();
|
||||
memory->sfree(cutsq);
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
cutsq = NULL;
|
||||
cut_inner = NULL;
|
||||
cut_inner_sq = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsKokkos<DeviceType>::cleanup_copy() {
|
||||
// WHY needed: this prevents parent copy from deallocating any arrays
|
||||
allocated = 0;
|
||||
cutsq = NULL;
|
||||
cut_inner = NULL;
|
||||
cut_inner_sq = NULL;
|
||||
eatom = NULL;
|
||||
vatom = NULL;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
{
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (neighflag == FULL || neighflag == FULLCLUSTER) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
atomKK->sync(execution_space,datamask_read);
|
||||
k_cutsq.template sync<DeviceType>();
|
||||
k_cut_inner.template sync<DeviceType>();
|
||||
k_cut_inner_sq.template sync<DeviceType>();
|
||||
k_params.template sync<DeviceType>();
|
||||
if (eflag || vflag) atomKK->modified(execution_space,datamask_modify);
|
||||
else atomKK->modified(execution_space,F_MASK);
|
||||
|
||||
x = atomKK->k_x.view<DeviceType>();
|
||||
c_x = atomKK->k_x.view<DeviceType>();
|
||||
f = atomKK->k_f.view<DeviceType>();
|
||||
q = atomKK->k_q.view<DeviceType>();
|
||||
type = atomKK->k_type.view<DeviceType>();
|
||||
nlocal = atom->nlocal;
|
||||
nall = atom->nlocal + atom->nghost;
|
||||
special_lj[0] = force->special_lj[0];
|
||||
special_lj[1] = force->special_lj[1];
|
||||
special_lj[2] = force->special_lj[2];
|
||||
special_lj[3] = force->special_lj[3];
|
||||
qqrd2e = force->qqrd2e;
|
||||
newton_pair = force->newton_pair;
|
||||
|
||||
// loop over neighbors of my atoms
|
||||
|
||||
copymode = 1;
|
||||
|
||||
EV_FLOAT ev = pair_compute<PairLJGromacsKokkos<DeviceType>,CoulLongTable<0> >
|
||||
(this,(NeighListKokkos<DeviceType>*)list);
|
||||
|
||||
DeviceType::fence();
|
||||
|
||||
if (eflag) {
|
||||
eng_vdwl += ev.evdwl;
|
||||
eng_coul += 0.0;
|
||||
}
|
||||
if (vflag_global) {
|
||||
virial[0] += ev.v[0];
|
||||
virial[1] += ev.v[1];
|
||||
virial[2] += ev.v[2];
|
||||
virial[3] += ev.v[3];
|
||||
virial[4] += ev.v[4];
|
||||
virial[5] += ev.v[5];
|
||||
}
|
||||
|
||||
if (vflag_fdotr) pair_virial_fdotr_compute(this);
|
||||
|
||||
copymode = 0;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ GROMACS pair force between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJGromacsKokkos<DeviceType>::
|
||||
compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT forcelj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj1:params(itype,jtype).lj1)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj2:params(itype,jtype).lj2));
|
||||
|
||||
if (rsq > (STACKPARAMS?m_params[itype][jtype].cut_inner_sq:params(itype,jtype).cut_inner_sq)) {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT tlj = r - (STACKPARAMS?m_params[itype][jtype].cut_inner:params(itype,jtype).cut_inner);
|
||||
const F_FLOAT fswitch = r*tlj*tlj*
|
||||
((STACKPARAMS?m_params[itype][jtype].ljsw1:params(itype,jtype).ljsw1) +
|
||||
(STACKPARAMS?m_params[itype][jtype].ljsw2:params(itype,jtype).ljsw2)*tlj);
|
||||
forcelj += fswitch;
|
||||
}
|
||||
return forcelj*r2inv;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
compute LJ GROMACS pair potential energy between atoms i and j
|
||||
---------------------------------------------------------------------- */
|
||||
template<class DeviceType>
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT PairLJGromacsKokkos<DeviceType>::
|
||||
compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const {
|
||||
|
||||
const F_FLOAT r2inv = 1.0/rsq;
|
||||
const F_FLOAT r6inv = r2inv*r2inv*r2inv;
|
||||
F_FLOAT englj = r6inv *
|
||||
((STACKPARAMS?m_params[itype][jtype].lj3:params(itype,jtype).lj3)*r6inv -
|
||||
(STACKPARAMS?m_params[itype][jtype].lj4:params(itype,jtype).lj4));
|
||||
englj += (STACKPARAMS?m_params[itype][jtype].ljsw5:params(itype,jtype).ljsw5);
|
||||
|
||||
if (rsq > (STACKPARAMS?m_params[itype][jtype].cut_inner_sq:params(itype,jtype).cut_inner_sq)) {
|
||||
const F_FLOAT r = sqrt(rsq);
|
||||
const F_FLOAT tlj = r - (STACKPARAMS?m_params[itype][jtype].cut_inner:params(itype,jtype).cut_inner);
|
||||
const F_FLOAT eswitch = tlj*tlj*tlj *
|
||||
((STACKPARAMS?m_params[itype][jtype].ljsw3:params(itype,jtype).ljsw3) +
|
||||
(STACKPARAMS?m_params[itype][jtype].ljsw4:params(itype,jtype).ljsw4)*tlj);
|
||||
englj += eswitch;
|
||||
}
|
||||
return englj;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
allocate all arrays
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsKokkos<DeviceType>::allocate()
|
||||
{
|
||||
PairLJGromacs::allocate();
|
||||
|
||||
int n = atom->ntypes;
|
||||
|
||||
memory->destroy(cutsq);
|
||||
memory->create_kokkos(k_cutsq,cutsq,n+1,n+1,"pair:cutsq");
|
||||
d_cutsq = k_cutsq.template view<DeviceType>();
|
||||
|
||||
memory->destroy(cut_inner);
|
||||
memory->create_kokkos(k_cut_inner,cut_inner,n+1,n+1,"pair:cut_inner");
|
||||
d_cut_inner = k_cut_inner.template view<DeviceType>();
|
||||
|
||||
memory->destroy(cut_inner_sq);
|
||||
memory->create_kokkos(k_cut_inner_sq,cut_inner_sq,n+1,n+1,"pair:cut_inner_sq");
|
||||
d_cut_inner_sq = k_cut_inner_sq.template view<DeviceType>();
|
||||
|
||||
k_params = Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType>("PairLJGromacs::params",n+1,n+1);
|
||||
params = k_params.d_view;
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
global settings
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsKokkos<DeviceType>::settings(int narg, char **arg)
|
||||
{
|
||||
if (narg != 2) error->all(FLERR,"Illegal pair_style command");
|
||||
|
||||
PairLJGromacs::settings(narg,arg);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init specific to this pair style
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
void PairLJGromacsKokkos<DeviceType>::init_style()
|
||||
{
|
||||
PairLJGromacs::init_style();
|
||||
|
||||
// error if rRESPA with inner levels
|
||||
|
||||
if (update->whichflag == 1 && strstr(update->integrate_style,"respa")) {
|
||||
int respa = 0;
|
||||
if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
|
||||
if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
|
||||
if (respa)
|
||||
error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
|
||||
}
|
||||
|
||||
// irequest = neigh request made by parent class
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_host = Kokkos::Impl::is_same<DeviceType,LMPHostType>::value &&
|
||||
!Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
neighbor->requests[irequest]->
|
||||
kokkos_device = Kokkos::Impl::is_same<DeviceType,LMPDeviceType>::value;
|
||||
|
||||
if (neighflag == FULL) {
|
||||
neighbor->requests[irequest]->full = 1;
|
||||
neighbor->requests[irequest]->half = 0;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else if (neighflag == HALF || neighflag == HALFTHREAD) {
|
||||
neighbor->requests[irequest]->full = 0;
|
||||
neighbor->requests[irequest]->half = 1;
|
||||
neighbor->requests[irequest]->full_cluster = 0;
|
||||
} else {
|
||||
error->all(FLERR,"Cannot use chosen neighbor list style with lj/gromacs/kk");
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
init for one type pair i,j and corresponding j,i
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
template<class DeviceType>
|
||||
double PairLJGromacsKokkos<DeviceType>::init_one(int i, int j)
|
||||
{
|
||||
double cutone = PairLJGromacs::init_one(i,j);
|
||||
double cut_inner_sqm = cut_inner_sq[i][j];
|
||||
|
||||
k_params.h_view(i,j).lj1 = lj1[i][j];
|
||||
k_params.h_view(i,j).lj2 = lj2[i][j];
|
||||
k_params.h_view(i,j).lj3 = lj3[i][j];
|
||||
k_params.h_view(i,j).lj4 = lj4[i][j];
|
||||
k_params.h_view(i,j).ljsw1 = ljsw1[i][j];
|
||||
k_params.h_view(i,j).ljsw2 = ljsw2[i][j];
|
||||
k_params.h_view(i,j).ljsw3 = ljsw3[i][j];
|
||||
k_params.h_view(i,j).ljsw4 = ljsw4[i][j];
|
||||
k_params.h_view(i,j).ljsw5 = ljsw5[i][j];
|
||||
k_params.h_view(i,j).cut_inner_sq = cut_inner_sqm;
|
||||
k_params.h_view(i,j).cut_inner = cut_inner[i][j];
|
||||
|
||||
k_params.h_view(j,i) = k_params.h_view(i,j);
|
||||
if(i<MAX_TYPES_STACKPARAMS+1 && j<MAX_TYPES_STACKPARAMS+1) {
|
||||
m_params[i][j] = m_params[j][i] = k_params.h_view(i,j);
|
||||
m_cutsq[j][i] = m_cutsq[i][j] = cutone*cutone;
|
||||
m_cut_inner_sq[j][i] = m_cut_inner_sq[i][j] = cut_inner_sqm;
|
||||
}
|
||||
|
||||
k_cutsq.h_view(i,j) = cutone*cutone;
|
||||
k_cutsq.template modify<LMPHostType>();
|
||||
k_cut_inner_sq.h_view(i,j) = cut_inner_sqm;
|
||||
k_cut_inner_sq.template modify<LMPHostType>();
|
||||
k_params.template modify<LMPHostType>();
|
||||
|
||||
return cutone;
|
||||
}
|
||||
|
||||
template class PairLJGromacsKokkos<LMPDeviceType>;
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
template class PairLJGromacsKokkos<LMPHostType>;
|
||||
#endif
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
/* -*- c++ -*- ----------------------------------------------------------
|
||||
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
||||
http://lammps.sandia.gov, Sandia National Laboratories
|
||||
Steve Plimpton, sjplimp@sandia.gov
|
||||
|
||||
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
||||
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
||||
certain rights in this software. This software is distributed under
|
||||
the GNU General Public License.
|
||||
|
||||
See the README file in the top-level LAMMPS directory.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#ifdef PAIR_CLASS
|
||||
|
||||
PairStyle(lj/gromacs/kk,PairLJGromacsKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/gromacs/kk/device,PairLJGromacsKokkos<LMPDeviceType>)
|
||||
PairStyle(lj/gromacs/kk/host,PairLJGromacsKokkos<LMPHostType>)
|
||||
|
||||
#else
|
||||
|
||||
#ifndef LMP_PAIR_LJ_GROMACS_KOKKOS_H
|
||||
#define LMP_PAIR_LJ_GROMACS_KOKKOS_H
|
||||
|
||||
#include "pair_kokkos.h"
|
||||
#include "pair_lj_gromacs.h"
|
||||
#include "neigh_list_kokkos.h"
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
|
||||
template<class DeviceType>
|
||||
class PairLJGromacsKokkos : public PairLJGromacs {
|
||||
public:
|
||||
enum {EnabledNeighFlags=FULL|HALFTHREAD|HALF};
|
||||
enum {COUL_FLAG=0};
|
||||
typedef DeviceType device_type;
|
||||
PairLJGromacsKokkos(class LAMMPS *);
|
||||
~PairLJGromacsKokkos();
|
||||
|
||||
void compute(int, int);
|
||||
|
||||
void settings(int, char **);
|
||||
void init_style();
|
||||
double init_one(int, int);
|
||||
|
||||
struct params_lj{
|
||||
params_lj(){cut_inner_sq=0;cut_inner=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;ljsw1=0;ljsw2=0;ljsw3=0;ljsw4=0;ljsw5=0;};
|
||||
params_lj(int i){cut_inner_sq=0;cut_inner=0;lj1=0;lj2=0;lj3=0;lj4=0;offset=0;ljsw1=0;ljsw2=0;ljsw3=0;ljsw4=0;ljsw5=0;};
|
||||
F_FLOAT cut_inner_sq,cut_inner,lj1,lj2,lj3,lj4,offset,ljsw1,ljsw2,ljsw3,ljsw4,ljsw5;
|
||||
};
|
||||
|
||||
protected:
|
||||
void cleanup_copy();
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fpair(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_fcoul(const F_FLOAT& rsq, const int& i, const int&j, const int& itype,
|
||||
const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_evdwl(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype) const;
|
||||
|
||||
template<bool STACKPARAMS, class Specialisation>
|
||||
KOKKOS_INLINE_FUNCTION
|
||||
F_FLOAT compute_ecoul(const F_FLOAT& rsq, const int& i, const int&j,
|
||||
const int& itype, const int& jtype, const F_FLOAT& factor_coul, const F_FLOAT& qtmp) const{
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
Kokkos::DualView<params_lj**,Kokkos::LayoutRight,DeviceType> k_params;
|
||||
typename Kokkos::DualView<params_lj**,
|
||||
Kokkos::LayoutRight,DeviceType>::t_dev_const params;
|
||||
// hardwired to space for 15 atom types
|
||||
params_lj m_params[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
|
||||
F_FLOAT m_cutsq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_inner[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
F_FLOAT m_cut_inner_sq[MAX_TYPES_STACKPARAMS+1][MAX_TYPES_STACKPARAMS+1];
|
||||
typename ArrayTypes<DeviceType>::t_x_array_randomread x;
|
||||
typename ArrayTypes<DeviceType>::t_x_array c_x;
|
||||
typename ArrayTypes<DeviceType>::t_f_array f;
|
||||
typename ArrayTypes<DeviceType>::t_int_1d_randomread type;
|
||||
typename ArrayTypes<DeviceType>::t_float_1d_randomread q;
|
||||
|
||||
DAT::tdual_efloat_1d k_eatom;
|
||||
DAT::tdual_virial_array k_vatom;
|
||||
typename ArrayTypes<DeviceType>::t_efloat_1d d_eatom;
|
||||
typename ArrayTypes<DeviceType>::t_virial_array d_vatom;
|
||||
|
||||
int newton_pair;
|
||||
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cutsq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cutsq;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_inner;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_inner;
|
||||
typename ArrayTypes<DeviceType>::tdual_ffloat_2d k_cut_inner_sq;
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_2d d_cut_inner_sq;
|
||||
|
||||
typename ArrayTypes<DeviceType>::t_ffloat_1d_randomread
|
||||
d_rtable, d_drtable, d_ftable, d_dftable,
|
||||
d_ctable, d_dctable, d_etable, d_detable;
|
||||
class AtomKokkos *atomKK;
|
||||
int neighflag;
|
||||
int nlocal,nall,eflag,vflag;
|
||||
|
||||
double special_lj[4];
|
||||
double qqrd2e;
|
||||
|
||||
void allocate();
|
||||
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,FULL,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALF,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALFTHREAD,true,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,FULL,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALF,false,CoulLongTable<1> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALFTHREAD,false,CoulLongTable<1> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsKokkos,FULL,CoulLongTable<1> >(PairLJGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsKokkos,HALF,CoulLongTable<1> >(PairLJGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsKokkos,HALFTHREAD,CoulLongTable<1> >(PairLJGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJGromacsKokkos,CoulLongTable<1> >(PairLJGromacsKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,FULL,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALF,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALFTHREAD,true,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,FULL,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALF,false,CoulLongTable<0> >;
|
||||
friend class PairComputeFunctor<PairLJGromacsKokkos,HALFTHREAD,false,CoulLongTable<0> >;
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsKokkos,FULL,CoulLongTable<0> >(PairLJGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsKokkos,HALF,CoulLongTable<0> >(PairLJGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute_neighlist<PairLJGromacsKokkos,HALFTHREAD,CoulLongTable<0> >(PairLJGromacsKokkos*,NeighListKokkos<DeviceType>*);
|
||||
friend EV_FLOAT pair_compute<PairLJGromacsKokkos,CoulLongTable<0> >(PairLJGromacsKokkos*,
|
||||
NeighListKokkos<DeviceType>*);
|
||||
friend void pair_virial_fdotr_compute<PairLJGromacsKokkos>(PairLJGromacsKokkos*);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* ERROR/WARNING messages:
|
||||
|
||||
*/
|
||||
Loading…
Reference in New Issue