ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Copying more variables to classes and moving/clarifying definitions

Browse Source
This commit is contained in:
Joel Clemmer
2020-11-12 18:37:53 -07:00
parent 6909839ff0
commit af11a54a27
14 changed files with 252 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
src/nbin.cpp
View File

@ -123,3 +123,96 @@ void NBin::copy_neighbor_info()
if (cutoff_custom > 0.0) cutneighmax = cutoff_custom;
}
/* ----------------------------------------------------------------------
convert atom coords into local bin #
for orthogonal, only ghost atoms will have coord >= bboxhi or coord < bboxlo
take special care to insure ghosts are in correct bins even w/ roundoff
hi ghost atoms = nbin,nbin+1,etc
owned atoms = 0 to nbin-1
lo ghost atoms = -1,-2,etc
this is necessary so that both procs on either side of PBC
treat a pair of atoms straddling the PBC in a consistent way
for triclinic, doesn't matter since stencil & neigh list built differently
------------------------------------------------------------------------- */
int NBin::coord2bin(double *x)
{
int ix,iy,iz;
if (!std::isfinite(x[0]) || !std::isfinite(x[1]) || !std::isfinite(x[2]))
error->one(FLERR,"Non-numeric positions - simulation unstable");
if (x[0] >= bboxhi[0])
ix = static_cast<int> ((x[0]-bboxhi[0])*bininvx) + nbinx;
else if (x[0] >= bboxlo[0]) {
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx);
ix = MIN(ix,nbinx-1);
} else
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx) - 1;
if (x[1] >= bboxhi[1])
iy = static_cast<int> ((x[1]-bboxhi[1])*bininvy) + nbiny;
else if (x[1] >= bboxlo[1]) {
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy);
iy = MIN(iy,nbiny-1);
} else
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy) - 1;
if (x[2] >= bboxhi[2])
iz = static_cast<int> ((x[2]-bboxhi[2])*bininvz) + nbinz;
else if (x[2] >= bboxlo[2]) {
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz);
iz = MIN(iz,nbinz-1);
} else
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz) - 1;
return (iz-mbinzlo)*mbiny*mbinx + (iy-mbinylo)*mbinx + (ix-mbinxlo);
}
/* ----------------------------------------------------------------------
convert atom coords into local bin # for a particular type
------------------------------------------------------------------------- */
int NBin::coord2bin_multi2(double *x, int it)
{
int ix,iy,iz;
int ibin;
if (!std::isfinite(x[0]) || !std::isfinite(x[1]) || !std::isfinite(x[2]))
error->one(FLERR,"Non-numeric positions - simulation unstable");
if (x[0] >= bboxhi[0])
ix = static_cast<int> ((x[0]-bboxhi[0])*bininvx_multi2[it]) + nbinx_multi2[it];
else if (x[0] >= bboxlo[0]) {
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx_multi2[it]);
ix = MIN(ix,nbinx_multi2[it]-1);
} else
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx_multi2[it]) - 1;
if (x[1] >= bboxhi[1])
iy = static_cast<int> ((x[1]-bboxhi[1])*bininvy_multi2[it]) + nbiny_multi2[it];
else if (x[1] >= bboxlo[1]) {
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy_multi2[it]);
iy = MIN(iy,nbiny_multi2[it]-1);
} else
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy_multi2[it]) - 1;
if (x[2] >= bboxhi[2])
iz = static_cast<int> ((x[2]-bboxhi[2])*bininvz_multi2[it]) + nbinz_multi2[it];
else if (x[2] >= bboxlo[2]) {
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz_multi2[it]);
iz = MIN(iz,nbinz_multi2[it]-1);
} else
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz_multi2[it]) - 1;
ibin = (iz-mbinzlo_multi2[it])*mbiny_multi2[it]*mbinx_multi2[it]
+ (iy-mbinylo_multi2[it])*mbinx_multi2[it]
+ (ix-mbinxlo_multi2[it]);
return ibin;
}

2
src/nbin.h
View File

@ -97,7 +97,7 @@ class NBin : protected Pointers {
// methods
int coord2bin(double *);
int coord2bin(double *, int);
int coord2bin_multi2(double *, int);
};
}

58
src/nbin_multi2.cpp
View File

