forked from lijiext/lammps
major neighbor list style whitespace cleanup
This commit is contained in:
parent
286d4f2743
commit
03ab8d0f48
|
@ -287,12 +287,12 @@ int NeighborKokkosExecute<DeviceType>::exclusion(const int &i,const int &j,
|
|||
|
||||
if (nex_mol) {
|
||||
for (m = 0; m < nex_mol; m++)
|
||||
if (ex_mol_intra[m]) { // intra-chain: exclude i-j pair if on same molecule
|
||||
if (ex_mol_intra[m]) { // intra-chain: exclude i-j pair if on same molecule
|
||||
if (mask[i] & ex_mol_bit[m] && mask[j] & ex_mol_bit[m] &&
|
||||
molecule[i] == molecule[j]) return 1;
|
||||
} else // exclude i-j pair if on different molecules
|
||||
if (mask[i] & ex_mol_bit[m] && mask[j] & ex_mol_bit[m] &&
|
||||
molecule[i] != molecule[j]) return 1;
|
||||
molecule[i] == molecule[j]) return 1;
|
||||
} else // exclude i-j pair if on different molecules
|
||||
if (mask[i] & ex_mol_bit[m] && mask[j] & ex_mol_bit[m] &&
|
||||
molecule[i] != molecule[j]) return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -385,7 +385,7 @@ struct NPairKokkosBuildFunctor {
|
|||
}
|
||||
#ifdef KOKKOS_HAVE_CUDA
|
||||
__device__ inline
|
||||
|
||||
|
||||
void operator() (typename Kokkos::TeamPolicy<DeviceType>::member_type dev) const {
|
||||
c.template build_ItemCuda<HALF_NEIGH,GHOST_NEWTON,TRI>(dev);
|
||||
}
|
||||
|
|
|
@ -55,7 +55,7 @@ NBinIntel::~NBinIntel() {
|
|||
nocopy(binhead,bins,_atombin,_binpacked:alloc_if(0) free_if(1))
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
setup for bin_atoms()
|
||||
|
@ -71,7 +71,7 @@ void NBinIntel::bin_atoms_setup(int nall)
|
|||
if (_offload_alloc) {
|
||||
const int * binhead = this->binhead;
|
||||
#pragma offload_transfer target(mic:_cop) \
|
||||
nocopy(binhead:alloc_if(0) free_if(1))
|
||||
nocopy(binhead:alloc_if(0) free_if(1))
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -99,7 +99,7 @@ void NBinIntel::bin_atoms_setup(int nall)
|
|||
const int * _atombin = this->_atombin;
|
||||
const int * _binpacked = this->_binpacked;
|
||||
#pragma offload_transfer target(mic:_cop) \
|
||||
nocopy(bins,_atombin,_binpacked:alloc_if(0) free_if(1))
|
||||
nocopy(bins,_atombin,_binpacked:alloc_if(0) free_if(1))
|
||||
}
|
||||
#endif
|
||||
memory->destroy(bins);
|
||||
|
@ -157,10 +157,10 @@ void NBinIntel::bin_atoms(IntelBuffers<flt_t,acc_t> * buffers) {
|
|||
const flt_t dx = (INTEL_BIGP - bboxhi[0]);
|
||||
const flt_t dy = (INTEL_BIGP - bboxhi[1]);
|
||||
const flt_t dz = (INTEL_BIGP - bboxhi[2]);
|
||||
if (dx * dx + dy * dy + dz * dz <
|
||||
static_cast<flt_t>(neighbor->cutneighmaxsq))
|
||||
if (dx * dx + dy * dy + dz * dz <
|
||||
static_cast<flt_t>(neighbor->cutneighmaxsq))
|
||||
error->one(FLERR,
|
||||
"Intel package expects no atoms within cutoff of {1e15,1e15,1e15}.");
|
||||
"Intel package expects no atoms within cutoff of {1e15,1e15,1e15}.");
|
||||
}
|
||||
|
||||
// ---------- Grow and cast/pack buffers -------------
|
||||
|
@ -181,7 +181,7 @@ void NBinIntel::bin_atoms(IntelBuffers<flt_t,acc_t> * buffers) {
|
|||
{
|
||||
int ifrom, ito, tid;
|
||||
IP_PRE_omp_range_id_align(ifrom, ito, tid, nall, nthreads,
|
||||
sizeof(ATOM_T));
|
||||
sizeof(ATOM_T));
|
||||
buffers->thr_pack(ifrom, ito, 0);
|
||||
}
|
||||
_fix->stop_watch(TIME_PACK);
|
||||
|
|
|
@ -70,12 +70,12 @@ fbi(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
|
|||
#endif
|
||||
|
||||
buffers->grow_list(list, atom->nlocal, comm->nthreads, off_end,
|
||||
_fix->nbor_pack_width());
|
||||
_fix->nbor_pack_width());
|
||||
|
||||
int need_ic = 0;
|
||||
if (atom->molecular)
|
||||
dminimum_image_check(need_ic, neighbor->cutneighmax, neighbor->cutneighmax,
|
||||
neighbor->cutneighmax);
|
||||
neighbor->cutneighmax);
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (need_ic) {
|
||||
|
@ -167,7 +167,7 @@ fbi(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
overflow = _fix->get_off_overflow_flag();
|
||||
_fix->stop_watch(TIME_HOST_NEIGHBOR);
|
||||
_fix->start_watch(TIME_OFFLOAD_LATENCY);
|
||||
} else
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
tnum = comm->nthreads;
|
||||
|
@ -255,8 +255,8 @@ fbi(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
ito += astart;
|
||||
int e_ito = ito;
|
||||
if (ito == num) {
|
||||
int imod = ito % pack_width;
|
||||
if (imod) e_ito += pack_width - imod;
|
||||
int imod = ito % pack_width;
|
||||
if (imod) e_ito += pack_width - imod;
|
||||
}
|
||||
const int list_size = (e_ito + tid * 2 + 2) * maxnbors;
|
||||
int which;
|
||||
|
@ -276,91 +276,91 @@ fbi(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
const int ioffset = ntypes * itype;
|
||||
|
||||
const int ibin = atombin[i];
|
||||
int raw_count = pack_offset;
|
||||
int raw_count = pack_offset;
|
||||
|
||||
// loop over all atoms in surrounding bins in stencil including self
|
||||
// skip i = j
|
||||
if (exclude) {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
if (exclude) {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
#ifdef INTEL_VMASK
|
||||
#ifdef INTEL_VMASK
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
int j = binpacked[jj];
|
||||
#endif
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
int j = binpacked[jj];
|
||||
|
||||
if (i == j) j=e_nall;
|
||||
|
||||
if (i == j) j=e_nall;
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (offload_noghost) {
|
||||
if (offload_noghost) {
|
||||
if (j < nlocal) {
|
||||
if (i < offload_end) continue;
|
||||
} else if (offload) continue;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
#endif
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
#endif
|
||||
|
||||
neighptr[raw_count++] = j;
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
} else {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
#ifdef INTEL_VMASK
|
||||
#ifdef INTEL_VMASK
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
int j = binpacked[jj];
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
int j = binpacked[jj];
|
||||
|
||||
if (i == j) j=e_nall;
|
||||
|
||||
if (i == j) j=e_nall;
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (offload_noghost) {
|
||||
if (offload_noghost) {
|
||||
if (j < nlocal) {
|
||||
if (i < offload_end) continue;
|
||||
} else if (offload) continue;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
neighptr[raw_count++] = j;
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (raw_count > obound) *overflow = 1;
|
||||
if (raw_count > obound) *overflow = 1;
|
||||
|
||||
#if defined(LMP_SIMD_COMPILER)
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
int vlmin = lmin, vlmax = lmax, vgmin = gmin, vgmax = gmax;
|
||||
#if __INTEL_COMPILER+0 > 1499
|
||||
#pragma vector aligned
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
int vlmin = lmin, vlmax = lmax, vgmin = gmin, vgmax = gmax;
|
||||
#if __INTEL_COMPILER+0 > 1499
|
||||
#pragma vector aligned
|
||||
#pragma simd reduction(max:vlmax,vgmax) reduction(min:vlmin, vgmin)
|
||||
#endif
|
||||
#else
|
||||
#pragma vector aligned
|
||||
#endif
|
||||
#else
|
||||
#pragma vector aligned
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
#endif
|
||||
#endif
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
int j = neighptr[u];
|
||||
const flt_t delx = xtmp - x[j].x;
|
||||
const flt_t dely = ytmp - x[j].y;
|
||||
const flt_t delz = ztmp - x[j].z;
|
||||
const int jtype = x[j].w;
|
||||
const flt_t rsq = delx * delx + dely * dely + delz * delz;
|
||||
if (rsq > cutneighsq[ioffset + jtype])
|
||||
neighptr[u] = e_nall;
|
||||
else {
|
||||
if (rsq > cutneighsq[ioffset + jtype])
|
||||
neighptr[u] = e_nall;
|
||||
else {
|
||||
if (need_ic) {
|
||||
int no_special;
|
||||
ominimum_image_check(no_special, delx, dely, delz);
|
||||
|
@ -376,73 +376,73 @@ fbi(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
if (j > vgmax) vgmax = j;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
lmin = MIN(lmin,vlmin);
|
||||
gmin = MIN(gmin,vgmin);
|
||||
lmax = MAX(lmax,vlmax);
|
||||
gmax = MAX(gmax,vgmax);
|
||||
lmin = MIN(lmin,vlmin);
|
||||
gmin = MIN(gmin,vgmin);
|
||||
lmax = MAX(lmax,vlmax);
|
||||
gmax = MAX(gmax,vgmax);
|
||||
#endif
|
||||
|
||||
int n = lane, n2 = pack_offset;
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
const int j = neighptr[u];
|
||||
int pj = j;
|
||||
if (pj < e_nall) {
|
||||
if (need_ic)
|
||||
if (pj < 0) pj = -pj - 1;
|
||||
|
||||
const int jtag = tag[pj];
|
||||
int flist = 0;
|
||||
if (itag > jtag) {
|
||||
if ((itag+jtag) % 2 == 0) flist = 1;
|
||||
} else if (itag < jtag) {
|
||||
if ((itag+jtag) % 2 == 1) flist = 1;
|
||||
} else {
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
const int j = neighptr[u];
|
||||
int pj = j;
|
||||
if (pj < e_nall) {
|
||||
if (need_ic)
|
||||
if (pj < 0) pj = -pj - 1;
|
||||
|
||||
const int jtag = tag[pj];
|
||||
int flist = 0;
|
||||
if (itag > jtag) {
|
||||
if ((itag+jtag) % 2 == 0) flist = 1;
|
||||
} else if (itag < jtag) {
|
||||
if ((itag+jtag) % 2 == 1) flist = 1;
|
||||
} else {
|
||||
if (x[pj].z < ztmp) flist = 1;
|
||||
else if (x[pj].z == ztmp && x[pj].y < ytmp) flist = 1;
|
||||
else if (x[pj].z == ztmp && x[pj].y == ytmp && x[pj].x < xtmp)
|
||||
flist = 1;
|
||||
}
|
||||
if (flist) {
|
||||
neighptr[n2++] = j;
|
||||
} else {
|
||||
neighptr[n] = j;
|
||||
n += pack_width;
|
||||
}
|
||||
else if (x[pj].z == ztmp && x[pj].y < ytmp) flist = 1;
|
||||
else if (x[pj].z == ztmp && x[pj].y == ytmp && x[pj].x < xtmp)
|
||||
flist = 1;
|
||||
}
|
||||
if (flist) {
|
||||
neighptr[n2++] = j;
|
||||
} else {
|
||||
neighptr[n] = j;
|
||||
n += pack_width;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ns = (n - lane) / pack_width;
|
||||
atombin[i] = ns;
|
||||
for (int u = pack_offset; u < n2; u++) {
|
||||
neighptr[n] = neighptr[u];
|
||||
n += pack_width;
|
||||
}
|
||||
int ns = (n - lane) / pack_width;
|
||||
atombin[i] = ns;
|
||||
for (int u = pack_offset; u < n2; u++) {
|
||||
neighptr[n] = neighptr[u];
|
||||
n += pack_width;
|
||||
}
|
||||
|
||||
ilist[i] = i;
|
||||
cnumneigh[i] = ct + lane;
|
||||
ns += n2 - pack_offset;
|
||||
ns += n2 - pack_offset;
|
||||
numneigh[i] = ns;
|
||||
|
||||
if (ns > max_chunk) max_chunk = ns;
|
||||
lane++;
|
||||
if (lane == pack_width) {
|
||||
ct += max_chunk * pack_width;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
const int edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
max_chunk = 0;
|
||||
pack_offset = maxnbors * pack_width;
|
||||
lane = 0;
|
||||
if (ct + obound > list_size) {
|
||||
if (i < ito - 1) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
}
|
||||
if (ns > max_chunk) max_chunk = ns;
|
||||
lane++;
|
||||
if (lane == pack_width) {
|
||||
ct += max_chunk * pack_width;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
const int edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
max_chunk = 0;
|
||||
pack_offset = maxnbors * pack_width;
|
||||
lane = 0;
|
||||
if (ct + obound > list_size) {
|
||||
if (i < ito - 1) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (*overflow == 1)
|
||||
|
@ -482,13 +482,13 @@ fbi(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
int * _noalias jlist = firstneigh + cnumneigh[i];
|
||||
const int jnum = numneigh[i];
|
||||
|
||||
const int trip = jnum * pack_width;
|
||||
const int trip = jnum * pack_width;
|
||||
for (int jj = 0; jj < trip; jj+=pack_width) {
|
||||
const int j = jlist[jj];
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
} else
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
} else
|
||||
ofind_special(which, special, nspecial, i, tag[j]);
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j >= nlocal) {
|
||||
|
@ -511,9 +511,9 @@ fbi(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
int jj = 0;
|
||||
for (jj = 0; jj < jnum; jj++) {
|
||||
if (jlist[jj] >= nlocal) {
|
||||
if (jlist[jj] == e_nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
}
|
||||
if (jlist[jj] == e_nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NPairStyle(full/bin/intel,
|
||||
NPairFullBinIntel,
|
||||
NP_FULL | NP_BIN | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI |
|
||||
NP_FULL | NP_BIN | NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI |
|
||||
NP_INTEL)
|
||||
#else
|
||||
|
||||
|
@ -38,7 +38,7 @@ class NPairFullBinIntel : public NPairIntel {
|
|||
void fbi(NeighList *, IntelBuffers<flt_t,acc_t> *);
|
||||
template <class flt_t, class acc_t, int, int>
|
||||
void fbi(const int, NeighList *, IntelBuffers<flt_t,acc_t> *, const int,
|
||||
const int, const int offload_end = 0);
|
||||
const int, const int offload_end = 0);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -26,7 +26,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NPairHalfBinNewtoffIntel::NPairHalfBinNewtoffIntel(LAMMPS *lmp) :
|
||||
NPairHalfBinNewtoffIntel::NPairHalfBinNewtoffIntel(LAMMPS *lmp) :
|
||||
NPairIntel(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
@ -75,7 +75,7 @@ hbnni(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
|
|||
int need_ic = 0;
|
||||
if (atom->molecular)
|
||||
dminimum_image_check(need_ic, neighbor->cutneighmax, neighbor->cutneighmax,
|
||||
neighbor->cutneighmax);
|
||||
neighbor->cutneighmax);
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (need_ic) {
|
||||
|
@ -159,7 +159,7 @@ hbnni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
overflow = _fix->get_off_overflow_flag();
|
||||
_fix->stop_watch(TIME_HOST_NEIGHBOR);
|
||||
_fix->start_watch(TIME_OFFLOAD_LATENCY);
|
||||
} else
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
tnum = comm->nthreads;
|
||||
|
@ -294,13 +294,13 @@ hbnni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
ominimum_image_check(no_special, delx, dely, delz);
|
||||
if (no_special)
|
||||
neighptr[n++] = -j - 1;
|
||||
else
|
||||
else
|
||||
neighptr[n++] = j;
|
||||
} else
|
||||
neighptr[n++] = j;
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j < lmin) lmin = j;
|
||||
if (j > lmax) lmax = j;
|
||||
if (j < lmin) lmin = j;
|
||||
if (j > lmax) lmax = j;
|
||||
#endif
|
||||
} else {
|
||||
if (need_ic) {
|
||||
|
@ -308,16 +308,16 @@ hbnni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
ominimum_image_check(no_special, delx, dely, delz);
|
||||
if (no_special)
|
||||
neighptr[n2++] = -j - 1;
|
||||
else
|
||||
else
|
||||
neighptr[n2++] = j;
|
||||
} else
|
||||
neighptr[n2++] = j;
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j < gmin) gmin = j;
|
||||
if (j > gmax) gmax = j;
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j < gmin) gmin = j;
|
||||
if (j > gmax) gmax = j;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ilist[i] = i;
|
||||
|
@ -341,13 +341,13 @@ hbnni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
neighptr += n;
|
||||
if (ct + n + maxnbors > list_size) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid) * maxnbors;
|
||||
ct = (ifrom + tid) * maxnbors;
|
||||
}
|
||||
}
|
||||
|
||||
if (*overflow == 1)
|
||||
for (int i = ifrom; i < ito; i++)
|
||||
numneigh[i] = 0;
|
||||
for (int i = ifrom; i < ito; i++)
|
||||
numneigh[i] = 0;
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (separate_buffers) {
|
||||
|
@ -370,7 +370,7 @@ hbnni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
if (offload) {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - overflow[LMP_LOCAL_MAX] - 1;
|
||||
nall_offset = overflow[LMP_LOCAL_MAX] + 1 + nghost;
|
||||
} else {
|
||||
} else {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - nlocal;
|
||||
nall_offset = nlocal + nghost;
|
||||
}
|
||||
|
@ -383,38 +383,38 @@ hbnni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
const int jnum = numneigh[i];
|
||||
for (int jj = 0; jj < jnum; jj++) {
|
||||
const int j = jlist[jj];
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
} else
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
} else
|
||||
ofind_special(which, special, nspecial, i, tag[j]);
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j >= nlocal) {
|
||||
if (j == nall)
|
||||
jlist[jj] = nall_offset;
|
||||
else if (which)
|
||||
jlist[jj] = (j-ghost_offset) ^ (which << SBBITS);
|
||||
else jlist[jj]-=ghost_offset;
|
||||
if (j >= nlocal) {
|
||||
if (j == nall)
|
||||
jlist[jj] = nall_offset;
|
||||
else if (which)
|
||||
jlist[jj] = (j-ghost_offset) ^ (which << SBBITS);
|
||||
else jlist[jj]-=ghost_offset;
|
||||
} else
|
||||
#endif
|
||||
if (which) jlist[jj] = j ^ (which << SBBITS);
|
||||
if (which) jlist[jj] = j ^ (which << SBBITS);
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
else if (separate_buffers) {
|
||||
for (int i = ifrom; i < ito; ++i) {
|
||||
for (int i = ifrom; i < ito; ++i) {
|
||||
int * _noalias jlist = firstneigh + cnumneigh[i];
|
||||
const int jnum = numneigh[i];
|
||||
int jj = 0;
|
||||
for (jj = 0; jj < jnum; jj++)
|
||||
if (jlist[jj] >= nlocal) break;
|
||||
while (jj < jnum) {
|
||||
if (jlist[jj] == nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
jj++;
|
||||
}
|
||||
}
|
||||
int jj = 0;
|
||||
for (jj = 0; jj < jnum; jj++)
|
||||
if (jlist[jj] >= nlocal) break;
|
||||
while (jj < jnum) {
|
||||
if (jlist[jj] == nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
jj++;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
} // end omp
|
||||
|
@ -438,9 +438,9 @@ hbnni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
_fix->start_watch(TIME_PACK);
|
||||
_fix->set_neighbor_host_sizes();
|
||||
buffers->pack_sep_from_single(_fix->host_min_local(),
|
||||
_fix->host_used_local(),
|
||||
_fix->host_min_ghost(),
|
||||
_fix->host_used_ghost());
|
||||
_fix->host_used_local(),
|
||||
_fix->host_min_ghost(),
|
||||
_fix->host_used_ghost());
|
||||
_fix->stop_watch(TIME_PACK);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -38,7 +38,7 @@ class NPairHalfBinNewtoffIntel : public NPairIntel {
|
|||
void hbnni(NeighList *, IntelBuffers<flt_t,acc_t> *);
|
||||
template <class flt_t, class acc_t, int>
|
||||
void hbnni(const int, NeighList *, IntelBuffers<flt_t,acc_t> *, const int,
|
||||
const int);
|
||||
const int);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -26,7 +26,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NPairHalfBinNewtonIntel::NPairHalfBinNewtonIntel(LAMMPS *lmp) :
|
||||
NPairHalfBinNewtonIntel::NPairHalfBinNewtonIntel(LAMMPS *lmp) :
|
||||
NPairIntel(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
@ -75,7 +75,7 @@ hbni(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
|
|||
int need_ic = 0;
|
||||
if (atom->molecular)
|
||||
dminimum_image_check(need_ic, neighbor->cutneighmax, neighbor->cutneighmax,
|
||||
neighbor->cutneighmax);
|
||||
neighbor->cutneighmax);
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (need_ic) {
|
||||
|
@ -96,7 +96,7 @@ hbni(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
|
|||
}
|
||||
}
|
||||
#else
|
||||
if (need_ic)
|
||||
if (need_ic)
|
||||
hbni<flt_t,acc_t,0,1>(0, list, buffers, host_start, nlocal);
|
||||
else
|
||||
hbni<flt_t,acc_t,0,0>(0, list, buffers, host_start, nlocal);
|
||||
|
@ -119,7 +119,7 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
if (offload) {
|
||||
if (INTEL_MIC_NBOR_PAD > 1)
|
||||
pad = INTEL_MIC_NBOR_PAD * sizeof(float) / sizeof(flt_t);
|
||||
} else
|
||||
} else
|
||||
#endif
|
||||
if (INTEL_NBOR_PAD > 1)
|
||||
pad = INTEL_NBOR_PAD * sizeof(float) / sizeof(flt_t);
|
||||
|
@ -172,7 +172,7 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
overflow = _fix->get_off_overflow_flag();
|
||||
_fix->stop_watch(TIME_HOST_NEIGHBOR);
|
||||
_fix->start_watch(TIME_OFFLOAD_LATENCY);
|
||||
} else
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
tnum = comm->nthreads;
|
||||
|
@ -235,8 +235,8 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
int end = stencil[k] + 1;
|
||||
for (int kk = k + 1; kk < nstencil; kk++) {
|
||||
if (stencil[kk-1]+1 == stencil[kk]) {
|
||||
end++;
|
||||
k++;
|
||||
end++;
|
||||
k++;
|
||||
} else break;
|
||||
}
|
||||
binend[nstencilp] = end;
|
||||
|
@ -262,8 +262,8 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
ito += astart;
|
||||
int e_ito = ito;
|
||||
if (ito == num) {
|
||||
int imod = ito % swidth;
|
||||
if (imod) e_ito += swidth - imod;
|
||||
int imod = ito % swidth;
|
||||
if (imod) e_ito += swidth - imod;
|
||||
}
|
||||
const int list_size = (e_ito + tid * 2 + 2) * maxnbors;
|
||||
#else
|
||||
|
@ -294,118 +294,118 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
// if j is owned atom, store it, since j is beyond i in linked list
|
||||
// if j is ghost, only store if j coords are "above/to the right" of i
|
||||
|
||||
int raw_count = pack_offset;
|
||||
int raw_count = pack_offset;
|
||||
for (int j = bins[i]; j >= 0; j = bins[j]) {
|
||||
if (j >= nlocal) {
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (offload_noghost && offload) continue;
|
||||
#endif
|
||||
#endif
|
||||
if (x[j].z < ztmp) continue;
|
||||
if (x[j].z == ztmp) {
|
||||
if (x[j].y < ytmp) continue;
|
||||
if (x[j].y == ytmp && x[j].x < xtmp) continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
else if (offload_noghost && i < offload_end) continue;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
if (exclude) {
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
}
|
||||
#endif
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
|
||||
// loop over all atoms in other bins in stencil, store every pair
|
||||
|
||||
const int ibin = atombin[i];
|
||||
if (exclude) {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
#ifdef INTEL_VMASK
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
const int j = binpacked[jj];
|
||||
|
||||
if (exclude) {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
#ifdef INTEL_VMASK
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
const int j = binpacked[jj];
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (offload_noghost) {
|
||||
if (j < nlocal) {
|
||||
if (i < offload_end) continue;
|
||||
} else if (offload) continue;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
#endif
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
#endif
|
||||
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
#ifdef INTEL_VMASK
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
const int j = binpacked[jj];
|
||||
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
#ifdef INTEL_VMASK
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
const int j = binpacked[jj];
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (offload_noghost) {
|
||||
if (j < nlocal) {
|
||||
if (i < offload_end) continue;
|
||||
} else if (offload) continue;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (raw_count > obound) *overflow = 1;
|
||||
if (raw_count > obound) *overflow = 1;
|
||||
|
||||
#if defined(LMP_SIMD_COMPILER)
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
int vlmin = lmin, vlmax = lmax, vgmin = gmin, vgmax = gmax;
|
||||
#if __INTEL_COMPILER+0 > 1499
|
||||
#pragma vector aligned
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
int vlmin = lmin, vlmax = lmax, vgmin = gmin, vgmax = gmax;
|
||||
#if __INTEL_COMPILER+0 > 1499
|
||||
#pragma vector aligned
|
||||
#pragma simd reduction(max:vlmax,vgmax) reduction(min:vlmin, vgmin)
|
||||
#endif
|
||||
#else
|
||||
#pragma vector aligned
|
||||
#endif
|
||||
#else
|
||||
#pragma vector aligned
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
#endif
|
||||
#endif
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
int j = neighptr[u];
|
||||
const flt_t delx = xtmp - x[j].x;
|
||||
const flt_t dely = ytmp - x[j].y;
|
||||
const flt_t delz = ztmp - x[j].z;
|
||||
const int jtype = x[j].w;
|
||||
const int jtype = x[j].w;
|
||||
const flt_t rsq = delx * delx + dely * dely + delz * delz;
|
||||
if (rsq > cutneighsq[ioffset + jtype])
|
||||
neighptr[u] = e_nall;
|
||||
else {
|
||||
if (need_ic) {
|
||||
int no_special;
|
||||
ominimum_image_check(no_special, delx, dely, delz);
|
||||
if (no_special)
|
||||
neighptr[u] = -j - 1;
|
||||
}
|
||||
if (rsq > cutneighsq[ioffset + jtype])
|
||||
neighptr[u] = e_nall;
|
||||
else {
|
||||
if (need_ic) {
|
||||
int no_special;
|
||||
ominimum_image_check(no_special, delx, dely, delz);
|
||||
if (no_special)
|
||||
neighptr[u] = -j - 1;
|
||||
}
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j < nlocal) {
|
||||
if (j < vlmin) vlmin = j;
|
||||
|
@ -415,40 +415,40 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
if (j > vgmax) vgmax = j;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
lmin = MIN(lmin,vlmin);
|
||||
gmin = MIN(gmin,vgmin);
|
||||
lmax = MAX(lmax,vlmax);
|
||||
gmax = MAX(gmax,vgmax);
|
||||
lmin = MIN(lmin,vlmin);
|
||||
gmin = MIN(gmin,vgmin);
|
||||
lmax = MAX(lmax,vlmax);
|
||||
gmax = MAX(gmax,vgmax);
|
||||
#endif
|
||||
|
||||
int n = lane, n2 = pack_offset;
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
const int j = neighptr[u];
|
||||
int pj = j;
|
||||
if (pj < e_nall) {
|
||||
if (need_ic)
|
||||
if (pj < 0) pj = -pj - 1;
|
||||
for (int u = pack_offset; u < raw_count; u++) {
|
||||
const int j = neighptr[u];
|
||||
int pj = j;
|
||||
if (pj < e_nall) {
|
||||
if (need_ic)
|
||||
if (pj < 0) pj = -pj - 1;
|
||||
|
||||
if (pj < nlocal) {
|
||||
neighptr[n] = j;
|
||||
n += swidth;
|
||||
} else
|
||||
neighptr[n2++] = j;
|
||||
}
|
||||
}
|
||||
int ns = (n - lane) / swidth;
|
||||
for (int u = pack_offset; u < n2; u++) {
|
||||
neighptr[n] = neighptr[u];
|
||||
n += swidth;
|
||||
}
|
||||
if (pj < nlocal) {
|
||||
neighptr[n] = j;
|
||||
n += swidth;
|
||||
} else
|
||||
neighptr[n2++] = j;
|
||||
}
|
||||
}
|
||||
int ns = (n - lane) / swidth;
|
||||
for (int u = pack_offset; u < n2; u++) {
|
||||
neighptr[n] = neighptr[u];
|
||||
n += swidth;
|
||||
}
|
||||
|
||||
ilist[i] = i;
|
||||
cnumneigh[i] = ct + lane;
|
||||
ns += n2 - pack_offset;
|
||||
#ifndef OUTER_CHUNK
|
||||
ns += n2 - pack_offset;
|
||||
#ifndef OUTER_CHUNK
|
||||
int edge = (ns % pad_width);
|
||||
if (edge) {
|
||||
const int pad_end = ns + (pad_width - edge);
|
||||
|
@ -458,41 +458,41 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
for ( ; ns < pad_end; ns++)
|
||||
neighptr[ns] = e_nall;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
numneigh[i] = ns;
|
||||
|
||||
#ifdef OUTER_CHUNK
|
||||
if (ns > max_chunk) max_chunk = ns;
|
||||
lane++;
|
||||
if (lane == swidth) {
|
||||
ct += max_chunk * swidth;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
int edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
max_chunk = 0;
|
||||
pack_offset = maxnbors * swidth;
|
||||
lane = 0;
|
||||
if (ct + obound > list_size) {
|
||||
#ifdef OUTER_CHUNK
|
||||
if (ns > max_chunk) max_chunk = ns;
|
||||
lane++;
|
||||
if (lane == swidth) {
|
||||
ct += max_chunk * swidth;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
int edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
max_chunk = 0;
|
||||
pack_offset = maxnbors * swidth;
|
||||
lane = 0;
|
||||
if (ct + obound > list_size) {
|
||||
if (i < ito - 1) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
ct += ns;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
if (ct + obound > list_size) {
|
||||
if (i < ito - 1) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#else
|
||||
ct += ns;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
if (ct + obound > list_size) {
|
||||
if (i < ito - 1) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
if (*overflow == 1)
|
||||
|
@ -505,25 +505,25 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
#pragma omp critical
|
||||
#endif
|
||||
{
|
||||
if (lmin < overflow[LMP_LOCAL_MIN]) overflow[LMP_LOCAL_MIN] = lmin;
|
||||
if (lmax > overflow[LMP_LOCAL_MAX]) overflow[LMP_LOCAL_MAX] = lmax;
|
||||
if (gmin < overflow[LMP_GHOST_MIN]) overflow[LMP_GHOST_MIN] = gmin;
|
||||
if (gmax > overflow[LMP_GHOST_MAX]) overflow[LMP_GHOST_MAX] = gmax;
|
||||
if (lmin < overflow[LMP_LOCAL_MIN]) overflow[LMP_LOCAL_MIN] = lmin;
|
||||
if (lmax > overflow[LMP_LOCAL_MAX]) overflow[LMP_LOCAL_MAX] = lmax;
|
||||
if (gmin < overflow[LMP_GHOST_MIN]) overflow[LMP_GHOST_MIN] = gmin;
|
||||
if (gmax > overflow[LMP_GHOST_MAX]) overflow[LMP_GHOST_MAX] = gmax;
|
||||
}
|
||||
#pragma omp barrier
|
||||
#pragma omp barrier
|
||||
}
|
||||
|
||||
int ghost_offset = 0, nall_offset = e_nall;
|
||||
if (separate_buffers) {
|
||||
int nghost = overflow[LMP_GHOST_MAX] + 1 - overflow[LMP_GHOST_MIN];
|
||||
if (nghost < 0) nghost = 0;
|
||||
if (offload) {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - overflow[LMP_LOCAL_MAX] - 1;
|
||||
nall_offset = overflow[LMP_LOCAL_MAX] + 1 + nghost;
|
||||
} else {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - nlocal;
|
||||
nall_offset = nlocal + nghost;
|
||||
}
|
||||
int nghost = overflow[LMP_GHOST_MAX] + 1 - overflow[LMP_GHOST_MIN];
|
||||
if (nghost < 0) nghost = 0;
|
||||
if (offload) {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - overflow[LMP_LOCAL_MAX] - 1;
|
||||
nall_offset = overflow[LMP_LOCAL_MAX] + 1 + nghost;
|
||||
} else {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - nlocal;
|
||||
nall_offset = nlocal + nghost;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -531,49 +531,49 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
for (int i = ifrom; i < ito; ++i) {
|
||||
int * _noalias jlist = firstneigh + cnumneigh[i];
|
||||
const int jnum = numneigh[i];
|
||||
#ifndef OUTER_CHUNK
|
||||
#ifndef OUTER_CHUNK
|
||||
#if defined(LMP_SIMD_COMPILER)
|
||||
#pragma vector aligned
|
||||
#pragma vector aligned
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = 0; jj < jnum; jj++) {
|
||||
#else
|
||||
const int trip = jnum * swidth;
|
||||
#else
|
||||
const int trip = jnum * swidth;
|
||||
for (int jj = 0; jj < trip; jj+= swidth) {
|
||||
#endif
|
||||
#endif
|
||||
const int j = jlist[jj];
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
} else
|
||||
ofind_special(which, special, nspecial, i, tag[j]);
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j >= nlocal) {
|
||||
if (j == e_nall)
|
||||
jlist[jj] = nall_offset;
|
||||
else if (which)
|
||||
jlist[jj] = (j-ghost_offset) ^ (which << SBBITS);
|
||||
else jlist[jj]-=ghost_offset;
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j >= nlocal) {
|
||||
if (j == e_nall)
|
||||
jlist[jj] = nall_offset;
|
||||
else if (which)
|
||||
jlist[jj] = (j-ghost_offset) ^ (which << SBBITS);
|
||||
else jlist[jj]-=ghost_offset;
|
||||
} else
|
||||
#endif
|
||||
#endif
|
||||
if (which) jlist[jj] = j ^ (which << SBBITS);
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
else if (separate_buffers) {
|
||||
for (int i = ifrom; i < ito; ++i) {
|
||||
for (int i = ifrom; i < ito; ++i) {
|
||||
int * _noalias jlist = firstneigh + cnumneigh[i];
|
||||
const int jnum = numneigh[i];
|
||||
int jj = 0;
|
||||
for (jj = 0; jj < jnum; jj++)
|
||||
if (jlist[jj] >= nlocal) break;
|
||||
while (jj < jnum) {
|
||||
if (jlist[jj] == e_nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
jj++;
|
||||
}
|
||||
}
|
||||
int jj = 0;
|
||||
for (jj = 0; jj < jnum; jj++)
|
||||
if (jlist[jj] >= nlocal) break;
|
||||
while (jj < jnum) {
|
||||
if (jlist[jj] == e_nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
jj++;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
} // end omp
|
||||
|
@ -597,9 +597,9 @@ hbni(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
_fix->start_watch(TIME_PACK);
|
||||
_fix->set_neighbor_host_sizes();
|
||||
buffers->pack_sep_from_single(_fix->host_min_local(),
|
||||
_fix->host_used_local(),
|
||||
_fix->host_min_ghost(),
|
||||
_fix->host_used_ghost());
|
||||
_fix->host_used_local(),
|
||||
_fix->host_min_ghost(),
|
||||
_fix->host_used_ghost());
|
||||
_fix->stop_watch(TIME_PACK);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -37,8 +37,8 @@ class NPairHalfBinNewtonIntel : public NPairIntel {
|
|||
template <class flt_t, class acc_t>
|
||||
void hbni(NeighList *, IntelBuffers<flt_t,acc_t> *);
|
||||
template <class flt_t, class acc_t, int, int>
|
||||
void hbni(const int, NeighList *, IntelBuffers<flt_t,acc_t> *, const int,
|
||||
const int, const int offload_end = 0);
|
||||
void hbni(const int, NeighList *, IntelBuffers<flt_t,acc_t> *, const int,
|
||||
const int, const int offload_end = 0);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -26,7 +26,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NPairHalfBinNewtonTriIntel::NPairHalfBinNewtonTriIntel(LAMMPS *lmp) :
|
||||
NPairHalfBinNewtonTriIntel::NPairHalfBinNewtonTriIntel(LAMMPS *lmp) :
|
||||
NPairIntel(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
@ -75,7 +75,7 @@ hbnti(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
|
|||
int need_ic = 0;
|
||||
if (atom->molecular)
|
||||
dminimum_image_check(need_ic, neighbor->cutneighmax, neighbor->cutneighmax,
|
||||
neighbor->cutneighmax);
|
||||
neighbor->cutneighmax);
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (need_ic) {
|
||||
|
@ -171,7 +171,7 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
overflow = _fix->get_off_overflow_flag();
|
||||
_fix->stop_watch(TIME_HOST_NEIGHBOR);
|
||||
_fix->start_watch(TIME_OFFLOAD_LATENCY);
|
||||
} else
|
||||
} else
|
||||
#endif
|
||||
{
|
||||
tnum = comm->nthreads;
|
||||
|
@ -279,20 +279,20 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
|
||||
const int ibin = atombin[i];
|
||||
|
||||
int raw_count = maxnbors;
|
||||
int raw_count = maxnbors;
|
||||
for (int k = 0; k < nstencilp; k++) {
|
||||
const int bstart = binhead[ibin + binstart[k]];
|
||||
const int bend = binhead[ibin + binend[k]];
|
||||
for (int jj = bstart; jj < bend; jj++) {
|
||||
const int j = binpacked[jj];
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (offload_noghost) {
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (offload_noghost) {
|
||||
if (j < nlocal) {
|
||||
if (i < offload_end) continue;
|
||||
} else if (offload) continue;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (x[j].z < ztmp) continue;
|
||||
if (x[j].z == ztmp) {
|
||||
|
@ -305,45 +305,45 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
|
||||
#ifndef _LMP_INTEL_OFFLOAD
|
||||
if (exclude) {
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
}
|
||||
#endif
|
||||
const int jtype = x[j].w;
|
||||
if (exclusion(i,j,itype,jtype,mask,molecule)) continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
if (raw_count > obound)
|
||||
*overflow = 1;
|
||||
neighptr[raw_count++] = j;
|
||||
}
|
||||
}
|
||||
if (raw_count > obound)
|
||||
*overflow = 1;
|
||||
|
||||
#if defined(LMP_SIMD_COMPILER)
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
int vlmin = lmin, vlmax = lmax, vgmin = gmin, vgmax = gmax;
|
||||
#if __INTEL_COMPILER+0 > 1499
|
||||
#pragma vector aligned
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
int vlmin = lmin, vlmax = lmax, vgmin = gmin, vgmax = gmax;
|
||||
#if __INTEL_COMPILER+0 > 1499
|
||||
#pragma vector aligned
|
||||
#pragma simd reduction(max:vlmax,vgmax) reduction(min:vlmin, vgmin)
|
||||
#endif
|
||||
#else
|
||||
#pragma vector aligned
|
||||
#endif
|
||||
#else
|
||||
#pragma vector aligned
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int u = maxnbors; u < raw_count; u++) {
|
||||
#endif
|
||||
#endif
|
||||
for (int u = maxnbors; u < raw_count; u++) {
|
||||
int j = neighptr[u];
|
||||
const flt_t delx = xtmp - x[j].x;
|
||||
const flt_t dely = ytmp - x[j].y;
|
||||
const flt_t delz = ztmp - x[j].z;
|
||||
const int jtype = x[j].w;
|
||||
const int jtype = x[j].w;
|
||||
const flt_t rsq = delx * delx + dely * dely + delz * delz;
|
||||
if (rsq > cutneighsq[ioffset + jtype])
|
||||
neighptr[u] = e_nall;
|
||||
else {
|
||||
if (rsq > cutneighsq[ioffset + jtype])
|
||||
neighptr[u] = e_nall;
|
||||
else {
|
||||
if (need_ic) {
|
||||
int no_special;
|
||||
ominimum_image_check(no_special, delx, dely, delz);
|
||||
if (no_special)
|
||||
neighptr[u] = -j - 1;
|
||||
}
|
||||
int no_special;
|
||||
ominimum_image_check(no_special, delx, dely, delz);
|
||||
if (no_special)
|
||||
neighptr[u] = -j - 1;
|
||||
}
|
||||
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j < nlocal) {
|
||||
|
@ -358,26 +358,26 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
}
|
||||
|
||||
int n = 0, n2 = maxnbors;
|
||||
for (int u = maxnbors; u < raw_count; u++) {
|
||||
const int j = neighptr[u];
|
||||
int pj = j;
|
||||
if (pj < e_nall) {
|
||||
if (need_ic)
|
||||
if (pj < 0) pj = -pj - 1;
|
||||
for (int u = maxnbors; u < raw_count; u++) {
|
||||
const int j = neighptr[u];
|
||||
int pj = j;
|
||||
if (pj < e_nall) {
|
||||
if (need_ic)
|
||||
if (pj < 0) pj = -pj - 1;
|
||||
|
||||
if (pj < nlocal)
|
||||
neighptr[n++] = j;
|
||||
else
|
||||
neighptr[n2++] = j;
|
||||
}
|
||||
}
|
||||
int ns = n;
|
||||
for (int u = maxnbors; u < n2; u++)
|
||||
neighptr[n++] = neighptr[u];
|
||||
if (pj < nlocal)
|
||||
neighptr[n++] = j;
|
||||
else
|
||||
neighptr[n2++] = j;
|
||||
}
|
||||
}
|
||||
int ns = n;
|
||||
for (int u = maxnbors; u < n2; u++)
|
||||
neighptr[n++] = neighptr[u];
|
||||
|
||||
ilist[i] = i;
|
||||
cnumneigh[i] = ct;
|
||||
ns += n2 - maxnbors;
|
||||
ns += n2 - maxnbors;
|
||||
|
||||
int edge = (ns % pad_width);
|
||||
if (edge) {
|
||||
|
@ -390,17 +390,17 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
}
|
||||
numneigh[i] = ns;
|
||||
|
||||
ct += ns;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
if (ct + obound > list_size) {
|
||||
if (i < ito - 1) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
}
|
||||
}
|
||||
ct += ns;
|
||||
const int alignb = (INTEL_DATA_ALIGN / sizeof(int));
|
||||
edge = (ct % alignb);
|
||||
if (edge) ct += alignb - edge;
|
||||
neighptr = firstneigh + ct;
|
||||
if (ct + obound > list_size) {
|
||||
if (i < ito - 1) {
|
||||
*overflow = 1;
|
||||
ct = (ifrom + tid * 2) * maxnbors;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (*overflow == 1)
|
||||
|
@ -428,7 +428,7 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
if (offload) {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - overflow[LMP_LOCAL_MAX] - 1;
|
||||
nall_offset = overflow[LMP_LOCAL_MAX] + 1 + nghost;
|
||||
} else {
|
||||
} else {
|
||||
ghost_offset = overflow[LMP_GHOST_MIN] - nlocal;
|
||||
nall_offset = nlocal + nghost;
|
||||
}
|
||||
|
@ -440,43 +440,43 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
int * _noalias jlist = firstneigh + cnumneigh[i];
|
||||
const int jnum = numneigh[i];
|
||||
#if defined(LMP_SIMD_COMPILER)
|
||||
#pragma vector aligned
|
||||
#pragma vector aligned
|
||||
#pragma simd
|
||||
#endif
|
||||
#endif
|
||||
for (int jj = 0; jj < jnum; jj++) {
|
||||
const int j = jlist[jj];
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
} else
|
||||
if (need_ic && j < 0) {
|
||||
which = 0;
|
||||
jlist[jj] = -j - 1;
|
||||
} else
|
||||
ofind_special(which, special, nspecial, i, tag[j]);
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
if (j >= nlocal) {
|
||||
if (j == e_nall)
|
||||
jlist[jj] = nall_offset;
|
||||
else if (which)
|
||||
jlist[jj] = (j-ghost_offset) ^ (which << SBBITS);
|
||||
else jlist[jj]-=ghost_offset;
|
||||
if (j >= nlocal) {
|
||||
if (j == e_nall)
|
||||
jlist[jj] = nall_offset;
|
||||
else if (which)
|
||||
jlist[jj] = (j-ghost_offset) ^ (which << SBBITS);
|
||||
else jlist[jj]-=ghost_offset;
|
||||
} else
|
||||
#endif
|
||||
if (which) jlist[jj] = j ^ (which << SBBITS);
|
||||
if (which) jlist[jj] = j ^ (which << SBBITS);
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef _LMP_INTEL_OFFLOAD
|
||||
else if (separate_buffers) {
|
||||
for (int i = ifrom; i < ito; ++i) {
|
||||
for (int i = ifrom; i < ito; ++i) {
|
||||
int * _noalias jlist = firstneigh + cnumneigh[i];
|
||||
const int jnum = numneigh[i];
|
||||
int jj = 0;
|
||||
for (jj = 0; jj < jnum; jj++)
|
||||
if (jlist[jj] >= nlocal) break;
|
||||
while (jj < jnum) {
|
||||
if (jlist[jj] == e_nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
jj++;
|
||||
}
|
||||
}
|
||||
int jj = 0;
|
||||
for (jj = 0; jj < jnum; jj++)
|
||||
if (jlist[jj] >= nlocal) break;
|
||||
while (jj < jnum) {
|
||||
if (jlist[jj] == e_nall) jlist[jj] = nall_offset;
|
||||
else jlist[jj] -= ghost_offset;
|
||||
jj++;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
} // end omp
|
||||
|
@ -500,9 +500,9 @@ hbnti(const int offload, NeighList *list, IntelBuffers<flt_t,acc_t> *buffers,
|
|||
_fix->start_watch(TIME_PACK);
|
||||
_fix->set_neighbor_host_sizes();
|
||||
buffers->pack_sep_from_single(_fix->host_min_local(),
|
||||
_fix->host_used_local(),
|
||||
_fix->host_min_ghost(),
|
||||
_fix->host_used_ghost());
|
||||
_fix->host_used_local(),
|
||||
_fix->host_min_ghost(),
|
||||
_fix->host_used_ghost());
|
||||
_fix->stop_watch(TIME_PACK);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -38,7 +38,7 @@ class NPairHalfBinNewtonTriIntel : public NPairIntel {
|
|||
void hbnti(NeighList *, IntelBuffers<flt_t,acc_t> *);
|
||||
template <class flt_t, class acc_t, int, int>
|
||||
void hbnti(const int, NeighList *, IntelBuffers<flt_t,acc_t> *, const int,
|
||||
const int, const int offload_end = 0);
|
||||
const int, const int offload_end = 0);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -62,6 +62,6 @@ void NPairIntel::grow_stencil()
|
|||
const int maxstencil = ns->get_maxstencil();
|
||||
#pragma offload_transfer target(mic:_cop) \
|
||||
in(stencil:length(maxstencil) alloc_if(1) free_if(0))
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -123,7 +123,7 @@ void NPair::copy_bin_info()
|
|||
mbinxlo = nb->mbinxlo;
|
||||
mbinylo = nb->mbinylo;
|
||||
mbinzlo = nb->mbinzlo;
|
||||
|
||||
|
||||
bininvx = nb->bininvx;
|
||||
bininvy = nb->bininvy;
|
||||
bininvz = nb->bininvz;
|
||||
|
@ -183,15 +183,15 @@ int NPair::exclusion(int i, int j, int itype, int jtype,
|
|||
if (nex_mol) {
|
||||
for (m = 0; m < nex_mol; m++)
|
||||
|
||||
// intra-chain: exclude i-j pair if in same molecule
|
||||
// inter-chain: exclude i-j pair if in different molecules
|
||||
// intra-chain: exclude i-j pair if in same molecule
|
||||
// inter-chain: exclude i-j pair if in different molecules
|
||||
|
||||
if (ex_mol_intra[m]) {
|
||||
if (mask[i] & ex_mol_bit[m] && mask[j] & ex_mol_bit[m] &&
|
||||
molecule[i] == molecule[j]) return 1;
|
||||
molecule[i] == molecule[j]) return 1;
|
||||
} else {
|
||||
if (mask[i] & ex_mol_bit[m] && mask[j] & ex_mol_bit[m] &&
|
||||
molecule[i] != molecule[j]) return 1;
|
||||
if (mask[i] & ex_mol_bit[m] && mask[j] & ex_mol_bit[m] &&
|
||||
molecule[i] != molecule[j]) return 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -79,7 +79,7 @@ class NPair : protected Pointers {
|
|||
double bininvx,bininvy,bininvz;
|
||||
int *atom2bin,*bins;
|
||||
int *binhead;
|
||||
|
||||
|
||||
// data from NStencil class
|
||||
|
||||
int nstencil;
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NPairStyle(full/bin,
|
||||
NPairFullBin,
|
||||
NP_FULL | NP_BIN | NP_MOLONLY |
|
||||
NP_FULL | NP_BIN | NP_MOLONLY |
|
||||
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -16,7 +16,7 @@
|
|||
NPairStyle(full/bin/atomonly,
|
||||
NPairFullBinAtomonly,
|
||||
NP_FULL | NP_BIN | NP_ATOMONLY |
|
||||
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
|
||||
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NPairStyle(full/bin/ghost,
|
||||
NPairFullBinGhost,
|
||||
NP_FULL | NP_BIN | NP_GHOST | NP_NEWTON | NP_NEWTOFF |
|
||||
NP_FULL | NP_BIN | NP_GHOST | NP_NEWTON | NP_NEWTOFF |
|
||||
NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NPairStyle(full/nsq/ghost,
|
||||
NPairFullNsqGhost,
|
||||
NP_FULL | NP_NSQ | NP_GHOST | NP_NEWTON | NP_NEWTOFF |
|
||||
NP_FULL | NP_NSQ | NP_GHOST | NP_NEWTON | NP_NEWTOFF |
|
||||
NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -25,7 +25,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NPairHalfBinAtomonlyNewton::NPairHalfBinAtomonlyNewton(LAMMPS *lmp) :
|
||||
NPairHalfBinAtomonlyNewton::NPairHalfBinAtomonlyNewton(LAMMPS *lmp) :
|
||||
NPair(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
|
|
@ -25,7 +25,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NPairHalfRespaBinNewtonTri::NPairHalfRespaBinNewtonTri(LAMMPS *lmp) :
|
||||
NPairHalfRespaBinNewtonTri::NPairHalfRespaBinNewtonTri(LAMMPS *lmp) :
|
||||
NPair(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
|
|
@ -190,7 +190,7 @@ void NPairHalfSizeBinNewton::build(NeighList *list)
|
|||
nn += dnum;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
n++;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -27,7 +27,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NPairHalfSizeBinNewtonTri::NPairHalfSizeBinNewtonTri(LAMMPS *lmp) :
|
||||
NPairHalfSizeBinNewtonTri::NPairHalfSizeBinNewtonTri(LAMMPS *lmp) :
|
||||
NPair(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
|
|
@ -15,8 +15,8 @@
|
|||
|
||||
NPairStyle(skip/half/respa,
|
||||
NPairSkipRespa,
|
||||
NP_SKIP | NP_RESPA | NP_HALF | NP_FULL |
|
||||
NP_NSQ | NP_BIN | NP_MULTI |
|
||||
NP_SKIP | NP_RESPA | NP_HALF | NP_FULL |
|
||||
NP_NSQ | NP_BIN | NP_MULTI |
|
||||
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -32,7 +32,7 @@ NPairSkipSize::NPairSkipSize(LAMMPS *lmp) : NPair(lmp) {}
|
|||
/* ----------------------------------------------------------------------
|
||||
build skip list for subset of types from parent list
|
||||
iskip and ijskip flag which atom types and type pairs to skip
|
||||
if list requests it, preserve shear history via fix shear/history
|
||||
if list requests it, preserve shear history via fix shear/history
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
void NPairSkipSize::build(NeighList *list)
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NPairStyle(skip/half/size,
|
||||
NPairSkipSize,
|
||||
NP_SKIP | NP_SIZE | NP_HALF | NP_FULL | NP_NSQ | NP_BIN | NP_MULTI |
|
||||
NP_SKIP | NP_SIZE | NP_HALF | NP_FULL | NP_NSQ | NP_BIN | NP_MULTI |
|
||||
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -33,7 +33,7 @@ NPairSkipSizeOff2on::NPairSkipSizeOff2on(LAMMPS *lmp) : NPair(lmp) {}
|
|||
build skip list for subset of types from parent list
|
||||
iskip and ijskip flag which atom types and type pairs to skip
|
||||
parent non-skip list used newton off, this skip list is newton on
|
||||
if list requests it, preserve shear history via fix shear/history
|
||||
if list requests it, preserve shear history via fix shear/history
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
void NPairSkipSizeOff2on::build(NeighList *list)
|
||||
|
|
|
@ -15,8 +15,8 @@
|
|||
|
||||
NPairStyle(skip/size/off2on,
|
||||
NPairSkipSizeOff2on,
|
||||
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_HALF |
|
||||
NP_NSQ | NP_BIN | NP_MULTI |
|
||||
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_HALF |
|
||||
NP_NSQ | NP_BIN | NP_MULTI |
|
||||
NP_NEWTON | NP_NEWTOFF | NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -27,7 +27,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NPairSkipSizeOff2onOneside::NPairSkipSizeOff2onOneside(LAMMPS *lmp) :
|
||||
NPairSkipSizeOff2onOneside::NPairSkipSizeOff2onOneside(LAMMPS *lmp) :
|
||||
NPair(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
@ -35,7 +35,7 @@ NPairSkipSizeOff2onOneside::NPairSkipSizeOff2onOneside(LAMMPS *lmp) :
|
|||
iskip and ijskip flag which atom types and type pairs to skip
|
||||
parent non-skip list used newton off and was not onesided,
|
||||
this skip list is newton on and onesided
|
||||
if list requests it, preserve shear history via fix shear/history
|
||||
if list requests it, preserve shear history via fix shear/history
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
void NPairSkipSizeOff2onOneside::build(NeighList *list)
|
||||
|
|
|
@ -15,8 +15,8 @@
|
|||
|
||||
NPairStyle(skip/size/off2on/oneside,
|
||||
NPairSkipSizeOff2onOneside,
|
||||
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_ONESIDE | NP_HALF |
|
||||
NP_NSQ | NP_BIN | NP_MULTI | NP_NEWTON | NP_NEWTOFF |
|
||||
NP_SKIP | NP_SIZE | NP_OFF2ON | NP_ONESIDE | NP_HALF |
|
||||
NP_NSQ | NP_BIN | NP_MULTI | NP_NEWTON | NP_NEWTOFF |
|
||||
NP_ORTHO | NP_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -28,7 +28,7 @@ NStencilFullBin2d::NStencilFullBin2d(LAMMPS *lmp) : NStencil(lmp) {}
|
|||
void NStencilFullBin2d::create()
|
||||
{
|
||||
int i,j;
|
||||
|
||||
|
||||
nstencil = 0;
|
||||
|
||||
for (j = -sy; j <= sy; j++)
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NStencilStyle(full/bin/2d,
|
||||
NStencilFullBin2d,
|
||||
NS_FULL | NS_BIN | NS_2D |
|
||||
NS_FULL | NS_BIN | NS_2D |
|
||||
NS_NEWTON | NS_NEWTOFF | NS_ORTHO | NS_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NStencilStyle(full/bin/3d,
|
||||
NStencilFullBin3d,
|
||||
NS_FULL | NS_BIN | NS_3D |
|
||||
NS_FULL | NS_BIN | NS_3D |
|
||||
NS_NEWTON | NS_NEWTOFF | NS_ORTHO | NS_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NStencilStyle(full/ghost/bin/2d,
|
||||
NStencilFullGhostBin2d,
|
||||
NS_FULL | NS_GHOST | NS_BIN | NS_2D |
|
||||
NS_FULL | NS_GHOST | NS_BIN | NS_2D |
|
||||
NS_NEWTON | NS_NEWTOFF | NS_ORTHO | NS_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NStencilStyle(full/ghost/bin/3d,
|
||||
NStencilFullGhostBin3d,
|
||||
NS_FULL | NS_GHOST | NS_BIN | NS_3D |
|
||||
NS_FULL | NS_GHOST | NS_BIN | NS_3D |
|
||||
NS_NEWTON | NS_NEWTOFF | NS_ORTHO | NS_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NStencilStyle(full/multi/2d,
|
||||
NStencilFullMulti2d,
|
||||
NS_FULL | NS_MULTI | NS_2D |
|
||||
NS_FULL | NS_MULTI | NS_2D |
|
||||
NS_NEWTON | NS_NEWTOFF | NS_ORTHO | NS_TRI)
|
||||
|
||||
#else
|
||||
|
|
|
@ -19,7 +19,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NStencilHalfBin2dNewtoff::NStencilHalfBin2dNewtoff(LAMMPS *lmp) :
|
||||
NStencilHalfBin2dNewtoff::NStencilHalfBin2dNewtoff(LAMMPS *lmp) :
|
||||
NStencil(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
|
|
@ -19,7 +19,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NStencilHalfBin2dNewtonTri::NStencilHalfBin2dNewtonTri(LAMMPS *lmp) :
|
||||
NStencilHalfBin2dNewtonTri::NStencilHalfBin2dNewtonTri(LAMMPS *lmp) :
|
||||
NStencil(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
|
|
@ -19,7 +19,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NStencilHalfBin3dNewtoff::NStencilHalfBin3dNewtoff(LAMMPS *lmp) :
|
||||
NStencilHalfBin3dNewtoff::NStencilHalfBin3dNewtoff(LAMMPS *lmp) :
|
||||
NStencil(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
|
|
@ -19,7 +19,7 @@ using namespace LAMMPS_NS;
|
|||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
NStencilHalfBin3dNewtonTri::NStencilHalfBin3dNewtonTri(LAMMPS *lmp) :
|
||||
NStencilHalfBin3dNewtonTri::NStencilHalfBin3dNewtonTri(LAMMPS *lmp) :
|
||||
NStencil(lmp) {}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
NStencilStyle(half/ghost/bin/2d/newtoff,
|
||||
NStencilHalfGhostBin2dNewtoff,
|
||||
NS_HALF | NS_GHOST | NS_BIN | NS_2D |
|
||||
NS_HALF | NS_GHOST | NS_BIN | NS_2D |
|
||||
NS_NEWTOFF | NS_ORTHO | NS_TRI)
|
||||
|
||||
#else
|
||||
|
|
Loading…
Reference in New Issue