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

more 'war on tabs'

Browse Source
This commit is contained in:
Axel Kohlmeyer
2019-03-29 10:21:44 -04:00
parent 1bf5047c7a
commit ff819be807
8 changed files with 126 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/comm.cpp
View File

@ -933,7 +933,7 @@ rendezvous_all2all(int n, char *inbuf, int insize, int inorder, int *procs,
"rendezvous:inbuf"); "rendezvous:inbuf");
MPI_Alltoallv(inbuf_a2a,sendcount,sdispls,MPI_CHAR, MPI_Alltoallv(inbuf_a2a,sendcount,sdispls,MPI_CHAR,
inbuf_rvous,recvcount,rdispls,MPI_CHAR,world); inbuf_rvous,recvcount,rdispls,MPI_CHAR,world);
if (!inorder) { if (!inorder) {
memory->destroy(procs_a2a); memory->destroy(procs_a2a);
@ -1036,7 +1036,7 @@ rendezvous_all2all(int n, char *inbuf, int insize, int inorder, int *procs,
outbuf = (char *) memory->smalloc((bigint) nout*outsize,"rendezvous:outbuf"); outbuf = (char *) memory->smalloc((bigint) nout*outsize,"rendezvous:outbuf");
MPI_Alltoallv(outbuf_a2a,sendcount,sdispls,MPI_CHAR, MPI_Alltoallv(outbuf_a2a,sendcount,sdispls,MPI_CHAR,
outbuf,recvcount,rdispls,MPI_CHAR,world); outbuf,recvcount,rdispls,MPI_CHAR,world);
memory->destroy(procs_rvous); memory->destroy(procs_rvous);
memory->sfree(outbuf_rvous); memory->sfree(outbuf_rvous);

76
src/compute_angle_local.cpp
View File

@ -88,7 +88,7 @@ ComputeAngleLocal::ComputeAngleLocal(LAMMPS *lmp, int narg, char **arg) :
int n = strlen(arg[iarg+2]) + 1; int n = strlen(arg[iarg+2]) + 1;
tstr = new char[n]; tstr = new char[n];
strcpy(tstr,arg[iarg+2]); strcpy(tstr,arg[iarg+2]);
tflag = 1; tflag = 1;
} else error->all(FLERR,"Illegal compute angle/local command"); } else error->all(FLERR,"Illegal compute angle/local command");
iarg += 3; iarg += 3;
} else error->all(FLERR,"Illegal compute angle/local command"); } else error->all(FLERR,"Illegal compute angle/local command");
@ -102,9 +102,9 @@ ComputeAngleLocal::ComputeAngleLocal(LAMMPS *lmp, int narg, char **arg) :
for (int i = 0; i < nvar; i++) { for (int i = 0; i < nvar; i++) {
vvar[i] = input->variable->find(vstr[i]); vvar[i] = input->variable->find(vstr[i]);
if (vvar[i] < 0) if (vvar[i] < 0)
error->all(FLERR,"Variable name for copute angle/local does not exist"); error->all(FLERR,"Variable name for copute angle/local does not exist");
if (!input->variable->equalstyle(vvar[i])) if (!input->variable->equalstyle(vvar[i]))
error->all(FLERR,"Variable for compute angle/local is invalid style"); error->all(FLERR,"Variable for compute angle/local is invalid style");
} }
if (tstr) { if (tstr) {
@ -153,7 +153,7 @@ void ComputeAngleLocal::init()
for (int i = 0; i < nvar; i++) { for (int i = 0; i < nvar; i++) {
vvar[i] = input->variable->find(vstr[i]); vvar[i] = input->variable->find(vstr[i]);
if (vvar[i] < 0) if (vvar[i] < 0)
error->all(FLERR,"Variable name for compute angle/local does not exist"); error->all(FLERR,"Variable name for compute angle/local does not exist");
} }
if (tstr) { if (tstr) {
@ -261,53 +261,53 @@ int ComputeAngleLocal::compute_angles(int flag)
// theta needed by one or more outputs // theta needed by one or more outputs
if (tflag) { if (tflag) {
delx1 = x[atom1][0] - x[atom2][0]; delx1 = x[atom1][0] - x[atom2][0];
dely1 = x[atom1][1] - x[atom2][1]; dely1 = x[atom1][1] - x[atom2][1];
delz1 = x[atom1][2] - x[atom2][2]; delz1 = x[atom1][2] - x[atom2][2];
domain->minimum_image(delx1,dely1,delz1); domain->minimum_image(delx1,dely1,delz1);
rsq1 = delx1*delx1 + dely1*dely1 + delz1*delz1; rsq1 = delx1*delx1 + dely1*dely1 + delz1*delz1;
r1 = sqrt(rsq1); r1 = sqrt(rsq1);
delx2 = x[atom3][0] - x[atom2][0]; delx2 = x[atom3][0] - x[atom2][0];
dely2 = x[atom3][1] - x[atom2][1]; dely2 = x[atom3][1] - x[atom2][1];
delz2 = x[atom3][2] - x[atom2][2]; delz2 = x[atom3][2] - x[atom2][2];
domain->minimum_image(delx2,dely2,delz2); domain->minimum_image(delx2,dely2,delz2);
rsq2 = delx2*delx2 + dely2*dely2 + delz2*delz2; rsq2 = delx2*delx2 + dely2*dely2 + delz2*delz2;
r2 = sqrt(rsq2); r2 = sqrt(rsq2);
// c = cosine of angle // c = cosine of angle
// theta = angle in radians // theta = angle in radians
c = delx1*delx2 + dely1*dely2 + delz1*delz2; c = delx1*delx2 + dely1*dely2 + delz1*delz2;
c /= r1*r2; c /= r1*r2;
if (c > 1.0) c = 1.0; if (c > 1.0) c = 1.0;
if (c < -1.0) c = -1.0; if (c < -1.0) c = -1.0;
theta = acos(c); theta = acos(c);
} }
if (nvalues == 1) ptr = &vlocal[m]; if (nvalues == 1) ptr = &vlocal[m];
else ptr = alocal[m]; else ptr = alocal[m];
if (nvar) { if (nvar) {
ivar = 0; ivar = 0;
if (tstr) input->variable->internal_set(tvar,theta); if (tstr) input->variable->internal_set(tvar,theta);
} }
for (n = 0; n < nvalues; n++) { for (n = 0; n < nvalues; n++) {
switch (bstyle[n]) { switch (bstyle[n]) {
case THETA: case THETA:
ptr[n] = 180.0*theta/MY_PI; ptr[n] = 180.0*theta/MY_PI;
break; break;
case ENG: case ENG:
if (atype > 0) ptr[n] = angle->single(atype,atom1,atom2,atom3); if (atype > 0) ptr[n] = angle->single(atype,atom1,atom2,atom3);
else ptr[n] = 0.0; else ptr[n] = 0.0;
break; break;
case VARIABLE: case VARIABLE:
ptr[n] = input->variable->compute_equal(vvar[ivar]); ptr[n] = input->variable->compute_equal(vvar[ivar]);
ivar++; ivar++;
break; break;
} }
} }

22
src/compute_bond_local.cpp
View File

@ -105,9 +105,9 @@ ComputeBondLocal::ComputeBondLocal(LAMMPS *lmp, int narg, char **arg) :
for (int i = 0; i < nvar; i++) { for (int i = 0; i < nvar; i++) {
vvar[i] = input->variable->find(vstr[i]); vvar[i] = input->variable->find(vstr[i]);
if (vvar[i] < 0) if (vvar[i] < 0)
error->all(FLERR,"Variable name for copute bond/local does not exist"); error->all(FLERR,"Variable name for copute bond/local does not exist");
if (!input->variable->equalstyle(vvar[i])) if (!input->variable->equalstyle(vvar[i]))
error->all(FLERR,"Variable for compute bond/local is invalid style"); error->all(FLERR,"Variable for compute bond/local is invalid style");
} }
if (dstr) { if (dstr) {
@ -168,7 +168,7 @@ void ComputeBondLocal::init()
for (int i = 0; i < nvar; i++) { for (int i = 0; i < nvar; i++) {
vvar[i] = input->variable->find(vstr[i]); vvar[i] = input->variable->find(vstr[i]);
if (vvar[i] < 0) if (vvar[i] < 0)
error->all(FLERR,"Variable name for compute bond/local does not exist"); error->all(FLERR,"Variable name for compute bond/local does not exist");
} }
if (dstr) { if (dstr) {
@ -377,10 +377,10 @@ int ComputeBondLocal::compute_bonds(int flag)
if (nvalues == 1) ptr = &vlocal[m]; if (nvalues == 1) ptr = &vlocal[m];
else ptr = alocal[m]; else ptr = alocal[m];
if (nvar) { if (nvar) {
ivar = 0; ivar = 0;
if (dstr) input->variable->internal_set(dvar,sqrt(rsq)); if (dstr) input->variable->internal_set(dvar,sqrt(rsq));
} }
for (n = 0; n < nvalues; n++) { for (n = 0; n < nvalues; n++) {
switch (bstyle[n]) { switch (bstyle[n]) {
@ -408,10 +408,10 @@ int ComputeBondLocal::compute_bonds(int flag)
case VELVIB: case VELVIB:
ptr[n] = vvib; ptr[n] = vvib;
break; break;
case VARIABLE: case VARIABLE:
ptr[n] = input->variable->compute_equal(vvar[ivar]); ptr[n] = input->variable->compute_equal(vvar[ivar]);
ivar++; ivar++;
break; break;
} }
} }
} }

56
src/compute_chunk_spread_atom.cpp
View File

@ -71,7 +71,7 @@ ComputeChunkSpreadAtom(LAMMPS *lmp, int narg, char **arg) :
ids[nvalues] = NULL; ids[nvalues] = NULL;
if (strncmp(arg[iarg],"c_",2) == 0 || if (strncmp(arg[iarg],"c_",2) == 0 ||
strncmp(arg[iarg],"f_",2) == 0) { strncmp(arg[iarg],"f_",2) == 0) {
if (arg[iarg][0] == 'c') which[nvalues] = COMPUTE; if (arg[iarg][0] == 'c') which[nvalues] = COMPUTE;
else if (arg[iarg][0] == 'f') which[nvalues] = FIX; else if (arg[iarg][0] == 'f') which[nvalues] = FIX;
@ -123,15 +123,15 @@ ComputeChunkSpreadAtom(LAMMPS *lmp, int narg, char **arg) :
"does not calculate per-chunk values"); "does not calculate per-chunk values");
if (argindex[i] == 0) { if (argindex[i] == 0) {
if (!modify->compute[icompute]->vector_flag) if (!modify->compute[icompute]->vector_flag)
error->all(FLERR,"Compute chunk/spread/atom compute " error->all(FLERR,"Compute chunk/spread/atom compute "
"does not calculate global vector"); "does not calculate global vector");
} else { } else {
if (!modify->compute[icompute]->array_flag) if (!modify->compute[icompute]->array_flag)
error->all(FLERR,"Compute chunk/spread/atom compute " error->all(FLERR,"Compute chunk/spread/atom compute "
"does not calculate global array"); "does not calculate global array");
if (argindex[i] > modify->compute[icompute]->size_array_cols) if (argindex[i] > modify->compute[icompute]->size_array_cols)
error->all(FLERR,"Compute chunk/spread/atom compute array " error->all(FLERR,"Compute chunk/spread/atom compute array "
"is accessed out-of-range"); "is accessed out-of-range");
} }
@ -140,15 +140,15 @@ ComputeChunkSpreadAtom(LAMMPS *lmp, int narg, char **arg) :
if (ifix < 0) if (ifix < 0)
error->all(FLERR,"Fix ID for compute chunk/spread/atom does not exist"); error->all(FLERR,"Fix ID for compute chunk/spread/atom does not exist");
if (argindex[i] == 0) { if (argindex[i] == 0) {
if (!modify->fix[ifix]->vector_flag) if (!modify->fix[ifix]->vector_flag)
error->all(FLERR,"Compute chunk/spread/atom fix " error->all(FLERR,"Compute chunk/spread/atom fix "
"does not calculate global vector"); "does not calculate global vector");
} else { } else {
if (!modify->fix[ifix]->array_flag) if (!modify->fix[ifix]->array_flag)
error->all(FLERR,"Compute chunk/spread/atom fix " error->all(FLERR,"Compute chunk/spread/atom fix "
"does not calculate global array"); "does not calculate global array");
if (argindex[i] > modify->fix[ifix]->size_array_cols) if (argindex[i] > modify->fix[ifix]->size_array_cols)
error->all(FLERR,"Compute chunk/spread/atom fix array " error->all(FLERR,"Compute chunk/spread/atom fix array "
"is accessed out-of-range"); "is accessed out-of-range");
} }
} }
@ -281,14 +281,14 @@ void ComputeChunkSpreadAtom::compute_peratom()
compute->compute_vector(); compute->compute_vector();
compute->invoked_flag |= INVOKED_VECTOR; compute->invoked_flag |= INVOKED_VECTOR;
} }
double *cvector = compute->vector; double *cvector = compute->vector;
for (i = 0; i < nlocal; i++, ptr += nstride) { for (i = 0; i < nlocal; i++, ptr += nstride) {
*ptr = 0.0; *ptr = 0.0;
if (!(mask[i] & groupbit)) continue; if (!(mask[i] & groupbit)) continue;
index = ichunk[i]-1; index = ichunk[i]-1;
if (index < 0 || index >= nchunk) continue; if (index < 0 || index >= nchunk) continue;
*ptr = cvector[index]; *ptr = cvector[index];
} }
} else { } else {
if (!(compute->invoked_flag & INVOKED_ARRAY)) { if (!(compute->invoked_flag & INVOKED_ARRAY)) {
@ -297,13 +297,13 @@ void ComputeChunkSpreadAtom::compute_peratom()
} }
int icol = argindex[m]-1; int icol = argindex[m]-1;
double **carray = compute->array; double **carray = compute->array;
for (i = 0; i < nlocal; i++, ptr += nstride) { for (i = 0; i < nlocal; i++, ptr += nstride) {
*ptr = 0.0; *ptr = 0.0;
if (!(mask[i] & groupbit)) continue; if (!(mask[i] & groupbit)) continue;
index = ichunk[i]-1; index = ichunk[i]-1;
if (index < 0 || index >= nchunk) continue; if (index < 0 || index >= nchunk) continue;
*ptr = carray[index][icol]; *ptr = carray[index][icol];
} }
} }
// access fix data, check if fix frequency is a match // access fix data, check if fix frequency is a match