@ -324,7 +324,7 @@ void NBinMulti2::bin_atoms()
for (i = nall-1; i >= nlocal; i--) {
if (mask[i] & bitmask) {
n = type[i];
ibin = coord2bin(x[i], n);
ibin = coord2bin_multi2(x[i], n);
atom2bin_multi2[n][i] = ibin;
bins_multi2[n][i] = binhead_multi2[n][ibin];
binhead_multi2[n][ibin] = i;
@ -332,7 +332,7 @@ void NBinMulti2::bin_atoms()
}
for (i = atom->nfirst-1; i >= 0; i--) {
n = type[i];
ibin = coord2bin(x[i], n);
ibin = coord2bin_multi2(x[i], n);
atom2bin_multi2[n][i] = ibin;
bins_multi2[n][i] = binhead_multi2[n][ibin];
binhead_multi2[n][ibin] = i;
@ -340,7 +340,7 @@ void NBinMulti2::bin_atoms()
} else {
for (i = nall-1; i >= 0; i--) {
n = type[i];
ibin = coord2bin(x[i], n);
ibin = coord2bin_multi2(x[i], n);
atom2bin_multi2[n][i] = ibin;
bins_multi2[n][i] = binhead_multi2[n][ibin];
binhead_multi2[n][ibin] = i;
@ -348,58 +348,6 @@ void NBinMulti2::bin_atoms()
}
}
/* ----------------------------------------------------------------------
convert atom coords into local bin # for a particular type
for orthogonal, only ghost atoms will have coord >= bboxhi or coord < bboxlo
take special care to insure ghosts are in correct bins even w/ roundoff
hi ghost atoms = nbin,nbin+1,etc
owned atoms = 0 to nbin-1
lo ghost atoms = -1,-2,etc
this is necessary so that both procs on either side of PBC
treat a pair of atoms straddling the PBC in a consistent way
for triclinic, doesn't matter since stencil & neigh list built differently
------------------------------------------------------------------------- */
int NBinMulti2::coord2bin(double *x, int it)
{
int ix,iy,iz;
int ibin;
if (!std::isfinite(x[0]) || !std::isfinite(x[1]) || !std::isfinite(x[2]))
error->one(FLERR,"Non-numeric positions - simulation unstable");
if (x[0] >= bboxhi[0])
ix = static_cast<int> ((x[0]-bboxhi[0])*bininvx_multi2[it]) + nbinx_multi2[it];
else if (x[0] >= bboxlo[0]) {
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx_multi2[it]);
ix = MIN(ix,nbinx_multi2[it]-1);
} else
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx_multi2[it]) - 1;
if (x[1] >= bboxhi[1])
iy = static_cast<int> ((x[1]-bboxhi[1])*bininvy_multi2[it]) + nbiny_multi2[it];
else if (x[1] >= bboxlo[1]) {
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy_multi2[it]);
iy = MIN(iy,nbiny_multi2[it]-1);
} else
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy_multi2[it]) - 1;
if (x[2] >= bboxhi[2])
iz = static_cast<int> ((x[2]-bboxhi[2])*bininvz_multi2[it]) + nbinz_multi2[it];
else if (x[2] >= bboxlo[2]) {
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz_multi2[it]);
iz = MIN(iz,nbinz_multi2[it]-1);
} else
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz_multi2[it]) - 1;
ibin = (iz-mbinzlo_multi2[it])*mbiny_multi2[it]*mbinx_multi2[it]
+ (iy-mbinylo_multi2[it])*mbinx_multi2[it]
+ (ix-mbinxlo_multi2[it]);
return ibin;
}
/* ---------------------------------------------------------------------- */
double NBinMulti2::memory_usage()

1
src/nbin_multi2.h
View File

@ -38,7 +38,6 @@ class NBinMulti2 : public NBin {
private:
int coord2bin(double *, int);
int itype_min();
};

48
src/nbin_standard.cpp
View File

