void NPairSkipSize::build(NeighList *list) { int i,j,ii,jj,n,itype,jnum,joriginal; int *neighptr,*jlist; int *type = atom->type; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int *ilist_skip = list->listskip->ilist; int *numneigh_skip = list->listskip->numneigh; int **firstneigh_skip = list->listskip->firstneigh; int inum_skip = list->listskip->inum; int *iskip = list->iskip; int **ijskip = list->ijskip; int inum = 0; ipage->reset(); // loop over atoms in other list // skip I atom entirely if iskip is set for type[I] // skip I,J pair if ijskip is set for type[I],type[J] for (ii = 0; ii < inum_skip; ii++) { i = ilist_skip[ii]; itype = type[i]; if (iskip[itype]) continue; n = 0; neighptr = ipage->vget(); // loop over parent non-skip size list jlist = firstneigh_skip[i]; jnum = numneigh_skip[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (ijskip[itype][type[j]]) continue; neighptr[n++] = joriginal; } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void NPairHalffullNewtoff::build(NeighList *list) { int i,j,ii,jj,n,jnum,joriginal; int *neighptr,*jlist; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int *ilist_full = list->listfull->ilist; int *numneigh_full = list->listfull->numneigh; int **firstneigh_full = list->listfull->firstneigh; int inum_full = list->listfull->inum; if (list->ghost) inum_full += list->listfull->gnum; int inum = 0; ipage->reset(); // loop over atoms in full list for (ii = 0; ii < inum_full; ii++) { n = 0; neighptr = ipage->vget(); // loop over parent full list i = ilist_full[ii]; jlist = firstneigh_full[i]; jnum = numneigh_full[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (j > i) neighptr[n++] = joriginal; } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; if (list->ghost) list->gnum = list->listfull->gnum; }
void NPairHalfSizeBinNewtoff::build(NeighList *list) { int i,j,k,m,n,nn,ibin,dnum,dnumbytes; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr,*touchptr; double *shearptr; int *npartner; tagint **partner; double **shearpartner; int **firsttouch; double **firstshear; MyPage<int> *ipage_touch; MyPage<double> *dpage_shear; NeighList *listhistory; double **x = atom->x; double *radius = atom->radius; tagint *tag = atom->tag; int *type = atom->type; int *mask = atom->mask; tagint *molecule = atom->molecule; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; FixShearHistory *fix_history = (FixShearHistory *) list->fix_history; if (fix_history) { fix_history->nlocal_neigh = nlocal; fix_history->nall_neigh = nlocal + atom->nghost; npartner = fix_history->npartner; partner = fix_history->partner; shearpartner = fix_history->shearpartner; listhistory = list->listhistory; firsttouch = listhistory->firstneigh; firstshear = listhistory->firstdouble; ipage_touch = listhistory->ipage; dpage_shear = listhistory->dpage; dnum = listhistory->dnum; dnumbytes = dnum * sizeof(double); } int inum = 0; ipage->reset(); if (fix_history) { ipage_touch->reset(); dpage_shear->reset(); } for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); if (fix_history) { nn = 0; touchptr = ipage_touch->vget(); shearptr = dpage_shear->vget(); } xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; ibin = atom2bin[i]; // loop over all atoms in surrounding bins in stencil including self // only store pair if i < j // stores own/own pairs only once // stores own/ghost pairs on both procs for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (j <= i) continue; if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = radi + radius[j]; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) { neighptr[n] = j; if (fix_history) { if (rsq < radsum*radsum) { for (m = 0; m < npartner[i]; m++) if (partner[i][m] == tag[j]) break; if (m < npartner[i]) { touchptr[n] = 1; memcpy(&shearptr[nn],&shearpartner[i][dnum*m],dnumbytes); nn += dnum; } else { touchptr[n] = 0; memcpy(&shearptr[nn],zeroes,dnumbytes); nn += dnum; } } else { touchptr[n] = 0; memcpy(&shearptr[nn],zeroes,dnumbytes); nn += dnum; } } n++; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (fix_history) { firsttouch[i] = touchptr; firstshear[i] = shearptr; ipage_touch->vgot(n); dpage_shear->vgot(nn); } } list->inum = inum; }
void NPairHalfSizeNsqNewton::build(NeighList *list) { int i,j,m,n,nn,itag,jtag,bitmask,dnum,dnumbytes; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr,*touchptr; double *shearptr; int *npartner; tagint **partner; double **shearpartner; int **firsttouch; double **firstshear; MyPage<int> *ipage_touch; MyPage<double> *dpage_shear; NeighList *listgranhistory; double **x = atom->x; double *radius = atom->radius; tagint *tag = atom->tag; int *type = atom->type; int *mask = atom->mask; tagint *molecule = atom->molecule; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; if (includegroup) { nlocal = atom->nfirst; bitmask = group->bitmask[includegroup]; } int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; FixShearHistory *fix_history = list->fix_history; if (fix_history) { fix_history->nlocal_neigh = nlocal; fix_history->nall_neigh = nall; npartner = fix_history->npartner; partner = fix_history->partner; shearpartner = fix_history->shearpartner; listgranhistory = list->listgranhistory; firsttouch = listgranhistory->firstneigh; firstshear = listgranhistory->firstdouble; ipage_touch = listgranhistory->ipage; dpage_shear = listgranhistory->dpage; dnum = listgranhistory->dnum; dnumbytes = dnum * sizeof(double); } int inum = 0; ipage->reset(); if (fix_history) { ipage_touch->reset(); dpage_shear->reset(); } for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); if (fix_history) { nn = 0; touchptr = ipage_touch->vget(); shearptr = dpage_shear->vget(); } itag = tag[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; // loop over remaining atoms, owned and ghost for (j = i+1; j < nall; j++) { if (includegroup && !(mask[j] & bitmask)) continue; if (j >= nlocal) { jtag = tag[j]; if (itag > jtag) { if ((itag+jtag) % 2 == 0) continue; } else if (itag < jtag) { if ((itag+jtag) % 2 == 1) continue; } else { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp && x[j][0] < xtmp) continue; } } } if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = radi + radius[j]; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) { neighptr[n] = j; if (fix_history) { if (rsq < radsum*radsum) { for (m = 0; m < npartner[i]; m++) if (partner[i][m] == tag[j]) break; if (m < npartner[i]) { touchptr[n] = 1; memcpy(&shearptr[nn],&shearpartner[i][dnum*m],dnumbytes); nn += dnum; } else { touchptr[n] = 0; memcpy(&shearptr[nn],zeroes,dnumbytes); nn += dnum; } } else { touchptr[n] = 0; memcpy(&shearptr[nn],zeroes,dnumbytes); nn += dnum; } } n++; } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (fix_history) { firsttouch[i] = touchptr; firstshear[i] = shearptr; ipage_touch->vgot(n); dpage_shear->vgot(nn); } } list->inum = inum; }
void Neighbor::granular_bin_newton(NeighList *list) { int i,j,k,n,ibin; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors double **x = atom->x; double *radius = atom->radius; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int *stencil = list->stencil; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; // loop over rest of atoms in i's bin, ghosts are at end of linked list // 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 and to the right" of i for (j = bins[i]; j >= 0; j = bins[j]) { if (j >= nlocal) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp && x[j][0] < xtmp) continue; } } if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = (radi + radius[j]) * contactDistanceFactor; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) neighptr[n++] = j; } // loop over all atoms in other bins in stencil, store every pair ibin = coord2bin(x[i]); for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = radi + radius[j]; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) neighptr[n++] = j; } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void Neighbor::granular_bin_no_newton(NeighList *list) { int i,j,k,m,n,nn,ibin,d; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr,*touchptr; double *shearptr; NeighList *listgranhistory; int *npartner,**partner; double **contacthistory; int **firsttouch; double **firstshear; MyPage<int> *ipage_touch; MyPage<double> *dpage_shear; int dnum; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors double **x = atom->x; double *radius = atom->radius; int *tag = atom->tag; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int *stencil = list->stencil; MyPage<int> *ipage = list->ipage; FixContactHistory *fix_history = list->fix_history; if (fix_history) { npartner = fix_history->npartner_; partner = fix_history->partner_; contacthistory = fix_history->contacthistory_; listgranhistory = list->listgranhistory; firsttouch = listgranhistory->firstneigh; firstshear = listgranhistory->firstdouble; ipage_touch = listgranhistory->ipage; dpage_shear = listgranhistory->dpage; dnum = listgranhistory->dnum; } int inum = 0; ipage->reset(); if (fix_history) { ipage_touch->reset(); dpage_shear->reset(); } for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); if (fix_history) { nn = 0; touchptr = ipage_touch->vget(); shearptr = dpage_shear->vget(); } xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; ibin = coord2bin(x[i]); // loop over all atoms in surrounding bins in stencil including self // only store pair if i < j // stores own/own pairs only once // stores own/ghost pairs on both procs for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (j <= i) continue; if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = (radi + radius[j]) * contactDistanceFactor; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) { neighptr[n] = j; if (fix_history) { if (rsq < radsum*radsum) { for (m = 0; m < npartner[i]; m++) if (partner[i][m] == tag[j]) break; if (m < npartner[i]) { touchptr[n] = 1; for (d = 0; d < dnum; d++) { shearptr[nn++] = contacthistory[i][m*dnum+d]; } } else { touchptr[n] = 0; for (d = 0; d < dnum; d++) { shearptr[nn++] = 0.0; } } } else { touchptr[n] = 0; for (d = 0; d < dnum; d++) { shearptr[nn++] = 0.0; } } } n++; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (fix_history) { firsttouch[i] = touchptr; firstshear[i] = shearptr; ipage_touch->vgot(n); dpage_shear->vgot(nn); } } list->inum = inum; }
void Neighbor::half_multi_no_newton(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which,ns,imol,iatom,moltemplate; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*s; double *cutsq,*distsq; // bin local & ghost atoms bin_atoms(); double **x = atom->x; int *type = atom->type; int *mask = atom->mask; tagint *tag = atom->tag; tagint *molecule = atom->molecule; tagint **special = atom->special; int **nspecial = atom->nspecial; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int *molindex = atom->molindex; int *molatom = atom->molatom; Molecule **onemols = atom->avec->onemols; int molecular = atom->molecular; if (molecular == 2) moltemplate = 1; else moltemplate = 0; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int *nstencil_multi = list->nstencil_multi; int **stencil_multi = list->stencil_multi; double **distsq_multi = list->distsq_multi; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); // loop over each atom, storing neighbors for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; if (moltemplate) { imol = molindex[i]; iatom = molatom[i]; tagprev = tag[i] - iatom - 1; } // loop over all atoms in other bins in stencil including self // only store pair if i < j // skip if i,j neighbor cutoff is less than bin distance // stores own/own pairs only once // stores own/ghost pairs on both procs ibin = coord2bin(x[i]); s = stencil_multi[itype]; distsq = distsq_multi[itype]; cutsq = cutneighsq[itype]; ns = nstencil_multi[itype]; for (k = 0; k < ns; k++) { for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) { if (j <= i) continue; jtype = type[j]; if (cutsq[jtype] < distsq[k]) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void Neighbor::half_nsq_no_newton(NeighList *list) { int i,j,n,itype,jtype,which,bitmask; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr; int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; int molecular = atom->molecular; if (includegroup) { nlocal = atom->nfirst; bitmask = group->bitmask[includegroup]; } int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); // loop over owned atoms, storing neighbors for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over remaining atoms, owned and ghost // only store pair if i < j for (j = i+1; j < nall; j++) { if (includegroup && !(mask[j] & bitmask)) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void Neighbor::half_multi_newton(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which,ns; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*s; double *cutsq,*distsq; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int molecular = atom->molecular; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int *nstencil_multi = list->nstencil_multi; int **stencil_multi = list->stencil_multi; double **distsq_multi = list->distsq_multi; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over rest of atoms in i's bin, ghosts are at end of linked list // 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 and to the right" of i for (j = bins[i]; j >= 0; j = bins[j]) { if (j >= nlocal) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp && x[j][0] < xtmp) continue; } } jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } // loop over all atoms in other bins in stencil, store every pair // skip if i,j neighbor cutoff is less than bin distance ibin = coord2bin(x[i]); s = stencil_multi[itype]; distsq = distsq_multi[itype]; cutsq = cutneighsq[itype]; ns = nstencil_multi[itype]; for (k = 0; k < ns; k++) { for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) { jtype = type[j]; if (cutsq[jtype] < distsq[k]) continue; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void Neighbor::respa_nsq_no_newton(NeighList *list) { int i,j,n,itype,jtype,n_inner,n_middle=0,bitmask=0; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*neighptr_inner,*neighptr_middle = NULL; // loop over each atom, storing neighbors int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; int molecular = atom->molecular; if (includegroup) { nlocal = atom->nfirst; bitmask = group->bitmask[includegroup]; } int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; NeighList *listinner = list->listinner; int *ilist_inner = listinner->ilist; int *numneigh_inner = listinner->numneigh; int **firstneigh_inner = listinner->firstneigh; MyPage<int> *ipage_inner = listinner->ipage; NeighList *listmiddle; int *ilist_middle,*numneigh_middle,**firstneigh_middle; MyPage<int> *ipage_middle = NULL; int respamiddle = list->respamiddle; if (respamiddle) { listmiddle = list->listmiddle; ilist_middle = listmiddle->ilist; numneigh_middle = listmiddle->numneigh; firstneigh_middle = listmiddle->firstneigh; ipage_middle = listmiddle->ipage; } int inum = 0; int which = 0; int minchange = 0; ipage->reset(); ipage_inner->reset(); if (respamiddle) ipage_middle->reset(); for (i = 0; i < nlocal; i++) { n = n_inner = 0; neighptr = ipage->vget(); neighptr_inner = ipage_inner->vget(); if (respamiddle) { n_middle = 0; neighptr_middle = ipage_middle->vget(); } itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over remaining atoms, owned and ghost for (j = i+1; j < nall; j++) { if (includegroup && !(mask[j] & bitmask)) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if ((minchange = domain->minimum_image_check(delx,dely,delz))) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; if (rsq < cut_inner_sq) { if (which == 0) neighptr_inner[n_inner++] = j; else if (minchange) neighptr_inner[n_inner++] = j; else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS); } if (respamiddle && rsq < cut_middle_sq && rsq > cut_middle_inside_sq) { if (which == 0) neighptr_middle[n_middle++] = j; else if (minchange) neighptr_middle[n_middle++] = j; else if (which > 0) neighptr_middle[n_middle++] = j ^ (which << SBBITS); } } } ilist[inum] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); ilist_inner[inum] = i; firstneigh_inner[i] = neighptr_inner; numneigh_inner[i] = n_inner; ipage_inner->vgot(n_inner); if (ipage_inner->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (respamiddle) { ilist_middle[inum] = i; firstneigh_middle[i] = neighptr_middle; numneigh_middle[i] = n_middle; ipage_middle->vgot(n_middle); if (ipage_middle->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } inum++; } list->inum = inum; listinner->inum = inum; if (respamiddle) listmiddle->inum = inum; }
void Neighbor::respa_bin_newton(NeighList *list) { int i,j,k,n,itype,jtype,ibin,n_inner,n_middle=0; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*neighptr_inner,*neighptr_middle = NULL; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int molecular = atom->molecular; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int *stencil = list->stencil; MyPage<int> *ipage = list->ipage; NeighList *listinner = list->listinner; int *ilist_inner = listinner->ilist; int *numneigh_inner = listinner->numneigh; int **firstneigh_inner = listinner->firstneigh; MyPage<int> *ipage_inner = listinner->ipage; NeighList *listmiddle; int *ilist_middle = NULL,*numneigh_middle = NULL,**firstneigh_middle = NULL; MyPage<int> *ipage_middle = NULL; int respamiddle = list->respamiddle; if (respamiddle) { listmiddle = list->listmiddle; ilist_middle = listmiddle->ilist; numneigh_middle = listmiddle->numneigh; firstneigh_middle = listmiddle->firstneigh; ipage_middle = listmiddle->ipage; } int inum = 0; int which = 0; int minchange = 0; ipage->reset(); ipage_inner->reset(); if (respamiddle) ipage_middle->reset(); for (i = 0; i < nlocal; i++) { n = n_inner = 0; neighptr = ipage->vget(); neighptr_inner = ipage_inner->vget(); if (respamiddle) { n_middle = 0; neighptr_middle = ipage_middle->vget(); } itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over rest of atoms in i's bin, ghosts are at end of linked list // 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 and to the right" of i for (j = bins[i]; j >= 0; j = bins[j]) { if (j >= nlocal) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp && x[j][0] < xtmp) continue; } } jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if ((minchange = domain->minimum_image_check(delx,dely,delz))) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; if (rsq < cut_inner_sq) { if (which == 0) neighptr_inner[n_inner++] = j; else if (minchange) neighptr_inner[n_inner++] = j; else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS); } if (respamiddle && rsq < cut_middle_sq && rsq > cut_middle_inside_sq) { if (which == 0) neighptr_middle[n_middle++] = j; else if (minchange) neighptr_middle[n_middle++] = j; else if (which > 0) neighptr_middle[n_middle++] = j ^ (which << SBBITS); } } } // loop over all atoms in other bins in stencil, store every pair ibin = coord2bin(x[i]); for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if ((minchange = domain->minimum_image_check(delx,dely,delz))) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; if (rsq < cut_inner_sq) { if (which == 0) neighptr_inner[n_inner++] = j; else if (minchange) neighptr_inner[n_inner++] = j; else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS); } if (respamiddle && rsq < cut_middle_sq && rsq > cut_middle_inside_sq) { if (which == 0) neighptr_middle[n_middle++] = j; else if (minchange) neighptr_middle[n_middle++] = j; else if (which > 0) neighptr_middle[n_middle++] = j ^ (which << SBBITS); } } } } ilist[inum] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); ilist_inner[inum] = i; firstneigh_inner[i] = neighptr_inner; numneigh_inner[i] = n_inner; ipage_inner->vgot(n_inner); if (ipage_inner->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (respamiddle) { ilist_middle[inum] = i; firstneigh_middle[i] = neighptr_middle; numneigh_middle[i] = n_middle; ipage_middle->vgot(n_middle); if (ipage_middle->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } inum++; } list->inum = inum; listinner->inum = inum; if (respamiddle) listmiddle->inum = inum; }
void NPairHalffullNewton::build(NeighList *list) { int i,j,ii,jj,n,jnum,joriginal; int *neighptr,*jlist; double xtmp,ytmp,ztmp; double **x = atom->x; int nlocal = atom->nlocal; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int *ilist_full = list->listfull->ilist; int *numneigh_full = list->listfull->numneigh; int **firstneigh_full = list->listfull->firstneigh; int inum_full = list->listfull->inum; int inum = 0; ipage->reset(); // loop over parent full list for (ii = 0; ii < inum_full; ii++) { n = 0; neighptr = ipage->vget(); i = ilist_full[ii]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over full neighbor list jlist = firstneigh_full[i]; jnum = numneigh_full[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (j < nlocal) { if (i > j) continue; } else { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp && x[j][0] < xtmp) continue; } } neighptr[n++] = joriginal; } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void NPairHalfRespaBinNewtoff::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,n_inner,n_middle,imol,iatom,moltemplate; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*neighptr_inner,*neighptr_middle; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; tagint *tag = atom->tag; tagint *molecule = atom->molecule; tagint **special = atom->special; int **nspecial = atom->nspecial; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int *molindex = atom->molindex; int *molatom = atom->molatom; Molecule **onemols = atom->avec->onemols; if (molecular == 2) moltemplate = 1; else moltemplate = 0; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; NeighList *listinner = list->listinner; int *ilist_inner = listinner->ilist; int *numneigh_inner = listinner->numneigh; int **firstneigh_inner = listinner->firstneigh; MyPage<int> *ipage_inner = listinner->ipage; NeighList *listmiddle; int *ilist_middle,*numneigh_middle,**firstneigh_middle; MyPage<int> *ipage_middle; int respamiddle = list->respamiddle; if (respamiddle) { listmiddle = list->listmiddle; ilist_middle = listmiddle->ilist; numneigh_middle = listmiddle->numneigh; firstneigh_middle = listmiddle->firstneigh; ipage_middle = listmiddle->ipage; } int inum = 0; int which = 0; int minchange = 0; ipage->reset(); ipage_inner->reset(); if (respamiddle) ipage_middle->reset(); for (i = 0; i < nlocal; i++) { n = n_inner = 0; neighptr = ipage->vget(); neighptr_inner = ipage_inner->vget(); if (respamiddle) { n_middle = 0; neighptr_middle = ipage_middle->vget(); } itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; ibin = atom2bin[i]; if (moltemplate) { imol = molindex[i]; iatom = molatom[i]; tagprev = tag[i] - iatom - 1; } // loop over all atoms in surrounding bins in stencil including self // only store pair if i < j // stores own/own pairs only once // stores own/ghost pairs on both procs for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (j <= i) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if ((minchange = domain->minimum_image_check(delx,dely,delz))) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; if (rsq < cut_inner_sq) { if (which == 0) neighptr_inner[n_inner++] = j; else if (minchange) neighptr_inner[n_inner++] = j; else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS); } if (respamiddle && rsq < cut_middle_sq && rsq > cut_middle_inside_sq) { if (which == 0) neighptr_middle[n_middle++] = j; else if (minchange) neighptr_middle[n_middle++] = j; else if (which > 0) neighptr_middle[n_middle++] = j ^ (which << SBBITS); } } } } ilist[inum] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); ilist_inner[inum] = i; firstneigh_inner[i] = neighptr_inner; numneigh_inner[i] = n_inner; ipage_inner->vgot(n_inner); if (ipage_inner->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (respamiddle) { ilist_middle[inum] = i; firstneigh_middle[i] = neighptr_middle; numneigh_middle[i] = n_middle; ipage_middle->vgot(n_middle); if (ipage_middle->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } inum++; } list->inum = inum; listinner->inum = inum; if (respamiddle) listmiddle->inum = inum; }
void NPairHalfBinNewtonSSA::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which,imol,iatom,moltemplate; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; tagint *tag = atom->tag; tagint *molecule = atom->molecule; tagint **special = atom->special; int **nspecial = atom->nspecial; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; if (includegroup) nlocal = atom->nfirst; int *ssaAIR = atom->ssaAIR; int *molindex = atom->molindex; int *molatom = atom->molatom; Molecule **onemols = atom->avec->onemols; int molecular = atom->molecular; if (molecular == 2) moltemplate = 1; else moltemplate = 0; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; NStencilSSA *ns_ssa = dynamic_cast<NStencilSSA*>(ns); if (!ns_ssa) error->one(FLERR, "NStencil wasn't a NStencilSSA object"); int nstencil_half = ns_ssa->nstencil_half; int nstencil_full = ns_ssa->nstencil; NBinSSA *nb_ssa = dynamic_cast<NBinSSA*>(nb); if (!nb_ssa) error->one(FLERR, "NBin wasn't a NBinSSA object"); int *bins_ssa = nb_ssa->bins_ssa; int *binhead_ssa = nb_ssa->binhead_ssa; int *gbinhead_ssa = nb_ssa->gbinhead_ssa; int inum = 0; ipage->reset(); // loop over owned atoms, storing half of the neighbors for (i = 0; i < nlocal; i++) { int AIRct[8] = { 0 }; n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; if (moltemplate) { imol = molindex[i]; iatom = molatom[i]; tagprev = tag[i] - iatom - 1; } // loop over rest of local atoms in i's bin // just store them, since j is beyond i in linked list for (j = bins_ssa[i]; j >= 0; j = bins_ssa[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } ibin = coord2bin(x[i]); // loop over all local atoms in other bins in "half" stencil for (k = 0; k < nstencil_half; k++) { for (j = binhead_ssa[ibin+stencil[k]]; j >= 0; j = bins_ssa[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } AIRct[0] = n; // loop over AIR ghost atoms in all bins in "full" stencil // Note: the non-AIR ghost atoms have already been filtered out // That is a significant time savings because of the "full" stencil // Note2: only non-pure locals can have ghosts as neighbors if (ssaAIR[i] == 1) for (k = 0; k < nstencil_full; k++) { for (j = gbinhead_ssa[ibin+stencil[k]]; j >= 0; j = bins_ssa[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) { neighptr[n++] = j; ++(AIRct[ssaAIR[j] - 1]); } else if (domain->minimum_image_check(delx,dely,delz)) { neighptr[n++] = j; ++(AIRct[ssaAIR[j] - 1]); } else if (which > 0) { neighptr[n++] = j ^ (which << SBBITS); ++(AIRct[ssaAIR[j] - 1]); } } else { neighptr[n++] = j; ++(AIRct[ssaAIR[j] - 1]); } } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); // sort the ghosts in the neighbor list by their ssaAIR number ssaAIRptr = atom->ssaAIR; qsort(&(neighptr[AIRct[0]]), n - AIRct[0], sizeof(int), cmp_ssaAIR); // do a prefix sum on the counts to turn them into indexes list->ndxAIR_ssa[i][0] = AIRct[0]; for (int ndx = 1; ndx < 8; ++ndx) { list->ndxAIR_ssa[i][ndx] = AIRct[ndx] + list->ndxAIR_ssa[i][ndx - 1]; } } list->inum = inum; }
void NPairHalfSizeBinNewtonTri::build(NeighList *list) { int i,j,k,n,ibin; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr; double **x = atom->x; double *radius = atom->radius; int *type = atom->type; int *mask = atom->mask; tagint *molecule = atom->molecule; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int history = list->history; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int mask_history = 3 << SBBITS; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; // loop over all atoms in bins in stencil // pairs for atoms j "below" i are excluded // below = lower z or (equal z and lower y) or (equal zy and lower x) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms ibin = atom2bin[i]; for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp) { if (x[j][0] < xtmp) continue; if (x[j][0] == xtmp && j <= i) continue; } } if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = radi + radius[j]; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) { if (history && rsq < radsum*radsum) neighptr[n++] = j ^ mask_history; else neighptr[n++] = j; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void NPairFullNsq::build(NeighList *list) { int i,j,n,itype,jtype,which,bitmask,imol,iatom,moltemplate; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; tagint *tag = atom->tag; tagint *molecule = atom->molecule; tagint **special = atom->special; int **nspecial = atom->nspecial; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; if (includegroup) { nlocal = atom->nfirst; bitmask = group->bitmask[includegroup]; } int *molindex = atom->molindex; int *molatom = atom->molatom; Molecule **onemols = atom->avec->onemols; if (molecular == 2) moltemplate = 1; else moltemplate = 0; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; if (moltemplate) { imol = molindex[i]; iatom = molatom[i]; tagprev = tag[i] - iatom - 1; } // loop over all atoms, owned and ghost // skip i = j for (j = 0; j < nall; j++) { if (includegroup && !(mask[j] & bitmask)) continue; if (i == j) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; list->gnum = 0; }
void Neighbor::half_bin_no_newton(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int molecular = atom->molecular; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int *stencil = list->stencil; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over all atoms in other bins in stencil including self // only store pair if i < j // stores own/own pairs only once // stores own/ghost pairs on both procs ibin = coord2bin(x[i]); for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (j <= i) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void Neighbor::respa_bin_newton_tri(NeighList *list) { int i,j,k,n,itype,jtype,ibin,n_inner,n_middle=0; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*neighptr_inner,*neighptr_middle = NULL; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int molecular = atom->molecular; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int *stencil = list->stencil; MyPage<int> *ipage = list->ipage; NeighList *listinner = list->listinner; int *ilist_inner = listinner->ilist; int *numneigh_inner = listinner->numneigh; int **firstneigh_inner = listinner->firstneigh; MyPage<int> *ipage_inner = listinner->ipage; NeighList *listmiddle; int *ilist_middle,*numneigh_middle,**firstneigh_middle; MyPage<int> *ipage_middle = NULL; int respamiddle = list->respamiddle; if (respamiddle) { listmiddle = list->listmiddle; ilist_middle = listmiddle->ilist; numneigh_middle = listmiddle->numneigh; firstneigh_middle = listmiddle->firstneigh; ipage_middle = listmiddle->ipage; } int inum = 0; int which = 0; int minchange = 0; ipage->reset(); ipage_inner->reset(); if (respamiddle) ipage_middle->reset(); for (i = 0; i < nlocal; i++) { n = n_inner = 0; neighptr = ipage->vget(); neighptr_inner = ipage_inner->vget(); if (respamiddle) { n_middle = 0; neighptr_middle = ipage_middle->vget(); } itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over all atoms in bins in stencil // pairs for atoms j "below" i are excluded // below = lower z or (equal z and lower y) or (equal zy and lower x) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms ibin = coord2bin(x[i]); for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp) { if (x[j][0] < xtmp) continue; if (x[j][0] == xtmp && j <= i) continue; } } jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if ((minchange = domain->minimum_image_check(delx,dely,delz))) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; if (rsq < cut_inner_sq) { if (which == 0) neighptr_inner[n_inner++] = j; else if (minchange) neighptr_inner[n_inner++] = j; else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS); } if (respamiddle && rsq < cut_middle_sq && rsq > cut_middle_inside_sq) { if (which == 0) neighptr_middle[n_middle++] = j; else if (minchange) neighptr_middle[n_middle++] = j; else if (which > 0) neighptr_middle[n_middle++] = j ^ (which << SBBITS); } } } } ilist[inum] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); ilist_inner[inum] = i; firstneigh_inner[i] = neighptr_inner; numneigh_inner[i] = n_inner; ipage_inner->vgot(n_inner); if (ipage_inner->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (respamiddle) { ilist_middle[inum] = i; firstneigh_middle[i] = neighptr_middle; numneigh_middle[i] = n_middle; ipage_middle->vgot(n_middle); if (ipage_middle->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } inum++; } list->inum = inum; listinner->inum = inum; if (respamiddle) listmiddle->inum = inum; }
void Neighbor::half_multi_newton_tri(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which,ns; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*s; double *cutsq,*distsq; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int molecular = atom->molecular; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int *nstencil_multi = list->nstencil_multi; int **stencil_multi = list->stencil_multi; double **distsq_multi = list->distsq_multi; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over all atoms in bins, including self, in stencil // skip if i,j neighbor cutoff is less than bin distance // bins below self are excluded from stencil // pairs for atoms j "below" i are excluded // below = lower z or (equal z and lower y) or (equal zy and lower x) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms ibin = coord2bin(x[i]); s = stencil_multi[itype]; distsq = distsq_multi[itype]; cutsq = cutneighsq[itype]; ns = nstencil_multi[itype]; for (k = 0; k < ns; k++) { for (j = binhead[ibin+s[k]]; j >= 0; j = bins[j]) { jtype = type[j]; if (cutsq[jtype] < distsq[k]) continue; if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp) { if (x[j][0] < xtmp) continue; if (x[j][0] == xtmp && j <= i) continue; } } if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void NPairSkipRespa::build(NeighList *list) { int i,j,ii,jj,n,itype,jnum,joriginal,n_inner,n_middle; int *neighptr,*jlist,*neighptr_inner,*neighptr_middle; int *type = atom->type; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int *ilist_skip = list->listskip->ilist; int *numneigh_skip = list->listskip->numneigh; int **firstneigh_skip = list->listskip->firstneigh; int inum_skip = list->listskip->inum; int *iskip = list->iskip; int **ijskip = list->ijskip; NeighList *listinner = list->listinner; int *ilist_inner = listinner->ilist; int *numneigh_inner = listinner->numneigh; int **firstneigh_inner = listinner->firstneigh; MyPage<int> *ipage_inner = listinner->ipage; int *numneigh_inner_skip = list->listskip->listinner->numneigh; int **firstneigh_inner_skip = list->listskip->listinner->firstneigh; NeighList *listmiddle; int *ilist_middle,*numneigh_middle,**firstneigh_middle; MyPage<int> *ipage_middle; int *numneigh_middle_skip,**firstneigh_middle_skip; int respamiddle = list->respamiddle; if (respamiddle) { listmiddle = list->listmiddle; ilist_middle = listmiddle->ilist; numneigh_middle = listmiddle->numneigh; firstneigh_middle = listmiddle->firstneigh; ipage_middle = listmiddle->ipage; numneigh_middle_skip = list->listskip->listmiddle->numneigh; firstneigh_middle_skip = list->listskip->listmiddle->firstneigh; } int inum = 0; ipage->reset(); ipage_inner->reset(); if (respamiddle) ipage_middle->reset(); // loop over atoms in other list // skip I atom entirely if iskip is set for type[I] // skip I,J pair if ijskip is set for type[I],type[J] for (ii = 0; ii < inum_skip; ii++) { i = ilist_skip[ii]; itype = type[i]; if (iskip[itype]) continue; n = n_inner = 0; neighptr = ipage->vget(); neighptr_inner = ipage_inner->vget(); if (respamiddle) { n_middle = 0; neighptr_middle = ipage_middle->vget(); } // loop over parent outer rRESPA list jlist = firstneigh_skip[i]; jnum = numneigh_skip[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (ijskip[itype][type[j]]) continue; neighptr[n++] = joriginal; } // loop over parent inner rRESPA list jlist = firstneigh_inner_skip[i]; jnum = numneigh_inner_skip[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (ijskip[itype][type[j]]) continue; neighptr_inner[n_inner++] = joriginal; } // loop over parent middle rRESPA list if (respamiddle) { jlist = firstneigh_middle_skip[i]; jnum = numneigh_middle_skip[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (ijskip[itype][type[j]]) continue; neighptr_middle[n_middle++] = joriginal; } } ilist[inum] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); ilist_inner[inum] = i; firstneigh_inner[i] = neighptr_inner; numneigh_inner[i] = n_inner; ipage_inner->vgot(n); if (ipage_inner->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (respamiddle) { ilist_middle[inum] = i; firstneigh_middle[i] = neighptr_middle; numneigh_middle[i] = n_middle; ipage_middle->vgot(n); if (ipage_middle->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } inum++; } list->inum = inum; listinner->inum = inum; if (respamiddle) listmiddle->inum = inum; }
void NPairHalfBinNewtonSSA::build(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which,imol,iatom,moltemplate; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; tagint *tag = atom->tag; tagint *molecule = atom->molecule; tagint **special = atom->special; int **nspecial = atom->nspecial; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int *molindex = atom->molindex; int *molatom = atom->molatom; Molecule **onemols = atom->avec->onemols; int molecular = atom->molecular; if (molecular == 2) moltemplate = 1; else moltemplate = 0; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; NStencilSSA *ns_ssa = dynamic_cast<NStencilSSA*>(ns); if (!ns_ssa) error->one(FLERR, "NStencil wasn't a NStencilSSA object"); int *nstencil_ssa = &(ns_ssa->nstencil_ssa[0]); int nstencil_full = ns_ssa->nstencil; NBinSSA *nb_ssa = dynamic_cast<NBinSSA*>(nb); if (!nb_ssa) error->one(FLERR, "NBin wasn't a NBinSSA object"); int *bins = nb_ssa->bins; int *binhead = nb_ssa->binhead; int *gairhead_ssa = &(nb_ssa->gairhead_ssa[0]); int inum = 0; int gnum = 0; int xbin,ybin,zbin,xbin2,ybin2,zbin2; int **stencilxyz = ns_ssa->stencilxyz; int lbinxlo = nb_ssa->lbinxlo; int lbinxhi = nb_ssa->lbinxhi; int lbinylo = nb_ssa->lbinylo; int lbinyhi = nb_ssa->lbinyhi; int lbinzlo = nb_ssa->lbinzlo; int lbinzhi = nb_ssa->lbinzhi; int sx1 = ns_ssa->sx + 1; int sy1 = ns_ssa->sy + 1; int sz1 = ns_ssa->sz + 1; ssa_phaseCt = sz1*sy1*sx1; xbin = (lbinxhi - lbinxlo + sx1 - 1) / sx1 + 1; ybin = (lbinyhi - lbinylo + sy1 - 1) / sy1 + 1; zbin = (lbinzhi - lbinzlo + sz1 - 1) / sz1 + 1; int phaseLenEstimate = xbin*ybin*zbin; if (ssa_phaseCt > ssa_maxPhaseCt) { ssa_maxPhaseCt = ssa_phaseCt; ssa_maxPhaseLen = 0; memory->destroy(ssa_phaseLen); memory->destroy(ssa_itemLoc); memory->destroy(ssa_itemLen); memory->create(ssa_phaseLen,ssa_maxPhaseCt,"NPairHalfBinNewtonSSA:ssa_phaseLen"); } if (phaseLenEstimate > ssa_maxPhaseLen) { ssa_maxPhaseLen = phaseLenEstimate; memory->destroy(ssa_itemLoc); memory->destroy(ssa_itemLen); memory->create(ssa_itemLoc,ssa_maxPhaseCt,ssa_maxPhaseLen,"NPairHalfBinNewtonSSA:ssa_itemLoc"); memory->create(ssa_itemLen,ssa_maxPhaseCt,ssa_maxPhaseLen,"NPairHalfBinNewtonSSA:ssa_itemLen"); } ipage->reset(); int workPhase = 0; // loop over bins with local atoms, storing half of the neighbors for (int zoff = ns_ssa->sz; zoff >= 0; --zoff) { for (int yoff = ns_ssa->sy; yoff >= 0; --yoff) { for (int xoff = ns_ssa->sx; xoff >= 0; --xoff) { int workItem = 0; for (zbin = lbinzlo + zoff; zbin < lbinzhi; zbin += sz1) { for (ybin = lbinylo + yoff - ns_ssa->sy; ybin < lbinyhi; ybin += sy1) { for (xbin = lbinxlo + xoff - ns_ssa->sx; xbin < lbinxhi; xbin += sx1) { if (workItem >= phaseLenEstimate) error->one(FLERR,"phaseLenEstimate was too small"); ssa_itemLoc[workPhase][workItem] = inum; // record where workItem starts in ilist for (int subphase = 0; subphase < 4; subphase++) { int s_ybin = ybin + ((subphase & 0x2) ? ns_ssa->sy : 0); int s_xbin = xbin + ((subphase & 0x1) ? ns_ssa->sx : 0); int ibin, ct; if ((s_ybin < lbinylo) || (s_ybin >= lbinyhi)) continue; if ((s_xbin < lbinxlo) || (s_xbin >= lbinxhi)) continue; ibin = zbin*nb_ssa->mbiny*nb_ssa->mbinx + s_ybin*nb_ssa->mbinx + s_xbin; for (i = binhead[ibin]; i >= 0; i = bins[i]) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; if (moltemplate) { imol = molindex[i]; iatom = molatom[i]; tagprev = tag[i] - iatom - 1; } // loop over all local atoms in the current stencil "subphase" for (k = nstencil_ssa[subphase]; k < nstencil_ssa[subphase+1]; k++) { const int jbin = ibin+stencil[k]; if (jbin != ibin) j = binhead[jbin]; else j = bins[i]; // same bin as i, so start just past i in the bin for (; j >= 0; j = bins[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } if (n > 0) { firstneigh[inum] = neighptr; numneigh[inum] = n; ilist[inum++] = i; } ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } } // record where workItem ends in ilist ssa_itemLen[workPhase][workItem] = inum - ssa_itemLoc[workPhase][workItem]; if (ssa_itemLen[workPhase][workItem] > 0) workItem++; } } } // record where workPhase ends ssa_phaseLen[workPhase++] = workItem; } } } if (ssa_phaseCt != workPhase) error->one(FLERR,"ssa_phaseCt was wrong"); list->AIRct_ssa[0] = list->inum = inum; // loop over AIR ghost atoms, storing their local neighbors // since these are ghosts, must check if stencil bin is out of bounds for (int airnum = 1; airnum <= 7; airnum++) { int locAIRct = 0; for (i = gairhead_ssa[airnum]; i >= 0; i = bins[i]) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; ibin = coord2bin(x[i],xbin,ybin,zbin); // loop over AIR ghost atoms in all bins in "full" stencil // Note: the non-AIR ghost atoms have already been filtered out for (k = 0; k < nstencil_full; k++) { xbin2 = xbin + stencilxyz[k][0]; ybin2 = ybin + stencilxyz[k][1]; zbin2 = zbin + stencilxyz[k][2]; // Skip it if this bin is outside the extent of local bins if (xbin2 < lbinxlo || xbin2 >= lbinxhi || ybin2 < lbinylo || ybin2 >= lbinyhi || zbin2 < lbinzlo || zbin2 >= lbinzhi) continue; for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[j],nspecial[j],tag[i]); else { int jmol = molindex[j]; if (jmol >= 0) { int jatom = molatom[j]; which = find_special(onemols[jmol]->special[jatom], onemols[jmol]->nspecial[jatom], tag[i] - (tag[j] - jatom - 1)); } else which = 0; } if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } if (n > 0) { firstneigh[inum + gnum] = neighptr; numneigh[inum + gnum] = n; ilist[inum + (gnum++)] = i; ++locAIRct; } ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor (ghost) list overflow, boost neigh_modify one"); } list->AIRct_ssa[airnum] = locAIRct; } list->gnum = gnum; }
void Neighbor::half_from_full_newton_ssa(NeighList *list) { int i,j,ii,jj,n,jnum,joriginal; int *neighptr,*jlist; int nlocal = atom->nlocal; int *ssaAIR = atom->ssaAIR; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int *ilist_full = list->listfull->ilist; int *numneigh_full = list->listfull->numneigh; int **firstneigh_full = list->listfull->firstneigh; int inum_full = list->listfull->inum; int inum = 0; ipage->reset(); // loop over parent full list for (ii = 0; ii < inum_full; ii++) { int AIRct[8] = { 0 }; n = 0; neighptr = ipage->vget(); i = ilist_full[ii]; // loop over full neighbor list jlist = firstneigh_full[i]; jnum = numneigh_full[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (j < nlocal) { if (i > j) continue; ++(AIRct[0]); } else { if (ssaAIR[j] < 2) continue; // skip ghost atoms not in AIR ++(AIRct[ssaAIR[j] - 1]); } neighptr[n++] = joriginal; } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); // sort the locals+ghosts in the neighbor list by their ssaAIR number ssaAIRptr = atom->ssaAIR; qsort(&(neighptr[0]), n, sizeof(int), cmp_ssaAIR); // Do a prefix sum on the counts to turn them into indexes. list->ndxAIR_ssa[i][0] = AIRct[0]; for (int ndx = 1; ndx < 8; ++ndx) { list->ndxAIR_ssa[i][ndx] = AIRct[ndx] + list->ndxAIR_ssa[i][ndx - 1]; } } list->inum = inum; }
void Neighbor::granular_nsq_newton(NeighList *list) { int i,j,n,itag,jtag,bitmask; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr; double **x = atom->x; double *radius = atom->radius; int *tag = atom->tag; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; if (includegroup) { nlocal = atom->nfirst; bitmask = group->bitmask[includegroup]; } int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); itag = tag[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; // loop over remaining atoms, owned and ghost for (j = i+1; j < nall; j++) { if (includegroup && !(mask[j] & bitmask)) continue; if (j >= nlocal) { jtag = tag[j]; if (itag > jtag) { if ((itag+jtag) % 2 == 0) continue; } else if (itag < jtag) { if ((itag+jtag) % 2 == 1) continue; } else { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp && x[j][0] < xtmp) continue; } } } if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = (radi + radius[j]) * contactDistanceFactor; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) neighptr[n++] = j; } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void Neighbor::half_bin_newton_ssa(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which,imol,iatom,moltemplate; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; tagint *tag = atom->tag; tagint *molecule = atom->molecule; tagint **special = atom->special; int **nspecial = atom->nspecial; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; int *ssaAIR = atom->ssaAIR; int *molindex = atom->molindex; int *molatom = atom->molatom; Molecule **onemols = atom->avec->onemols; int molecular = atom->molecular; if (molecular == 2) moltemplate = 1; else moltemplate = 0; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int maxstencil = list->maxstencil; int *stencil = list->stencil; MyPage<int> *ipage = list->ipage; int inum = 0; if (binatomflag) { /* only false in Neighbor::build_one */ /* ---------------------------------------------------------------------- bin owned and ghost atoms for use by Shardlow Splitting Algorithm exclude ghost atoms that are not in the Active Interaction Regions (AIR) ------------------------------------------------------------------------- */ if (mbins > list->maxhead_ssa) { list->maxhead_ssa = mbins; memory->destroy(list->gbinhead_ssa); memory->destroy(list->binhead_ssa); memory->create(list->binhead_ssa,list->maxhead_ssa,"binhead_ssa"); memory->create(list->gbinhead_ssa,list->maxhead_ssa,"gbinhead_ssa"); } for (i = 0; i < mbins; i++) { list->gbinhead_ssa[i] = -1; list->binhead_ssa[i] = -1; } if (maxbin > list->maxbin_ssa) { list->maxbin_ssa = maxbin; memory->destroy(list->bins_ssa); memory->create(list->bins_ssa,list->maxbin_ssa,"bins_ssa"); } // bin in reverse order so linked list will be in forward order if (includegroup) { int bitmask = group->bitmask[includegroup]; for (i = nall-1; i >= nlocal; i--) { if (ssaAIR[i] < 2) continue; // skip ghost atoms not in AIR if (mask[i] & bitmask) { ibin = coord2bin(x[i]); list->bins_ssa[i] = list->gbinhead_ssa[ibin]; list->gbinhead_ssa[ibin] = i; } } nlocal = atom->nfirst; // This is important for the code that follows! } else { for (i = nall-1; i >= nlocal; i--) { if (ssaAIR[i] < 2) continue; // skip ghost atoms not in AIR ibin = coord2bin(x[i]); list->bins_ssa[i] = list->gbinhead_ssa[ibin]; list->gbinhead_ssa[ibin] = i; } } for (i = nlocal-1; i >= 0; i--) { ibin = coord2bin(x[i]); list->bins_ssa[i] = list->binhead_ssa[ibin]; list->binhead_ssa[ibin] = i; } } /* else reuse previous binning. See Neighbor::build_one comment. */ ipage->reset(); // loop over owned atoms, storing half of the neighbors for (i = 0; i < nlocal; i++) { int AIRct[8] = { 0 }; n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; if (moltemplate) { imol = molindex[i]; iatom = molatom[i]; tagprev = tag[i] - iatom - 1; } // loop over rest of local atoms in i's bin // just store them, since j is beyond i in linked list for (j = list->bins_ssa[i]; j >= 0; j = list->bins_ssa[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } ibin = coord2bin(x[i]); // loop over all local atoms in other bins in "half" stencil for (k = 0; k < nstencil; k++) { for (j = list->binhead_ssa[ibin+stencil[k]]; j >= 0; j = list->bins_ssa[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } AIRct[0] = n; // loop over AIR ghost atoms in all bins in "full" stencil // Note: the non-AIR ghost atoms have already been filtered out // That is a significant time savings because of the "full" stencil // Note2: only non-pure locals can have ghosts as neighbors if (ssaAIR[i] == 1) for (k = 0; k < maxstencil; k++) { if (stencil[k] > mbins) break; /* Check if ghost stencil bins are exhausted */ for (j = list->gbinhead_ssa[ibin+stencil[k]]; j >= 0; j = list->bins_ssa[j]) { jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) { neighptr[n++] = j; ++(AIRct[ssaAIR[j] - 1]); } else if (domain->minimum_image_check(delx,dely,delz)) { neighptr[n++] = j; ++(AIRct[ssaAIR[j] - 1]); } else if (which > 0) { neighptr[n++] = j ^ (which << SBBITS); ++(AIRct[ssaAIR[j] - 1]); } } else { neighptr[n++] = j; ++(AIRct[ssaAIR[j] - 1]); } } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); // sort the ghosts in the neighbor list by their ssaAIR number ssaAIRptr = atom->ssaAIR; qsort(&(neighptr[AIRct[0]]), n - AIRct[0], sizeof(int), cmp_ssaAIR); // Do a prefix sum on the counts to turn them into indexes. list->ndxAIR_ssa[i][0] = AIRct[0]; for (int ndx = 1; ndx < 8; ++ndx) { list->ndxAIR_ssa[i][ndx] = AIRct[ndx] + list->ndxAIR_ssa[i][ndx - 1]; } } list->inum = inum; }
void Neighbor::granular_nsq_no_newton(NeighList *list) { int i,j,m,n,nn,bitmask,d; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr,*touchptr; double *shearptr; NeighList *listgranhistory; int *npartner,**partner; double **contacthistory; int **firsttouch; double **firstshear; MyPage<int> *ipage_touch; MyPage<double> *dpage_shear; int dnum; double **x = atom->x; double *radius = atom->radius; int *tag = atom->tag; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; if (includegroup) { nlocal = atom->nfirst; bitmask = group->bitmask[includegroup]; } int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; FixContactHistory *fix_history = list->fix_history; if (fix_history) { npartner = fix_history->npartner_; partner = fix_history->partner_; contacthistory = fix_history->contacthistory_; listgranhistory = list->listgranhistory; firsttouch = listgranhistory->firstneigh; firstshear = listgranhistory->firstdouble; ipage_touch = listgranhistory->ipage; dpage_shear = listgranhistory->dpage; dnum = listgranhistory->dnum; } int inum = 0; ipage->reset(); if (fix_history) { ipage_touch->reset(); dpage_shear->reset(); } for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); if (fix_history) { nn = 0; touchptr = ipage_touch->vget(); shearptr = dpage_shear->vget(); } xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; // loop over remaining atoms, owned and ghost for (j = i+1; j < nall; j++) { if (includegroup && !(mask[j] & bitmask)) continue; if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = (radi + radius[j]) * contactDistanceFactor; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) { neighptr[n] = j; if (fix_history) { if (rsq < radsum*radsum) { for (m = 0; m < npartner[i]; m++) if (partner[i][m] == tag[j]) break; if (m < npartner[i]) { touchptr[n] = 1; for (d = 0; d < dnum; d++) { shearptr[nn++] = contacthistory[i][m*dnum+d]; } } else { touchptr[n] = 0; for (d = 0; d < dnum; d++) { shearptr[nn++] = 0.0; } } } else { touchptr[n] = 0; for (d = 0; d < dnum; d++) { shearptr[nn++] = 0.0; } } } n++; } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (fix_history) { firsttouch[i] = touchptr; firstshear[i] = shearptr; ipage_touch->vgot(n); dpage_shear->vgot(nn); } } list->inum = inum; }
void Neighbor::full_nsq_ghost(NeighList *list) { int i,j,n,itype,jtype,which; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr; int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; int molecular = atom->molecular; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); // loop over owned & ghost atoms, storing neighbors for (i = 0; i < nall; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over all atoms, owned and ghost // skip i = j // no molecular test when i = ghost atom if (i < nlocal) { for (j = 0; j < nall; j++) { if (i == j) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } else { for (j = 0; j < nall; j++) { if (i == j) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighghostsq[itype][jtype]) neighptr[n++] = j; } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = atom->nlocal; list->gnum = inum - atom->nlocal; }
void Neighbor::granular_bin_newton_tri(NeighList *list) { int i,j,k,n,ibin; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; double radi,radsum,cutsq; int *neighptr; // bin local & ghost atoms bin_atoms(); // loop over each atom, storing neighbors double **x = atom->x; double *radius = atom->radius; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; if (includegroup) nlocal = atom->nfirst; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int *stencil = list->stencil; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); for (i = 0; i < nlocal; i++) { n = 0; neighptr = ipage->vget(); xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; radi = radius[i]; // loop over all atoms in bins in stencil // pairs for atoms j "below" i are excluded // below = lower z or (equal z and lower y) or (equal zy and lower x) // (equal zyx and j <= i) // latter excludes self-self interaction but allows superposed atoms ibin = coord2bin(x[i]); for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp) { if (x[j][0] < xtmp) continue; if (x[j][0] == xtmp && j <= i) continue; } } if (exclude && exclusion(i,j,type[i],type[j],mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; radsum = (radi + radius[j]) * contactDistanceFactor; cutsq = (radsum+skin) * (radsum+skin); if (rsq <= cutsq) neighptr[n++] = j; } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = inum; }
void Neighbor::full_bin_ghost(NeighList *list) { int i,j,k,n,itype,jtype,ibin,which; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int xbin,ybin,zbin,xbin2,ybin2,zbin2; int *neighptr; // bin owned & ghost atoms bin_atoms(); int **special = atom->special; int **nspecial = atom->nspecial; int *tag = atom->tag; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; int *molecule = atom->molecule; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; int molecular = atom->molecular; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; int nstencil = list->nstencil; int *stencil = list->stencil; int **stencilxyz = list->stencilxyz; MyPage<int> *ipage = list->ipage; int inum = 0; ipage->reset(); // loop over owned & ghost atoms, storing neighbors for (i = 0; i < nall; i++) { n = 0; neighptr = ipage->vget(); itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; // loop over all atoms in surrounding bins in stencil including self // when i is a ghost atom, must check if stencil bin is out of bounds // skip i = j // no molecular test when i = ghost atom if (i < nlocal) { ibin = coord2bin(x[i]); for (k = 0; k < nstencil; k++) { for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (i == j) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { which = find_special(special[i],nspecial[i],tag[j]); if (which == 0) neighptr[n++] = j; else if (domain->minimum_image_check(delx,dely,delz)) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; } } } } else { ibin = coord2bin(x[i],xbin,ybin,zbin); for (k = 0; k < nstencil; k++) { xbin2 = xbin + stencilxyz[k][0]; ybin2 = ybin + stencilxyz[k][1]; zbin2 = zbin + stencilxyz[k][2]; if (xbin2 < 0 || xbin2 >= mbinx || ybin2 < 0 || ybin2 >= mbiny || zbin2 < 0 || zbin2 >= mbinz) continue; for (j = binhead[ibin+stencil[k]]; j >= 0; j = bins[j]) { if (i == j) continue; jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighghostsq[itype][jtype]) neighptr[n++] = j; } } } ilist[inum++] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } list->inum = atom->nlocal; list->gnum = inum - atom->nlocal; }
void NPairHalfRespaNsqNewton::build(NeighList *list) { int i,j,n,itype,jtype,itag,jtag,n_inner,n_middle,bitmask; int imol,iatom,moltemplate; tagint tagprev; double xtmp,ytmp,ztmp,delx,dely,delz,rsq; int *neighptr,*neighptr_inner,*neighptr_middle; double **x = atom->x; int *type = atom->type; int *mask = atom->mask; tagint *tag = atom->tag; tagint *molecule = atom->molecule; tagint **special = atom->special; int **nspecial = atom->nspecial; int nlocal = atom->nlocal; int nall = nlocal + atom->nghost; if (includegroup) { nlocal = atom->nfirst; bitmask = group->bitmask[includegroup]; } int *molindex = atom->molindex; int *molatom = atom->molatom; Molecule **onemols = atom->avec->onemols; if (molecular == 2) moltemplate = 1; else moltemplate = 0; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; NeighList *listinner = list->listinner; int *ilist_inner = listinner->ilist; int *numneigh_inner = listinner->numneigh; int **firstneigh_inner = listinner->firstneigh; MyPage<int> *ipage_inner = listinner->ipage; NeighList *listmiddle; int *ilist_middle,*numneigh_middle,**firstneigh_middle; MyPage<int> *ipage_middle; int respamiddle = list->respamiddle; if (respamiddle) { listmiddle = list->listmiddle; ilist_middle = listmiddle->ilist; numneigh_middle = listmiddle->numneigh; firstneigh_middle = listmiddle->firstneigh; ipage_middle = listmiddle->ipage; } int inum = 0; int which = 0; int minchange = 0; ipage->reset(); ipage_inner->reset(); if (respamiddle) ipage_middle->reset(); for (i = 0; i < nlocal; i++) { n = n_inner = 0; neighptr = ipage->vget(); neighptr_inner = ipage_inner->vget(); if (respamiddle) { n_middle = 0; neighptr_middle = ipage_middle->vget(); } itag = tag[i]; itype = type[i]; xtmp = x[i][0]; ytmp = x[i][1]; ztmp = x[i][2]; if (moltemplate) { imol = molindex[i]; iatom = molatom[i]; tagprev = tag[i] - iatom - 1; } // loop over remaining atoms, owned and ghost for (j = i+1; j < nall; j++) { if (includegroup && !(mask[j] & bitmask)) continue; if (j >= nlocal) { jtag = tag[j]; if (itag > jtag) { if ((itag+jtag) % 2 == 0) continue; } else if (itag < jtag) { if ((itag+jtag) % 2 == 1) continue; } else { if (x[j][2] < ztmp) continue; if (x[j][2] == ztmp) { if (x[j][1] < ytmp) continue; if (x[j][1] == ytmp && x[j][0] < xtmp) continue; } } } jtype = type[j]; if (exclude && exclusion(i,j,itype,jtype,mask,molecule)) continue; delx = xtmp - x[j][0]; dely = ytmp - x[j][1]; delz = ztmp - x[j][2]; rsq = delx*delx + dely*dely + delz*delz; if (rsq <= cutneighsq[itype][jtype]) { if (molecular) { if (!moltemplate) which = find_special(special[i],nspecial[i],tag[j]); else if (imol >= 0) which = find_special(onemols[imol]->special[iatom], onemols[imol]->nspecial[iatom], tag[j]-tagprev); else which = 0; if (which == 0) neighptr[n++] = j; else if ((minchange = domain->minimum_image_check(delx,dely,delz))) neighptr[n++] = j; else if (which > 0) neighptr[n++] = j ^ (which << SBBITS); } else neighptr[n++] = j; if (rsq < cut_inner_sq) { if (which == 0) neighptr_inner[n_inner++] = j; else if (minchange) neighptr_inner[n_inner++] = j; else if (which > 0) neighptr_inner[n_inner++] = j ^ (which << SBBITS); } if (respamiddle && rsq < cut_middle_sq && rsq > cut_middle_inside_sq) { if (which == 0) neighptr_middle[n_middle++] = j; else if (minchange) neighptr_middle[n_middle++] = j; else if (which > 0) neighptr_middle[n_middle++] = j ^ (which << SBBITS); } } } ilist[inum] = i; firstneigh[i] = neighptr; numneigh[i] = n; ipage->vgot(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); ilist_inner[inum] = i; firstneigh_inner[i] = neighptr_inner; numneigh_inner[i] = n_inner; ipage_inner->vgot(n_inner); if (ipage_inner->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (respamiddle) { ilist_middle[inum] = i; firstneigh_middle[i] = neighptr_middle; numneigh_middle[i] = n_middle; ipage_middle->vgot(n_middle); if (ipage_middle->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); } inum++; } list->inum = inum; listinner->inum = inum; if (respamiddle) listmiddle->inum = inum; }
void Neighbor::skip_from_granular_off2on_onesided(NeighList *list) { int i,j,ii,jj,m,n,nn,itype,jnum,joriginal,flip,dnum,dnumbytes,tmp; tagint itag,jtag; int *surf,*neighptr,*jlist; NeighList *listgranhistory; int *npartner; tagint **partner; double **shearpartner; int **firsttouch; double **firstshear; MyPage<int> *ipage_touch; MyPage<double> *dpage_shear; tagint *tag = atom->tag; int *type = atom->type; int nlocal = atom->nlocal; int *ilist = list->ilist; int *numneigh = list->numneigh; int **firstneigh = list->firstneigh; MyPage<int> *ipage = list->ipage; int *ilist_skip = list->listskip->ilist; int *numneigh_skip = list->listskip->numneigh; int **firstneigh_skip = list->listskip->firstneigh; int inum_skip = list->listskip->inum; int *iskip = list->iskip; int **ijskip = list->ijskip; if (domain->dimension == 2) surf = atom->line; else surf = atom->tri; FixShearHistory *fix_history = list->fix_history; if (fix_history) { fix_history->nlocal_neigh = nlocal; fix_history->nall_neigh = nlocal + atom->nghost; npartner = fix_history->npartner; partner = fix_history->partner; shearpartner = fix_history->shearpartner; listgranhistory = list->listgranhistory; firsttouch = listgranhistory->firstneigh; firstshear = listgranhistory->firstdouble; ipage_touch = listgranhistory->ipage; dpage_shear = listgranhistory->dpage; dnum = listgranhistory->dnum; dnumbytes = dnum * sizeof(double); } int inum = 0; ipage->reset(); if (fix_history) { ipage_touch->reset(); dpage_shear->reset(); } // two loops over parent list required, one to count, one to store // because onesided constraint means pair I,J may be stored with I or J // so don't know in advance how much space to alloc for each atom's neighs // first loop over atoms in other list to count neighbors // skip I atom entirely if iskip is set for type[I] // skip I,J pair if ijskip is set for type[I],type[J] for (i = 0; i < nlocal; i++) numneigh[i] = 0; for (ii = 0; ii < inum_skip; ii++) { i = ilist_skip[ii]; itype = type[i]; if (iskip[itype]) continue; itag = tag[i]; n = 0; // loop over parent non-skip granular list jlist = firstneigh_skip[i]; jnum = numneigh_skip[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (ijskip[itype][type[j]]) continue; // flip I,J if necessary to satisfy onesided constraint // do not keep if I is now ghost if (surf[i] >= 0) { if (j >= nlocal) continue; tmp = i; i = j; j = tmp; flip = 1; } else flip = 0; numneigh[i]++; if (flip) i = j; } } // allocate all per-atom neigh list chunks, including history for (i = 0; i < nlocal; i++) { if (numneigh[i] == 0) continue; n = numneigh[i]; firstneigh[i] = ipage->get(n); if (ipage->status()) error->one(FLERR,"Neighbor list overflow, boost neigh_modify one"); if (fix_history) { firsttouch[i] = ipage_touch->get(n); firstshear[i] = dpage_shear->get(dnum*n); } } // second loop over atoms in other list to store neighbors // skip I atom entirely if iskip is set for type[I] // skip I,J pair if ijskip is set for type[I],type[J] for (i = 0; i < nlocal; i++) numneigh[i] = 0; for (ii = 0; ii < inum_skip; ii++) { i = ilist_skip[ii]; itype = type[i]; if (iskip[itype]) continue; itag = tag[i]; // loop over parent non-skip granular list and optionally its history info jlist = firstneigh_skip[i]; jnum = numneigh_skip[i]; for (jj = 0; jj < jnum; jj++) { joriginal = jlist[jj]; j = joriginal & NEIGHMASK; if (ijskip[itype][type[j]]) continue; // flip I,J if necessary to satisfy onesided constraint // do not keep if I is now ghost if (surf[i] >= 0) { if (j >= nlocal) continue; tmp = i; i = j; j = tmp; flip = 1; } else flip = 0; // store j in neigh list, not joriginal, like other neigh methods // OK, b/c there is no special list flagging for surfs firstneigh[i][numneigh[i]] = j; // no numeric test for current touch // just use FSH partner list to infer it // would require complex calculation for surfs if (fix_history) { jtag = tag[j]; n = numneigh[i]; nn = dnum*n; for (m = 0; m < npartner[i]; m++) if (partner[i][m] == jtag) break; if (m < npartner[i]) { firsttouch[i][n] = 1; memcpy(&firstshear[i][nn],&shearpartner[i][dnum*m],dnumbytes); } else { firsttouch[i][n] = 0; memcpy(&firstshear[i][nn],zeroes,dnumbytes); } } numneigh[i]++; if (flip) i = j; } // only add atom I to ilist if it has neighbors // fix shear/history allows for this in pre_exchange_onesided() if (numneigh[i]) ilist[inum++] = i; } list->inum = inum; }