26
src/compute_dihedral_local.cpp
View File

@ -101,10 +101,10 @@ ComputeDihedralLocal::ComputeDihedralLocal(LAMMPS *lmp, int narg, char **arg) :
for (int i = 0; i < nvar; i++) { for (int i = 0; i < nvar; i++) {
vvar[i] = input->variable->find(vstr[i]); vvar[i] = input->variable->find(vstr[i]);
if (vvar[i] < 0) if (vvar[i] < 0)
error->all(FLERR, error->all(FLERR,
"Variable name for copute dihedral/local does not exist"); "Variable name for copute dihedral/local does not exist");
if (!input->variable->equalstyle(vvar[i])) if (!input->variable->equalstyle(vvar[i]))
error->all(FLERR,"Variable for compute dihedral/local is invalid style"); error->all(FLERR,"Variable for compute dihedral/local is invalid style");
} }
if (pstr) { if (pstr) {
@ -154,7 +154,7 @@ void ComputeDihedralLocal::init()
for (int i = 0; i < nvar; i++) { for (int i = 0; i < nvar; i++) {
vvar[i] = input->variable->find(vstr[i]); vvar[i] = input->variable->find(vstr[i]);
if (vvar[i] < 0) if (vvar[i] < 0)
error->all(FLERR, error->all(FLERR,
"Variable name for compute dihedral/local does not exist"); "Variable name for compute dihedral/local does not exist");
} }
@ -307,19 +307,19 @@ int ComputeDihedralLocal::compute_dihedrals(int flag)
else ptr = alocal[m]; else ptr = alocal[m];
if (nvar) { if (nvar) {
ivar = 0; ivar = 0;
if (pstr) input->variable->internal_set(pvar,phi); if (pstr) input->variable->internal_set(pvar,phi);
} }
for (n = 0; n < nvalues; n++) { for (n = 0; n < nvalues; n++) {
switch (bstyle[n]) { switch (bstyle[n]) {
case PHI: case PHI:
ptr[n] = 180.0*phi/MY_PI; ptr[n] = 180.0*phi/MY_PI;
break; break;
case VARIABLE: case VARIABLE:
ptr[n] = input->variable->compute_equal(vvar[ivar]); ptr[n] = input->variable->compute_equal(vvar[ivar]);
ivar++; ivar++;
break; break;
} }
} }

2
src/compute_property_atom.cpp
View File

@ -141,7 +141,7 @@ ComputePropertyAtom::ComputePropertyAtom(LAMMPS *lmp, int narg, char **arg) :
error->all(FLERR,"Compute property/atom for " error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated"); "atom property that isn't allocated");
pack_choice[i] = &ComputePropertyAtom::pack_mu; pack_choice[i] = &ComputePropertyAtom::pack_mu;
} else if (strcmp(arg[iarg],"spx") == 0) { // pack magnetic variables } else if (strcmp(arg[iarg],"spx") == 0) { // pack magnetic variables
if (!atom->sp_flag) if (!atom->sp_flag)
error->all(FLERR,"Compute property/atom for " error->all(FLERR,"Compute property/atom for "
"atom property that isn't allocated"); "atom property that isn't allocated");

4
src/compute_property_atom.h
View File

@ -84,7 +84,9 @@ class ComputePropertyAtom : public Compute {
void pack_radius(int); void pack_radius(int);
void pack_diameter(int); void pack_diameter(int);
void pack_spx(int); // pack magnetic variables // pack magnetic variables
void pack_spx(int);
void pack_spy(int); void pack_spy(int);
void pack_spz(int); void pack_spz(int);
void pack_sp(int); void pack_sp(int);

60
src/memory.h
View File

@ -443,44 +443,44 @@ class Memory : protected Pointers {
template <typename TYPE> template <typename TYPE>
TYPE ****grow(TYPE ****&array, int n1, int n2, int n3, int n4, TYPE ****grow(TYPE ****&array, int n1, int n2, int n3, int n4,
const char *name) const char *name)
{ {
if (array == NULL) return create(array, n1, n2, n3, n4, name); if (array == NULL) return create(array, n1, n2, n3, n4, name);
bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4; bigint nbytes = ((bigint) sizeof(TYPE)) * n1*n2*n3*n4;
TYPE *data = (TYPE *)srealloc(array[0][0][0], nbytes, name); TYPE *data = (TYPE *)srealloc(array[0][0][0], nbytes, name);
nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3; nbytes = ((bigint) sizeof(TYPE *)) * n1*n2*n3;
TYPE **cube = (TYPE **)srealloc(array[0][0], nbytes, name); TYPE **cube = (TYPE **)srealloc(array[0][0], nbytes, name);
nbytes = ((bigint) sizeof(TYPE **)) * n1*n2; nbytes = ((bigint) sizeof(TYPE **)) * n1*n2;
TYPE ***plane = (TYPE ***)srealloc(array[0], nbytes, name); TYPE ***plane = (TYPE ***)srealloc(array[0], nbytes, name);
nbytes = ((bigint) sizeof(TYPE ***)) * n1; nbytes = ((bigint) sizeof(TYPE ***)) * n1;
array = (TYPE ****)srealloc(array, nbytes, name); array = (TYPE ****)srealloc(array, nbytes, name);
int i, j, k; int i, j, k;
bigint m1, m2; bigint m1, m2;
bigint n = 0; bigint n = 0;
for (i = 0; i < n1; i++) { for (i = 0; i < n1; i++) {
m2 = ((bigint)i) * n2; m2 = ((bigint)i) * n2;
array[i] = &plane[m2]; array[i] = &plane[m2];
for (j = 0; j < n2; j++) { for (j = 0; j < n2; j++) {
m1 = ((bigint)i) * n2 + j; m1 = ((bigint)i) * n2 + j;
m2 = ((bigint)i) * n2*n3 + j*n3; m2 = ((bigint)i) * n2*n3 + j*n3;
plane[m1] = &cube[m2]; plane[m1] = &cube[m2];
for (k = 0; k < n3; k++) { for (k = 0; k < n3; k++) {
m1 = ((bigint)i) * n2*n3 + j*n3 + k; m1 = ((bigint)i) * n2*n3 + j*n3 + k;
cube[m1] = &data[n]; cube[m1] = &data[n];
n += n4; n += n4;
} }
} }
} }
return array; return array;
} }
template <typename TYPE> template <typename TYPE>
TYPE *****grow(TYPE *****&array, int n1, int n2, int n3, int n4, TYPE *****grow(TYPE *****&array, int n1, int n2, int n3, int n4,
const char *name) const char *name)
{ {
fail(name); return NULL; fail(name); return NULL;
} }
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------