@ -259,54 +259,6 @@ void NBinStandard::bin_atoms()
}
}
/* ----------------------------------------------------------------------
convert atom coords into local bin #
for orthogonal, only ghost atoms will have coord >= bboxhi or coord < bboxlo
take special care to insure ghosts are in correct bins even w/ roundoff
hi ghost atoms = nbin,nbin+1,etc
owned atoms = 0 to nbin-1
lo ghost atoms = -1,-2,etc
this is necessary so that both procs on either side of PBC
treat a pair of atoms straddling the PBC in a consistent way
for triclinic, doesn't matter since stencil & neigh list built differently
------------------------------------------------------------------------- */
int NBinStandard::coord2bin(double *x)
{
int ix,iy,iz;
if (!std::isfinite(x[0]) || !std::isfinite(x[1]) || !std::isfinite(x[2]))
error->one(FLERR,"Non-numeric positions - simulation unstable");
if (x[0] >= bboxhi[0])
ix = static_cast<int> ((x[0]-bboxhi[0])*bininvx) + nbinx;
else if (x[0] >= bboxlo[0]) {
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx);
ix = MIN(ix,nbinx-1);
} else
ix = static_cast<int> ((x[0]-bboxlo[0])*bininvx) - 1;
if (x[1] >= bboxhi[1])
iy = static_cast<int> ((x[1]-bboxhi[1])*bininvy) + nbiny;
else if (x[1] >= bboxlo[1]) {
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy);
iy = MIN(iy,nbiny-1);
} else
iy = static_cast<int> ((x[1]-bboxlo[1])*bininvy) - 1;
if (x[2] >= bboxhi[2])
iz = static_cast<int> ((x[2]-bboxhi[2])*bininvz) + nbinz;
else if (x[2] >= bboxlo[2]) {
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz);
iz = MIN(iz,nbinz-1);
} else
iz = static_cast<int> ((x[2]-bboxlo[2])*bininvz) - 1;
return (iz-mbinzlo)*mbiny*mbinx + (iy-mbinylo)*mbinx + (ix-mbinxlo);
}
/* ---------------------------------------------------------------------- */
double NBinStandard::memory_usage()

4
src/nbin_standard.h
View File

@ -34,10 +34,6 @@ class NBinStandard : public NBin {
void setup_bins(int);
void bin_atoms();
double memory_usage();
private:
int coord2bin(double *);
};
}

119
src/nstencil.cpp
View File

