jianmu
/
lammps
forked from lijiext/lammps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@954 f3b2605a-c512-4ea7-a41b-209d697bcdaa

This commit is contained in:
sjplimp 2007-10-04 23:59:26 +00:00
parent 60da95b755
commit ed9ce73904
10 changed files with 404 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/GRANULAR/pair_gran_hertzian.cpp
View File

@ -95,7 +95,7 @@ void PairGranHertzian::compute(int eflag, int vflag)
if (rsq >= radsum*radsum) {
// unset touching neighbors
// unset non-touching neighbors
touch[jj] = 0;
shear = &allshear[3*jj];

18
src/GRANULAR/pair_gran_history.cpp
View File

@ -123,7 +123,7 @@ void PairGranHistory::compute(int eflag, int vflag)
if (rsq >= radsum*radsum) {
// unset touching neighbors
// unset non-touching neighbors
touch[jj] = 0;
shear = &allshear[3*jj];
@ -421,11 +421,19 @@ double PairGranHistory::init_one(int i, int j)
{
if (!allocated) allocate();
// return dummy value used in neighbor setup,
// but not in actual neighbor calculation
// since particles have variable radius
// return max diameter of any particle
// not used in granular neighbor calculation since particles have radius
// but will insure cutoff is big enough for any other neighbor lists built
return 1.0;
double *radius = atom->radius;
int nlocal = atom->nlocal;
double maxrad = 0.0;
for (int m = 0; m < nlocal; m++) maxrad = MAX(maxrad,radius[m]);
double mine = maxrad;
MPI_Allreduce(&mine,&maxrad,1,MPI_DOUBLE,MPI_MAX,world);
return 2.0*maxrad;
}
/* ----------------------------------------------------------------------

9
src/finish.cpp
View File

@ -293,11 +293,12 @@ void Finish::end(int flag)
}
}
// find a half non-skip neighbor list
// find a non-skip neighbor list containing half the pairwise interactions
for (m = 0; m < neighbor->old_nrequest; m++)
if ((neighbor->old_requests[m]->half ||
neighbor->old_requests[m]->half_from_full) &&
if ((neighbor->old_requests[m]->half || neighbor->old_requests[m]->gran ||
neighbor->old_requests[m]->respaouter ||
neighbor->old_requests[m]->half_from_full) &&
neighbor->old_requests[m]->skip == 0) break;
int nneigh = 0;
@ -322,7 +323,7 @@ void Finish::end(int flag)
}
}
// find a full non-skip neighbor list
// find a non-skip neighbor list containing full pairwise interactions
for (m = 0; m < neighbor->old_nrequest; m++)
if (neighbor->old_requests[m]->full &&

264
src/neigh_derive.cpp
View File

@ -25,7 +25,7 @@ using namespace LAMMPS_NS;
works if full list is a skip list
------------------------------------------------------------------------- */
void Neighbor::half_full_no_newton(NeighList *list)
void Neighbor::half_from_full_no_newton(NeighList *list)
{
int i,j,ii,jj,n,jnum;
int *neighptr,*jlist;
@ -56,7 +56,7 @@ void Neighbor::half_full_no_newton(NeighList *list)
neighptr = &pages[npage][npnt];
n = 0;
// loop over full neighbor list
// loop over parent full list
i = ilist_full[ii];
jlist = firstneigh_full[i];
@ -86,7 +86,7 @@ void Neighbor::half_full_no_newton(NeighList *list)
works if full list is a skip list
------------------------------------------------------------------------- */
void Neighbor::half_full_newton(NeighList *list)
void Neighbor::half_from_full_newton(NeighList *list)
{
int i,j,ii,jj,n,jnum;
int *neighptr,*jlist;
@ -108,7 +108,7 @@ void Neighbor::half_full_newton(NeighList *list)
int npage = 0;
int npnt = 0;
// loop over atoms in full list
// loop over parent full list
for (ii = 0; ii < inum_full; ii++) {
@ -158,6 +158,7 @@ void Neighbor::half_full_newton(NeighList *list)
/* ----------------------------------------------------------------------
build skip list for subset of types from parent list
iskip and ijskip flag which atom types and type pairs to skip
this is for half and full lists
------------------------------------------------------------------------- */
void Neighbor::skip_from(NeighList *list)
@ -202,7 +203,7 @@ void Neighbor::skip_from(NeighList *list)
neighptr = &pages[npage][npnt];
n = 0;
// loop over full neighbor list
// loop over parent non-skip list
jlist = firstneigh_skip[i];
jnum = numneigh_skip[i];
@ -227,7 +228,258 @@ void Neighbor::skip_from(NeighList *list)
}
/* ----------------------------------------------------------------------
create list which is simply a copy of another list
build skip list for subset of types from parent list
iskip and ijskip flag which atom types and type pairs to skip
this is for granular lists with history, copy the history values from parent
------------------------------------------------------------------------- */
void Neighbor::skip_from_granular(NeighList *list)
{
int i,j,ii,jj,n,nn,itype,jnum,joriginal;
int *neighptr,*jlist,*touchptr,*touchptr_skip;
double *shearptr,*shearptr_skip;
int *type = atom->type;
int nall = atom->nlocal + atom->nghost;
int *ilist = list->ilist;
int *numneigh = list->numneigh;
int **firstneigh = list->firstneigh;
int **pages = list->pages;
int *ilist_skip = list->listskip->ilist;
int *numneigh_skip = list->listskip->numneigh;
int **firstneigh_skip = list->listskip->firstneigh;
int **firsttouch_skip = list->listskip->listgranhistory->firstneigh;
double **firstshear_skip = list->listskip->listgranhistory->firstdouble;
int inum_skip = list->listskip->inum;
int *iskip = list->iskip;
int **ijskip = list->ijskip;
NeighList *listgranhistory = list->listgranhistory;
int **firsttouch = listgranhistory->firstneigh;
double **firstshear = listgranhistory->firstdouble;
int **pages_touch = listgranhistory->pages;
double **pages_shear = listgranhistory->dpages;
int inum = 0;
int npage = 0;
int npnt = 0;
// 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[type[i]]) continue;
if (pgsize - npnt < oneatom) {
npnt = 0;
npage++;
if (npage == list->maxpage) {
pages = list->add_pages();
pages_touch = listgranhistory->add_pages();
pages_shear = listgranhistory->dpages;
}
}
n = 0;
neighptr = &pages[npage][npnt];
nn = 0;
touchptr = &pages_touch[npage][npnt];
shearptr = &pages_shear[npage][3*npnt];
// loop over parent non-skip granular list and its history info
touchptr_skip = firsttouch_skip[i];
shearptr_skip = firstshear_skip[i];
jlist = firstneigh_skip[i];
jnum = numneigh_skip[i];
for (jj = 0; jj < jnum; jj++) {
j = joriginal = jlist[jj];
if (j >= nall) j %= nall;
if (ijskip[itype][type[j]]) continue;
neighptr[n] = joriginal;
touchptr[n++] = touchptr_skip[jj];
shearptr[nn++] = shearptr_skip[3*jj];
shearptr[nn++] = shearptr_skip[3*jj+1];
shearptr[nn++] = shearptr_skip[3*jj+2];
}
ilist[inum] = i;
firstneigh[i] = neighptr;
numneigh[i] = n;
firsttouch[i] = touchptr;
firstshear[i] = shearptr;
inum++;
npnt += n;
if (npnt >= pgsize)
error->one("Neighbor list overflow, boost neigh_modify one or page");
}
list->inum = inum;
}
/* ----------------------------------------------------------------------
build skip list for subset of types from parent list
iskip and ijskip flag which atom types and type pairs to skip
this is for respa lists, copy the inner/middle values from parent
------------------------------------------------------------------------- */
void Neighbor::skip_from_respa(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 nall = atom->nlocal + atom->nghost;
int *ilist = list->ilist;
int *numneigh = list->numneigh;
int **firstneigh = list->firstneigh;
int **pages = list->pages;
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 *numneigh_inner = listinner->numneigh;
int **firstneigh_inner = listinner->firstneigh;
int **pages_inner = listinner->pages;
int *numneigh_inner_skip = list->listskip->listinner->numneigh;
int **firstneigh_inner_skip = list->listskip->listinner->firstneigh;
NeighList *listmiddle;
int *numneigh_middle,**firstneigh_middle,**pages_middle;
int *numneigh_middle_skip,**firstneigh_middle_skip;
int respamiddle = list->respamiddle;
if (respamiddle) {
listmiddle = list->listmiddle;
numneigh_middle = listmiddle->numneigh;
firstneigh_middle = listmiddle->firstneigh;
pages_middle = listmiddle->pages;
numneigh_middle_skip = list->listskip->listmiddle->numneigh;
firstneigh_middle_skip = list->listskip->listmiddle->firstneigh;
}
int inum = 0;
int npage = 0;
int npnt = 0;
int npage_inner = 0;
int npnt_inner = 0;
int npage_middle = 0;
int npnt_middle = 0;
// 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[type[i]]) continue;
if (pgsize - npnt < oneatom) {
npnt = 0;
npage++;
if (npage == list->maxpage) pages = list->add_pages();
}
neighptr = &pages[npage][npnt];
n = 0;
if (pgsize - npnt_inner < oneatom) {
npnt_inner = 0;
npage_inner++;
if (npage_inner == listinner->maxpage)
pages_inner = listinner->add_pages();
}
neighptr_inner = &pages_inner[npage_inner][npnt_inner];
n_inner = 0;
if (respamiddle) {
if (pgsize - npnt_middle < oneatom) {
npnt_middle = 0;
npage_middle++;
if (npage_middle == listmiddle->maxpage)
pages_middle = listmiddle->add_pages();
}
neighptr_middle = &pages_middle[npage_middle][npnt_middle];
n_middle = 0;
}
// loop over parent outer rRESPA list
jlist = firstneigh_skip[i];
jnum = numneigh_skip[i];
for (jj = 0; jj < jnum; jj++) {
j = joriginal = jlist[jj];
if (j >= nall) j %= nall;
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++) {
j = joriginal = jlist[jj];
if (j >= nall) j %= nall;
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++) {
j = joriginal = jlist[jj];
if (j >= nall) j %= nall;
if (ijskip[itype][type[j]]) continue;
neighptr_middle[n_middle++] = joriginal;
}
}
ilist[inum] = i;
firstneigh[i] = neighptr;
numneigh[i] = n;
inum++;
npnt += n;
if (npnt >= pgsize)
error->one("Neighbor list overflow, boost neigh_modify one or page");
firstneigh_inner[i] = neighptr_inner;
numneigh_inner[i] = n_inner;
npnt_inner += n_inner;
if (npnt_inner >= pgsize)
error->one("Neighbor list overflow, boost neigh_modify one or page");
if (respamiddle) {
firstneigh_middle[i] = neighptr_middle;
numneigh_middle[i] = n_middle;
npnt_middle += n_middle;
if (npnt_middle >= pgsize)
error->one("Neighbor list overflow, boost neigh_modify one or page");
}
}
list->inum = inum;
}
/* ----------------------------------------------------------------------
create list which is simply a copy of parent list
------------------------------------------------------------------------- */
void Neighbor::copy_from(NeighList *list)

2
src/neigh_request.h
View File

@ -32,7 +32,7 @@ class NeighRequest : protected Pointers {
int command;
// kind of list requested, one flag is 1, others are 0
// set by reqeusting class
// set by requesting class
int half; // 1 if half neigh list
int full; // 1 if full neigh list

153
src/neighbor.cpp
View File

@ -54,6 +54,8 @@ using namespace LAMMPS_NS;
enum{NSQ,BIN,MULTI}; // also in neigh_list.cpp
// #define NEIGH_LIST_DEBUG 1
/* ---------------------------------------------------------------------- */
Neighbor::Neighbor(LAMMPS *lmp) : Pointers(lmp)
@ -196,7 +198,11 @@ void Neighbor::init()
// set to 0 if cutforce = 0
// cutneighmin/max used for neighbor bin sizes
// cutghost determines comm distance = max of cutneigh & skin
// may need ghosts for bonds even if all cutneigh = 0 (pair = NULL)
// skin is only > cutneighmax when cutneighmax = 0.0 due to pair = NULL
// in this case, are running a bond-only simulation
// still need ghost atom communication for bonds and atom exchange
// triggered by atoms moving 1/2 skin distance, but no neigh lists formed
// user should set skin big enough to find all bonds
triggersq = 0.25*skin*skin;
@ -382,7 +388,9 @@ void Neighbor::init()
for (i = 0; i < nrequest; i++)
if (requests[i]->identical(old_requests[i]) == 0) same = 0;
printf("SAME %d\n",same);
#ifdef NEIGH_LIST_DEBUG
if (comm->me == 0) printf("SAME flag %d\n",same);
#endif
// if old and new are not the same, create new pairwise lists
@ -422,42 +430,47 @@ void Neighbor::init()
}
// detect lists that are connected to other lists
// if-the-else sequence is important
// since don't want to re-process skip or copy lists further down
// skip: point this list at request->otherlist, copy skip ptrs from request
// copy: point this list at request->otherlist
// half_from_full: point this list at preceeding full list
// granhistory: set preceeding list's listgranhistory to this list
// also set precedding list's ptr to FixShearHistory
// respaouter: point this list at preceeding 1/2 inner/middle lists
// pair and half and non-skip: if there is a pair full non-skip list,
// pair and half: if there is a full non-occasional non-skip list
// change this list to half_from_full and point at the full list
// parent could be copy list or pair or fix
// fix/compute requests:
// kind of request = half or full
// occasional or not doesn't matter
// if non-skip pair list of same kind exists, become copy of that list
// else if request is half and non-skip pair full exists,
// kind of request = half or full, occasional or not doesn't matter
// if request = half and non-skip pair half/respaouter exists,
// become copy of that list
// if request = full and non-skip pair full exists,
// become copy of that list
// if request = half and non-skip pair full exists,
// become half_from_full of that list
// else do nothing and the fix/compute list will be built directly
// if no matches, do nothing, fix/compute list will be built directly
// ok if parent is copy list
for (i = 0; i < nlist; i++) {
if (requests[i]->skip) {
lists[i]->listskip = lists[requests[i]->otherlist];
lists[i]->iskip = requests[i]->iskip;
lists[i]->ijskip = requests[i]->ijskip;
}
if (requests[i]->copy)
} else if (requests[i]->copy)
lists[i]->listcopy = lists[requests[i]->otherlist];
if (requests[i]->half_from_full) lists[i]->listfull = lists[i-1];
else if (requests[i]->half_from_full)
lists[i]->listfull = lists[i-1];
if (requests[i]->granhistory) {
else if (requests[i]->granhistory) {
lists[i-1]->listgranhistory = lists[i];
for (int ifix = 0; ifix < modify->nfix; ifix++)
if (strcmp(modify->fix[ifix]->style,"SHEAR_HISTORY") == 0)
lists[i-1]->fix_history = (FixShearHistory *) modify->fix[ifix];
}
if (requests[i]->respaouter) {
} else if (requests[i]->respaouter) {
if (requests[i-1]->respainner) {
lists[i]->respamiddle = 0;
lists[i]->listinner = lists[i-1];
@ -466,33 +479,33 @@ void Neighbor::init()
lists[i]->listmiddle = lists[i-1];
lists[i]->listinner = lists[i-2];
}
}
if (requests[i]->pair && requests[i]->half && requests[i]->skip == 0) {
} else if (requests[i]->pair && requests[i]->half) {
for (j = 0; j < nlist; j++)
if (requests[j]->pair && requests[j]->full &&
if (requests[j]->full && requests[j]->occasional == 0 &&
requests[j]->skip == 0) break;
if (j < nlist) {
requests[i]->half = 0;
requests[i]->half_from_full = 1;
lists[i]->listfull = lists[j];
}
}
if (requests[i]->fix || requests[i]->compute) {
} else if (requests[i]->fix || requests[i]->compute) {
for (j = 0; j < nlist; j++) {
if (requests[j]->pair && requests[j]->skip == 0 &&
requests[j]->half && requests[i]->half) break;
if (requests[j]->pair && requests[j]->skip == 0 &&
requests[j]->full && requests[i]->full) break;
if (requests[i]->half && requests[j]->pair &&
requests[j]->skip == 0 && requests[j]->half) break;
if (requests[i]->full && requests[j]->pair &&
requests[j]->skip == 0 && requests[j]->full) break;
if (requests[i]->half && requests[j]->pair &&
requests[j]->skip == 0 && requests[j]->respaouter) break;
}
if (j < nlist) {
requests[i]->copy = 1;
lists[i]->listcopy = lists[j];
} else {
for (j = 0; j < nlist; j++) {
if (requests[j]->pair && requests[j]->skip == 0 &&
requests[j]->full && requests[i]->half) break;
if (requests[i]->half && requests[j]->pair &&
requests[j]->skip == 0 && requests[j]->full) break;
}
if (j < nlist) {
requests[i]->half = 0;
@ -530,10 +543,10 @@ void Neighbor::init()
if (stencil_create[i] == NULL) lists[i]->stencilflag = 0;
}
// DEBUG: print list attributes
#ifdef NEIGH_LIST_DEBUG
for (i = 0; i < nlist; i++) lists[i]->print_attributes();
#endif
// allocate atom arrays and 1st pages of lists that store them
for (i = 0; i < nlist; i++)
@ -565,23 +578,13 @@ void Neighbor::init()
slist[nslist++] = i;
}
// DEBUG: print lists of lists
if (comm->me == 0) {
printf("Build lists = %d: ",nblist);
for (i = 0; i < nblist; i++) printf("%d ",blist[i]);
printf("\n");
printf("Grow lists = %d: ",nglist);
for (i = 0; i < nglist; i++) printf("%d ",glist[i]);
printf("\n");
printf("Stencil lists = %d: ",nslist);
for (i = 0; i < nslist; i++) printf("%d ",slist[i]);
printf("\n");
}
#ifdef NEIGH_LIST_DEBUG
print_lists_of_lists();
#endif
// reorder build vector if necessary
// relevant for lists that copy/skip/half-full from parent
// the derived lst must appear in blist after the parent list
// the derived list must appear in blist after the parent list
// no occasional lists are in build vector
// swap two lists within blist when dependency is mis-ordered
// done when entire pass thru blist results in no swaps
@ -608,19 +611,9 @@ void Neighbor::init()
}
}
// DEBUG: print lists of lists
if (comm->me == 0) {
printf("Build lists = %d: ",nblist);
for (i = 0; i < nblist; i++) printf("%d ",blist[i]);
printf("\n");
printf("Grow lists = %d: ",nglist);
for (i = 0; i < nglist; i++) printf("%d ",glist[i]);
printf("\n");
printf("Stencil lists = %d: ",nslist);
for (i = 0; i < nslist; i++) printf("%d ",slist[i]);
printf("\n");
}
#ifdef NEIGH_LIST_DEBUG
print_lists_of_lists();
#endif
}
// delete old requests
@ -750,11 +743,13 @@ int Neighbor::request(void *requestor)
return nrequest-1;
}
/* ----------------------------------------------------------------------
determine which pair_build function each neigh list needs
based on settings of neigh request
skip or copy -> single function
copy -> copy_from function
skip -> granular function if gran with granhistory
respa function if respaouter
skip_from function for everything else
half_from_full, half, full, gran, respaouter -> choose by newton and tri
style NSQ options = newton off, newton on
style BIN options = newton off, newton on and not tri, newton on and tri
@ -767,13 +762,17 @@ void Neighbor::choose_build(int index, NeighRequest *rq)
{
PairPtr pb = NULL;
if (rq->skip) pb = &Neighbor::skip_from;
if (rq->copy) pb = &Neighbor::copy_from;
else if (rq->copy) pb = &Neighbor::copy_from;
else if (rq->skip) {
if (rq->gran && lists[index]->listgranhistory)
pb = &Neighbor::skip_from_granular;
else if (rq->respaouter) pb = &Neighbor::skip_from_respa;
else pb = &Neighbor::skip_from;
else if (rq->half_from_full) {
if (newton_pair == 0) pb = &Neighbor::half_full_no_newton;
else if (newton_pair == 1) pb = &Neighbor::half_full_newton;
} else if (rq->half_from_full) {
if (newton_pair == 0) pb = &Neighbor::half_from_full_no_newton;
else if (newton_pair == 1) pb = &Neighbor::half_from_full_newton;
} else if (rq->half) {
if (style == NSQ) {
@ -878,6 +877,23 @@ void Neighbor::choose_stencil(int index, NeighRequest *rq)
/* ---------------------------------------------------------------------- */
void Neighbor::print_lists_of_lists()
{
if (comm->me == 0) {
printf("Build lists = %d: ",nblist);
for (int i = 0; i < nblist; i++) printf("%d ",blist[i]);
printf("\n");
printf("Grow lists = %d: ",nglist);
for (int i = 0; i < nglist; i++) printf("%d ",glist[i]);
printf("\n");
printf("Stencil lists = %d: ",nslist);
for (int i = 0; i < nslist; i++) printf("%d ",slist[i]);
printf("\n");
}
}
/* ---------------------------------------------------------------------- */
int Neighbor::decide()
{
if (must_check) {
@ -968,17 +984,6 @@ void Neighbor::build()
for (i = 0; i < nblist; i++)
(this->*pair_build[blist[i]])(lists[blist[i]]);
/*
if (comm->me == 0) {
for (int m = 0; m < nlist; m++) {
int num = 0;
for (i = 0; i < lists[m]->inum; i++)
num += lists[m]->numneigh[lists[m]->ilist[i]];
printf("List %d length = %d\n",m,num);
}
}
*/
if (atom->molecular) {
if (atom->nbonds) (this->*bond_build)();
if (atom->nangles) (this->*angle_build)();

21
src/neighbor.h
View File

@ -58,13 +58,14 @@ class Neighbor : protected Pointers {
Neighbor(class LAMMPS *);
~Neighbor();
void init();
int request(void *); // another class requests a neighbor list
int decide(); // decide whether to build or not
int check_distance(); // check max distance moved since last build
void setup_bins(); // setup bins based on box and cutoff
void build(); // create all neighbor lists (pair,bond)
void build_one(int); // create a single neighbor list
void set(int, char **); // set neighbor style and skin distance
int request(void *); // another class requests a neighbor list
void print_lists_of_lists(); // debug print out
int decide(); // decide whether to build or not
int check_distance(); // check max distance moved since last build
void setup_bins(); // setup bins based on box and cutoff
void build(); // create all neighbor lists (pair,bond)
void build_one(int); // create a single neighbor list
void set(int, char **); // set neighbor style and skin distance
void modify_params(int, char**); // modify parameters that control builds
double memory_usage();
@ -169,9 +170,11 @@ class Neighbor : protected Pointers {
void full_bin(class NeighList *);
void full_multi(class NeighList *);
void half_full_no_newton(class NeighList *);
void half_full_newton(class NeighList *);
void half_from_full_no_newton(class NeighList *);
void half_from_full_newton(class NeighList *);
void skip_from(class NeighList *);
void skip_from_granular(class NeighList *);
void skip_from_respa(class NeighList *);
void copy_from(class NeighList *);
void granular_nsq_no_newton(class NeighList *);

47
src/pair_hybrid.cpp
View File

@ -316,16 +316,10 @@ void PairHybrid::init_style()
for (istyle = 0; istyle < nstyles; istyle++) styles[istyle]->init_style();
// create skip lists for each neigh request
// any kind of list can have its skip flag set at this stage
for (i = 0; i < neighbor->nrequest; i++) {
// only relevant for half, full, gran, respaouter lists
if (neighbor->requests[i]->granhistory) continue;
if (neighbor->requests[i]->respamiddle) continue;
if (neighbor->requests[i]->respainner) continue;
if (neighbor->requests[i]->half_from_full) continue;
// find associated sub-style
for (istyle = 0; istyle < nstyles; istyle++)
@ -435,23 +429,44 @@ double PairHybrid::init_one(int i, int j)
void PairHybrid::modify_requests()
{
int i,j;
NeighRequest *irq,*jrq;
// if list is skip list, look for non-skip list of same kind
// if list is skip list and not copy, look for non-skip list of same kind
// if one exists, point at that one
// else make new non-skip request of same kind and point at that one
// don't bother to set ID for new request, since pair hybrid ignores list
// only exception is half_from_full:
// ignore it, turn off skip, since it will derive from its skip parent
// after possible new request creation, unset skip flag and otherlist
// for these derived lists: granhistory, rRESPA inner/middle
// this prevents neighbor from treating them as skip lists
// copy list check is for pair style = hybrid/overlay
// which invokes this routine
for (i = 0; i < neighbor->nrequest; i++) {
if (neighbor->requests[i]->skip == 0) continue;
irq = neighbor->requests[i];
if (irq->skip == 0 || irq->copy) continue;
if (irq->half_from_full) {
irq->skip = 0;
continue;
}
for (j = 0; j < neighbor->nrequest; j++)
if (neighbor->requests[i]->same_kind(neighbor->requests[j]) &&
neighbor->requests[j]->skip == 0) break;
for (j = 0; j < neighbor->nrequest; j++) {
jrq = neighbor->requests[j];
if (irq->same_kind(jrq) && jrq->skip == 0) break;
}
if (j < neighbor->nrequest) neighbor->requests[i]->otherlist = j;
if (j < neighbor->nrequest) irq->otherlist = j;
else {
int irequest = neighbor->request(this);
neighbor->requests[irequest]->copy_kind(neighbor->requests[i]);
neighbor->requests[i]->otherlist = irequest;
int newrequest = neighbor->request(this);
neighbor->requests[newrequest]->copy_kind(irq);
neighbor->requests[newrequest]->dnum = irq->dnum;
irq->otherlist = newrequest;
}
if (irq->granhistory || irq->respainner || irq->respamiddle) {
irq->skip = 0;
irq->otherlist = -1;
}
}
}

24
src/pair_hybrid_overlay.cpp
View File

@ -103,7 +103,8 @@ void PairHybridOverlay::modify_requests()
// loop over pair requests
// if a previous list is same kind with same skip attributes
// then make this one a copy list of that one
// NOTE: SHOULD I SKIP granhistory, respamiddle, halffromfull ??
// works whether both lists are no-skip or yes-skip
// will not point a list at a copy list, but at copy list's parent
for (i = 0; i < neighbor->nrequest; i++) {
irq = neighbor->requests[i];
@ -117,24 +118,7 @@ void PairHybridOverlay::modify_requests()
}
}
// if list is skip list and not copy, look for non-skip list of same kind
// if one exists, point at that one
// else make new non-skip request of same kind and point at that one
// perform same operations on skip lists as pair style = hybrid
for (i = 0; i < neighbor->nrequest; i++) {
irq = neighbor->requests[i];
if (irq->skip == 0 || irq->copy) continue;
for (j = 0; j < neighbor->nrequest; j++) {
jrq = neighbor->requests[j];
if (irq->same_kind(jrq) && jrq->skip == 0) break;
}
if (j < neighbor->nrequest) irq->otherlist = j;
else {
int newrequest = neighbor->request(this);
neighbor->requests[newrequest]->copy_kind(irq);
irq->otherlist = newrequest;
}
}
PairHybrid::modify_requests();
}

20
src/style_user_ackland.h
View File

@ -1,20 +0,0 @@
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#ifdef ComputeInclude
#include "compute_ackland_atom.h"
#endif
#ifdef ComputeClass
ComputeStyle(ackland/atom,ComputeAcklandAtom)
#endif