@ -124,13 +124,17 @@ NStencil::~NStencil()
memory->destroy(stencil_bin_type);
memory->destroy(stencil_cut);
memory->destroy(sx_multi2);
memory->destroy(sy_multi2);
memory->destroy(sz_multi2);
memory->destroy(stencil_sx_multi2);
memory->destroy(stencil_sy_multi2);
memory->destroy(stencil_sz_multi2);
memory->destroy(stencil_mbinx_multi2);
memory->destroy(stencil_mbiny_multi2);
memory->destroy(stencil_mbinz_multi2);
memory->destroy(binsizex_multi2);
memory->destroy(binsizey_multi2);
memory->destroy(binsizez_multi2);
memory->destroy(stencil_binsizex_multi2);
memory->destroy(stencil_binsizey_multi2);
memory->destroy(stencil_binsizez_multi2);
}
}
@ -181,20 +185,20 @@ void NStencil::copy_bin_info()
}
/* ----------------------------------------------------------------------
copy needed info for a given type from NBin class to this stencil class
copy needed info for multi2 from NBin class to this stencil class
------------------------------------------------------------------------- */
void NStencil::copy_bin_info_multi2(int type)
void NStencil::copy_bin_info_multi2()
{
mbinx = nb->mbinx_multi2[type];
mbiny = nb->mbiny_multi2[type];
mbinz = nb->mbinz_multi2[type];
binsizex = nb->binsizex_multi2[type];
binsizey = nb->binsizey_multi2[type];
binsizez = nb->binsizez_multi2[type];
bininvx = nb->bininvx_multi2[type];
bininvy = nb->bininvy_multi2[type];
bininvz = nb->bininvz_multi2[type];
mbinx_multi2 = nb->mbinx_multi2;
mbiny_multi2 = nb->mbiny_multi2;
mbinz_multi2 = nb->mbinz_multi2;
binsizex_multi2 = nb->binsizex_multi2;
binsizey_multi2 = nb->binsizey_multi2;
binsizez_multi2 = nb->binsizez_multi2;
bininvx_multi2 = nb->bininvx_multi2;
bininvy_multi2 = nb->bininvy_multi2;
bininvz_multi2 = nb->bininvz_multi2;
}
/* ----------------------------------------------------------------------
@ -266,6 +270,8 @@ void NStencil::create_setup()
int i, j, bin_type, smax;
double stencil_range;
int n = atom->ntypes;
if(nb) copy_bin_info_multi2();
// Allocate arrays to store stencil information
memory->create(stencil_half, n+1, n+1,
@ -277,20 +283,26 @@ void NStencil::create_setup()
memory->create(stencil_cut, n+1, n+1,
"neighstencil:stencil_cut");
memory->create(sx_multi2, n+1, n+1, "neighstencil:sx_multi2");
memory->create(sy_multi2, n+1, n+1, "neighstencil:sy_multi2");
memory->create(sz_multi2, n+1, n+1, "neighstencil:sz_multi2");
memory->create(stencil_sx_multi2, n+1, n+1,
"neighstencil:stencil_sx_multi2");
memory->create(stencil_sy_multi2, n+1, n+1,
"neighstencil:stencil_sy_multi2");
memory->create(stencil_sz_multi2, n+1, n+1,
"neighstencil:stencil_sz_multi2");
memory->create(binsizex_multi2, n+1, n+1,
"neighstencil:binsizex_multi2");
memory->create(binsizey_multi2, n+1, n+1,
"neighstencil:binsizey_multi2");
memory->create(binsizez_multi2, n+1, n+1,
"neighstencil:binsizez_multi2");
memory->create(stencil_binsizex_multi2, n+1, n+1,
"neighstencil:stencil_binsizex_multi2");
memory->create(stencil_binsizey_multi2, n+1, n+1,
"neighstencil:stencil_binsizey_multi2");
memory->create(stencil_binsizez_multi2, n+1, n+1,
"neighstencil:stencil_binsizez_multi2");
memory->create(mbinx_multi2, n+1, n+1, "neighstencil:mbinx_multi2");
memory->create(mbiny_multi2, n+1, n+1, "neighstencil:mbiny_multi2");
memory->create(mbinz_multi2, n+1, n+1, "neighstencil:mbinz_multi2");
memory->create(stencil_mbinx_multi2, n+1, n+1,
"neighstencil:stencil_mbinx_multi2");
memory->create(stencil_mbiny_multi2, n+1, n+1,
"neighstencil:stencil_mbiny_multi2");
memory->create(stencil_mbinz_multi2, n+1, n+1,
"neighstencil:stencil_mbinz_multi2");
// Skip all stencils by default, initialize smax
for (i = 1; i <= n; i++) {
@ -324,28 +336,27 @@ void NStencil::create_setup()
// Copy bin info for this particular pair of types
bin_type = stencil_bin_type[i][j];
copy_bin_info_multi2(bin_type);
binsizex_multi2[i][j] = binsizex;
binsizey_multi2[i][j] = binsizey;
binsizez_multi2[i][j] = binsizez;
stencil_binsizex_multi2[i][j] = binsizex_multi2[bin_type];
stencil_binsizey_multi2[i][j] = binsizey_multi2[bin_type];
stencil_binsizez_multi2[i][j] = binsizez_multi2[bin_type];
mbinx_multi2[i][j] = mbinx;
mbiny_multi2[i][j] = mbiny;
mbinz_multi2[i][j] = mbinz;
stencil_mbinx_multi2[i][j] = mbinx_multi2[bin_type];
stencil_mbiny_multi2[i][j] = mbiny_multi2[bin_type];
stencil_mbinz_multi2[i][j] = mbinz_multi2[bin_type];
stencil_range = stencil_cut[i][j];
sx = static_cast<int> (stencil_range*bininvx);
sx = static_cast<int> (stencil_range*bininvx_multi2[bin_type]);
if (sx*binsizex < stencil_range) sx++;
sy = static_cast<int> (stencil_range*bininvy);
sy = static_cast<int> (stencil_range*bininvy_multi2[bin_type]);
if (sy*binsizey < stencil_range) sy++;
sz = static_cast<int> (stencil_range*bininvz);
sz = static_cast<int> (stencil_range*bininvz_multi2[bin_type]);
if (sz*binsizez < stencil_range) sz++;
sx_multi2[i][j] = sx;
sy_multi2[i][j] = sy;
sz_multi2[i][j] = sz;
stencil_sx_multi2[i][j] = sx;
stencil_sy_multi2[i][j] = sy;
stencil_sz_multi2[i][j] = sz;
smax = ((2*sx+1) * (2*sy+1) * (2*sz+1));
@ -383,6 +394,30 @@ double NStencil::bin_distance(int i, int j, int k)
return (delx*delx + dely*dely + delz*delz);
}
/* ----------------------------------------------------------------------
compute closest distance for a given atom type
------------------------------------------------------------------------- */
double NStencil::bin_distance_multi2(int i, int j, int k, int type)
{
double delx,dely,delz;
if (i > 0) delx = (i-1)*binsizex_multi2[type];
else if (i == 0) delx = 0.0;
else delx = (i+1)*binsizex_multi2[type];
if (j > 0) dely = (j-1)*binsizey_multi2[type];
else if (j == 0) dely = 0.0;
else dely = (j+1)*binsizey_multi2[type];
if (k > 0) delz = (k-1)*binsizez_multi2[type];
else if (k == 0) delz = 0.0;
else delz = (k+1)*binsizez_multi2[type];
return (delx*delx + dely*dely + delz*delz);
}
/* ---------------------------------------------------------------------- */
double NStencil::memory_usage()

47
src/nstencil.h
View File

@ -39,13 +39,13 @@ class NStencil : protected Pointers {
// Probably not needed for multi2 since bins are more efficiently chosen
int sx,sy,sz; // extent of stencil in each dim
int **sx_multi2; // analogs for multi tiered
int **sy_multi2;
int **sz_multi2;
int **stencil_sx_multi2; // analogs for each multi2 stencil
int **stencil_sy_multi2;
int **stencil_sz_multi2;
double cutoff_custom; // cutoff set by requestor
// Arrays to store options for multi/tiered itype-jtype stencils
// Arrays to store options for multi2 itype-jtype stencils
bool **stencil_half; // flag creation of a half stencil for itype-jtype
bool **stencil_skip; // skip creation of itype-jtype stencils (for newton on)
int **stencil_bin_type; // what type to use for bin information
@ -78,15 +78,27 @@ class NStencil : protected Pointers {
double binsizex,binsizey,binsizez;
double bininvx,bininvy,bininvz;
// analogs for multi-tiered
// data from NBin class for multi2
int *mbinx_multi2;
int *mbiny_multi2;
int *mbinz_multi2;
double *binsizex_multi2;
double *binsizey_multi2;
double *binsizez_multi2;
double *bininvx_multi2;
double *bininvy_multi2;
double *bininvz_multi2;
// Stored bin information for each stencil
int **stencil_mbinx_multi2;
int **stencil_mbiny_multi2;
int **stencil_mbinz_multi2;
double **stencil_binsizex_multi2;
double **stencil_binsizey_multi2;
double **stencil_binsizez_multi2;
int **mbinx_multi2;
int **mbiny_multi2;
int **mbinz_multi2;
double **binsizex_multi2;
double **binsizey_multi2;
double **binsizez_multi2;
// data common to all NStencil variants
int xyzflag; // 1 if stencilxyz is allocated
@ -95,15 +107,16 @@ class NStencil : protected Pointers {
int dimension;
// methods for all NStencil variants
// methods for standard NStencil variants
void copy_bin_info(); // copy info from NBin class
double bin_distance(int, int, int); // distance between bin corners
// methods for multi/tiered NStencil
void copy_bin_info_multi2(int); // copy mult/tiered info from NBin class
virtual void set_stencil_properties(){} // determine which stencils to build and how
// methods for multi2 NStencil
double bin_distance_multi2(int, int, int, int); // distance between bin corners for different types
void copy_bin_info_multi2(); // copy mult2 info from NBin class
virtual void set_stencil_properties(){} // determine which stencils to build and how
};
}

17
src/nstencil_full_multi2_2d.cpp
View File

@ -68,7 +68,7 @@ void NStencilFullMulti22d::set_stencil_properties()
void NStencilFullMulti22d::create()
{
int itype, jtype, i, j, k, ns;
int itype, jtype, bin_type, i, j, k, ns;
int n = atom->ntypes;
double cutsq;
@ -79,22 +79,19 @@ void NStencilFullMulti22d::create()
ns = 0;
sx = sx_multi2[itype][jtype];
sy = sy_multi2[itype][jtype];
sx = stencil_sx_multi2[itype][jtype];
sy = stencil_sy_multi2[itype][jtype];
mbinx = mbinx_multi2[itype][jtype];
mbiny = mbiny_multi2[itype][jtype];
mbinx = stencil_mbinx_multi2[itype][jtype];
mbiny = stencil_mbiny_multi2[itype][jtype];
// Redefine for use in bin_distance()
binsizex = binsizex_multi2[itype][jtype];
binsizey = binsizey_multi2[itype][jtype];
binsizez = binsizez_multi2[itype][jtype];
bin_type = stencil_bin_type[i][j];
cutsq = stencil_cut[itype][jtype];
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance(i,j,0) < cutsq)
if (bin_distance_multi2(i,j,0,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] = j*mbinx + i;
nstencil_multi2[itype][jtype] = ns;

21
src/nstencil_full_multi2_3d.cpp
View File

@ -68,7 +68,7 @@ void NStencilFullMulti23d::set_stencil_properties()
void NStencilFullMulti23d::create()
{
int itype, jtype, i, j, k, ns;
int itype, jtype, bin_type, i, j, k, ns;
int n = atom->ntypes;
double cutsq;
@ -79,25 +79,22 @@ void NStencilFullMulti23d::create()
ns = 0;
sx = sx_multi2[itype][jtype];
sy = sy_multi2[itype][jtype];
sz = sz_multi2[itype][jtype];
sx = stencil_sx_multi2[itype][jtype];
sy = stencil_sy_multi2[itype][jtype];
sz = stencil_sz_multi2[itype][jtype];
mbinx = mbinx_multi2[itype][jtype];
mbiny = mbiny_multi2[itype][jtype];
mbinz = mbinz_multi2[itype][jtype];
mbinx = stencil_mbinx_multi2[itype][jtype];
mbiny = stencil_mbiny_multi2[itype][jtype];
mbinz = stencil_mbinz_multi2[itype][jtype];
// Redefine for use in bin_distance()
binsizex = binsizex_multi2[itype][jtype];
binsizey = binsizey_multi2[itype][jtype];
binsizez = binsizez_multi2[itype][jtype];
bin_type = stencil_bin_type[i][j];
cutsq = stencil_cut[itype][jtype];
for (k = -sz; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance(i,j,k) < cutsq)
if (bin_distance_multi2(i,j,k,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] =
k*mbiny*mbinx + j*mbinx + i;

13
src/nstencil_half_multi2_2d.cpp
View File

@ -82,16 +82,11 @@ void NStencilHalfMulti22d::create()
ns = 0;
sx = sx_multi2[itype][jtype];
sy = sy_multi2[itype][jtype];
sx = stencil_sx_multi2[itype][jtype];
sy = stencil_sy_multi2[itype][jtype];
mbinx = mbinx_multi2[itype][jtype];
mbiny = mbiny_multi2[itype][jtype];
// Redefine for use in bin_distance()
binsizex = binsizex_multi2[itype][jtype];
binsizey = binsizey_multi2[itype][jtype];
binsizez = binsizez_multi2[itype][jtype];
mbinx = stencil_mbinx_multi2[itype][jtype];
mbiny = stencil_mbiny_multi2[itype][jtype];
cutsq = stencil_cut[itype][jtype];

19
src/nstencil_half_multi2_2d_tri.cpp
View File

@ -71,7 +71,7 @@ void NStencilHalfMulti22dTri::set_stencil_properties()
void NStencilHalfMulti22dTri::create()
{
int itype, jtype, i, j, ns;
int itype, jtype, bin_type, i, j, ns;
int n = atom->ntypes;
double cutsq;
@ -82,28 +82,25 @@ void NStencilHalfMulti22dTri::create()
ns = 0;
sx = sx_multi2[itype][jtype];
sy = sy_multi2[itype][jtype];
sx = stencil_sx_multi2[itype][jtype];
sy = stencil_sy_multi2[itype][jtype];
mbinx = mbinx_multi2[itype][jtype];
mbiny = mbiny_multi2[itype][jtype];
mbinx = stencil_mbinx_multi2[itype][jtype];
mbiny = stencil_mbiny_multi2[itype][jtype];
// Redefine for use in bin_distance()
binsizex = binsizex_multi2[itype][jtype];
binsizey = binsizey_multi2[itype][jtype];
binsizez = binsizez_multi2[itype][jtype];
bin_type = stencil_bin_type[i][j];
cutsq = stencil_cut[itype][jtype];
if (stencil_half[itype][jtype]) {
for (j = 0; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance(i,j,0) < cutsq)
if (bin_distance_multi2(i,j,0,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] = j*mbinx + i;
} else {
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance(i,j,0) < cutsq)
if (bin_distance_multi2(i,j,0,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] = j*mbinx + i;
}

23
src/nstencil_half_multi2_3d.cpp
View File

@ -71,7 +71,7 @@ void NStencilHalfMulti23d::set_stencil_properties()
void NStencilHalfMulti23d::create()
{
int itype, jtype, i, j, k, ns;
int itype, jtype, bin_type, i, j, k, ns;
int n = atom->ntypes;
double cutsq;
@ -82,18 +82,15 @@ void NStencilHalfMulti23d::create()
ns = 0;
sx = sx_multi2[itype][jtype];
sy = sy_multi2[itype][jtype];
sz = sz_multi2[itype][jtype];
sx = stencil_sx_multi2[itype][jtype];
sy = stencil_sy_multi2[itype][jtype];
sz = stencil_sz_multi2[itype][jtype];
mbinx = mbinx_multi2[itype][jtype];
mbiny = mbiny_multi2[itype][jtype];
mbinz = mbinz_multi2[itype][jtype];
mbinx = stencil_mbinx_multi2[itype][jtype];
mbiny = stencil_mbiny_multi2[itype][jtype];
mbinz = stencil_mbinz_multi2[itype][jtype];
// Redefine for use in bin_distance()
binsizex = binsizex_multi2[itype][jtype];
binsizey = binsizey_multi2[itype][jtype];
binsizez = binsizez_multi2[itype][jtype];
bin_type = stencil_bin_type[i][j];
cutsq = stencil_cut[itype][jtype];
@ -102,7 +99,7 @@ void NStencilHalfMulti23d::create()
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (k > 0 || j > 0 || (j == 0 && i > 0)) {
if (bin_distance(i,j,k) < cutsq)
if (bin_distance_multi2(i,j,k,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] =
k*mbiny*mbinx + j*mbinx + i;
}
@ -110,7 +107,7 @@ void NStencilHalfMulti23d::create()
for (k = -sz; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance(i,j,k) < cutsq)
if (bin_distance_multi2(i,j,k,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] =
k*mbiny*mbinx + j*mbinx + i;
}

23
src/nstencil_half_multi2_3d_tri.cpp
View File

@ -71,7 +71,7 @@ void NStencilHalfMulti23dTri::set_stencil_properties()
void NStencilHalfMulti23dTri::create()
{
int itype, jtype, i, j, k, ns;
int itype, jtype, bin_type, i, j, k, ns;
int n = atom->ntypes;
double cutsq;
@ -82,18 +82,15 @@ void NStencilHalfMulti23dTri::create()
ns = 0;
sx = sx_multi2[itype][jtype];
sy = sy_multi2[itype][jtype];
sz = sz_multi2[itype][jtype];
sx = stencil_sx_multi2[itype][jtype];
sy = stencil_sy_multi2[itype][jtype];
sz = stencil_sz_multi2[itype][jtype];
mbinx = mbinx_multi2[itype][jtype];
mbiny = mbiny_multi2[itype][jtype];
mbinz = mbinz_multi2[itype][jtype];
mbinx = stencil_mbinx_multi2[itype][jtype];
mbiny = stencil_mbiny_multi2[itype][jtype];
mbinz = stencil_mbinz_multi2[itype][jtype];
// Redefine for use in bin_distance()
binsizex = binsizex_multi2[itype][jtype];
binsizey = binsizey_multi2[itype][jtype];
binsizez = binsizez_multi2[itype][jtype];
bin_type = stencil_bin_type[i][j];
cutsq = stencil_cut[itype][jtype];
@ -101,14 +98,14 @@ void NStencilHalfMulti23dTri::create()
for (k = 0; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance(i,j,k) < cutsq)
if (bin_distance_multi2(i,j,k,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] =
k*mbiny*mbinx + j*mbinx + i;
} else {
for (k = -sz; k <= sz; k++)
for (j = -sy; j <= sy; j++)
for (i = -sx; i <= sx; i++)
if (bin_distance(i,j,k) < cutsq)
if (bin_distance_multi2(i,j,k,bin_type) < cutsq)
stencil_multi2[itype][jtype][ns++] =
k*mbiny*mbinx + j*mbinx + i;
}