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

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

Browse Source
This commit is contained in:
sjplimp
2011-04-14 17:40:40 +00:00
parent f7ce52785b
commit 759ee1f3e8
26 changed files with 490 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
src/ASPHERE/atom_vec_ellipsoid.cpp
View File

@ -262,13 +262,19 @@ int AtomVecEllipsoid::pack_comm_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecEllipsoid::pack_comm_one(int i, double *buf)
int AtomVecEllipsoid::pack_comm_hybrid(int n, int *list, double *buf)
{
buf[0] = quat[i][0];
buf[1] = quat[i][1];
buf[2] = quat[i][2];
buf[3] = quat[i][3];
return 4;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = quat[i][0];
buf[m++] = quat[i][1];
buf[m++] = quat[i][2];
buf[m++] = quat[i][3];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -317,13 +323,19 @@ void AtomVecEllipsoid::unpack_comm_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecEllipsoid::unpack_comm_one(int i, double *buf)
int AtomVecEllipsoid::unpack_comm_hybrid(int n, int first, double *buf)
{
quat[i][0] = buf[0];
quat[i][1] = buf[1];
quat[i][2] = buf[2];
quat[i][3] = buf[3];
return 4;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
quat[i][0] = buf[m++];
quat[i][1] = buf[m++];
quat[i][2] = buf[m++];
quat[i][3] = buf[m++];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -347,12 +359,18 @@ int AtomVecEllipsoid::pack_reverse(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecEllipsoid::pack_reverse_one(int i, double *buf)
int AtomVecEllipsoid::pack_reverse_hybrid(int n, int first, double *buf)
{
buf[0] = torque[i][0];
buf[1] = torque[i][1];
buf[2] = torque[i][2];
return 3;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
buf[m++] = torque[i][0];
buf[m++] = torque[i][1];
buf[m++] = torque[i][2];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -375,12 +393,18 @@ void AtomVecEllipsoid::unpack_reverse(int n, int *list, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecEllipsoid::unpack_reverse_one(int i, double *buf)
int AtomVecEllipsoid::unpack_reverse_hybrid(int n, int *list, double *buf)
{
torque[i][0] += buf[0];
torque[i][1] += buf[1];
torque[i][2] += buf[2];
return 3;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
torque[j][0] += buf[m++];
torque[j][1] += buf[m++];
torque[j][2] += buf[m++];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -543,16 +567,22 @@ int AtomVecEllipsoid::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecEllipsoid::pack_border_one(int i, double *buf)
int AtomVecEllipsoid::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = shape[i][0];
buf[1] = shape[i][1];
buf[2] = shape[i][2];
buf[3] = quat[i][0];
buf[4] = quat[i][1];
buf[5] = quat[i][2];
buf[6] = quat[i][3];
return 7;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = shape[j][0];
buf[m++] = shape[j][1];
buf[m++] = shape[j][2];
buf[m++] = quat[j][0];
buf[m++] = quat[j][1];
buf[m++] = quat[j][2];
buf[m++] = quat[j][3];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -615,16 +645,22 @@ void AtomVecEllipsoid::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecEllipsoid::unpack_border_one(int i, double *buf)
int AtomVecEllipsoid::unpack_border_hybrid(int n, int first, double *buf)
{
shape[i][0] = buf[0];
shape[i][1] = buf[1];
shape[i][2] = buf[2];
quat[i][0] = buf[3];
quat[i][1] = buf[4];
quat[i][2] = buf[5];
quat[i][3] = buf[6];
return 7;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
shape[i][0] = buf[m++];
shape[i][1] = buf[m++];
shape[i][2] = buf[m++];
quat[i][0] = buf[m++];
quat[i][1] = buf[m++];
quat[i][2] = buf[m++];
quat[i][3] = buf[m++];
}
return m;
}
/* ----------------------------------------------------------------------

12
src/ASPHERE/atom_vec_ellipsoid.h
View File

@ -33,20 +33,20 @@ class AtomVecEllipsoid : public AtomVec {
void copy(int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_one(int, double *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_one(int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_one(int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, int *, double *);
int unpack_reverse_one(int, double *);
int unpack_reverse_hybrid(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

73
src/DIPOLE/atom_vec_dipole.cpp
View File

@ -44,7 +44,6 @@ AtomVecDipole::AtomVecDipole(LAMMPS *lmp, int narg, char **arg) :
size_data_vel = 7;
xcol_data = 4;
atom->dipole_flag = 1;
atom->q_flag = atom->mu_flag = 1;
}
@ -232,12 +231,18 @@ int AtomVecDipole::pack_comm_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecDipole::pack_comm_one(int i, double *buf)
int AtomVecDipole::pack_comm_hybrid(int n, int *list, double *buf)
{
buf[0] = mu[i][0];
buf[1] = mu[i][1];
buf[2] = mu[i][2];
return 3;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = mu[j][0];
buf[m++] = mu[j][1];
buf[m++] = mu[j][2];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -281,12 +286,18 @@ void AtomVecDipole::unpack_comm_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecDipole::unpack_comm_one(int i, double *buf)
int AtomVecDipole::unpack_comm_hybrid(int n, int first, double *buf)
{
mu[i][0] = buf[0];
mu[i][1] = buf[1];
mu[i][2] = buf[2];
return 3;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
mu[i][0] = buf[m++];
mu[i][1] = buf[m++];
mu[i][2] = buf[m++];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -461,14 +472,20 @@ int AtomVecDipole::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecDipole::pack_border_one(int i, double *buf)
int AtomVecDipole::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = q[i];
buf[1] = mu[i][0];
buf[2] = mu[i][1];
buf[3] = mu[i][2];
buf[4] = mu[i][3];
return 5;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = q[j];
buf[m++] = mu[j][0];
buf[m++] = mu[j][1];
buf[m++] = mu[j][2];
buf[m++] = mu[j][3];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -524,14 +541,20 @@ void AtomVecDipole::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecDipole::unpack_border_one(int i, double *buf)
int AtomVecDipole::unpack_border_hybrid(int n, int first, double *buf)
{
q[i] = buf[0];
mu[i][0] = buf[1];
mu[i][1] = buf[2];
mu[i][2] = buf[3];
mu[i][3] = buf[4];
return 5;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
q[i] = buf[m++];
mu[i][0] = buf[m++];
mu[i][1] = buf[m++];
mu[i][2] = buf[m++];
mu[i][3] = buf[m++];
}
return m;
}
/* ----------------------------------------------------------------------

8
src/DIPOLE/atom_vec_dipole.h
View File

@ -32,18 +32,18 @@ class AtomVecDipole : public AtomVec {
void copy(int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_one(int, double *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_one(int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
void unpack_reverse(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

23
src/MOLECULE/atom_vec_angle.cpp
View File

@ -428,10 +428,16 @@ int AtomVecAngle::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecAngle::pack_border_one(int i, double *buf)
int AtomVecAngle::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = molecule[i];
return 1;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = molecule[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -479,10 +485,15 @@ void AtomVecAngle::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecAngle::unpack_border_one(int i, double *buf)
int AtomVecAngle::unpack_border_hybrid(int n, int first, double *buf)
{
molecule[i] = static_cast<int> (buf[0]);
return 1;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++)
molecule[i] = static_cast<int> (buf[m++]);
return m;
}
/* ----------------------------------------------------------------------

4
src/MOLECULE/atom_vec_angle.h
View File

@ -38,10 +38,10 @@ class AtomVecAngle : public AtomVec {
void unpack_reverse(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

23
src/MOLECULE/atom_vec_bond.cpp
View File

@ -421,10 +421,16 @@ int AtomVecBond::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecBond::pack_border_one(int i, double *buf)
int AtomVecBond::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = molecule[i];
return 1;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = molecule[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -472,10 +478,15 @@ void AtomVecBond::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecBond::unpack_border_one(int i, double *buf)
int AtomVecBond::unpack_border_hybrid(int n, int first, double *buf)
{
molecule[i] = static_cast<int> (buf[0]);
return 1;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++)
molecule[i] = static_cast<int> (buf[m++]);
return m;
}
/* ----------------------------------------------------------------------

4
src/MOLECULE/atom_vec_bond.h
View File

@ -38,10 +38,10 @@ class AtomVecBond : public AtomVec {
void unpack_reverse(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

28
src/MOLECULE/atom_vec_full.cpp
View File

@ -506,11 +506,17 @@ int AtomVecFull::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecFull::pack_border_one(int i, double *buf)
int AtomVecFull::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = q[i];
buf[1] = molecule[i];
return 2;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = q[j];
buf[m++] = molecule[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -560,11 +566,17 @@ void AtomVecFull::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecFull::unpack_border_one(int i, double *buf)
int AtomVecFull::unpack_border_hybrid(int n, int first, double *buf)
{
q[i] = buf[0];
molecule[i] = static_cast<int> (buf[1]);
return 2;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
q[i] = buf[m++];
molecule[i] = static_cast<int> (buf[m++]);
}
return m;
}
/* ----------------------------------------------------------------------

4
src/MOLECULE/atom_vec_full.h
View File

@ -38,10 +38,10 @@ class AtomVecFull : public AtomVec {
void unpack_reverse(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

23
src/MOLECULE/atom_vec_molecular.cpp
View File

@ -499,10 +499,16 @@ int AtomVecMolecular::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecMolecular::pack_border_one(int i, double *buf)
int AtomVecMolecular::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = molecule[i];
return 1;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = molecule[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -550,10 +556,15 @@ void AtomVecMolecular::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecMolecular::unpack_border_one(int i, double *buf)
int AtomVecMolecular::unpack_border_hybrid(int n, int first, double *buf)
{
molecule[i] = static_cast<int> (buf[0]);
return 1;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++)
molecule[i] = static_cast<int> (buf[m++]);
return m;
}
/* ----------------------------------------------------------------------

4
src/MOLECULE/atom_vec_molecular.h
View File

@ -38,10 +38,10 @@ class AtomVecMolecular : public AtomVec {
void unpack_reverse(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

63
src/PERI/atom_vec_peri.cpp
View File

@ -231,10 +231,16 @@ int AtomVecPeri::pack_comm_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecPeri::pack_comm_one(int i, double *buf)
int AtomVecPeri::pack_comm_hybrid(int n, int *list, double *buf)
{
buf[0] = s0[i];
return 1;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = s0[i];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -274,10 +280,15 @@ void AtomVecPeri::unpack_comm_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecPeri::unpack_comm_one(int i, double *buf)
int AtomVecPeri::unpack_comm_hybrid(int n, int first, double *buf)
{
s0[i] = buf[0];
return 1;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++)
s0[i] = buf[m++];
return m;
}
/* ---------------------------------------------------------------------- */
@ -452,14 +463,20 @@ int AtomVecPeri::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecPeri::pack_border_one(int i, double *buf)
int AtomVecPeri::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = vfrac[i];
buf[1] = s0[i];
buf[2] = x0[i][0];
buf[3] = x0[i][1];
buf[4] = x0[i][2];
return 5;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = vfrac[j];
buf[m++] = s0[j];
buf[m++] = x0[j][0];
buf[m++] = x0[j][1];
buf[m++] = x0[j][2];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -515,14 +532,20 @@ void AtomVecPeri::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecPeri::unpack_border_one(int i, double *buf)
int AtomVecPeri::unpack_border_hybrid(int n, int first, double *buf)
{
vfrac[i] = buf[0];
s0[i] = buf[1];
x0[i][0] = buf[2];
x0[i][1] = buf[3];
x0[i][2] = buf[4];
return 5;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
vfrac[i] = buf[m++];
s0[i] = buf[m++];
x0[i][0] = buf[m++];
x0[i][1] = buf[m++];
x0[i][2] = buf[m++];
}
return m;
}
/* ----------------------------------------------------------------------

8
src/PERI/atom_vec_peri.h
View File

@ -32,18 +32,18 @@ class AtomVecPeri : public AtomVec {
void copy(int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_one(int, double *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_one(int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
void unpack_reverse(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

2
src/SRD/fix_srd.cpp
View File

@ -291,8 +291,6 @@ void FixSRD::init()
if (bigexist && !atom->sphere_flag && !atom->ellipsoid_flag)
error->all("Fix SRD requires atom style sphere or ellipsoid");
if (bigexist && atom->angmom_flag && atom->omega_flag)
error->all("Fix SRD cannot have both atom attributes angmom and omega");
if (bigexist && collidestyle == NOSLIP && !atom->torque_flag)
error->all("Fix SRD no-slip requires atom attribute torque");

86
src/USER-EFF/atom_vec_electron.cpp
View File

@ -228,6 +228,20 @@ int AtomVecElectron::pack_comm_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecElectron::pack_comm_hybrid(int n, int *list, double *buf)
{
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = eradius[i];
}
return m;
}
/* ---------------------------------------------------------------------- */
void AtomVecElectron::unpack_comm(int n, int first, double *buf)
{
int i,m,last;
@ -263,18 +277,15 @@ void AtomVecElectron::unpack_comm_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecElectron::pack_comm_one(int i, double *buf)
int AtomVecElectron::unpack_comm_hybrid(int n, int first, double *buf)
{
buf[0] = eradius[i];
return 1;
}
int i,m,last;
/* ---------------------------------------------------------------------- */
int AtomVecElectron::unpack_comm_one(int i, double *buf)
{
eradius[i] = buf[0];
return 1;
m = 0;
last = first + n;
for (i = first; i < last; i++)
eradius[i] = buf[m++];
return m;
}
/* ---------------------------------------------------------------------- */
@ -296,10 +307,15 @@ int AtomVecElectron::pack_reverse(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecElectron::pack_reverse_one(int i, double *buf)
int AtomVecElectron::pack_reverse_hybrid(int n, int first, double *buf)
{
buf[0] = erforce[i];
return 1;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++)
buf[m++] = erforce[i];
return m;
}
/* ---------------------------------------------------------------------- */
@ -320,10 +336,16 @@ void AtomVecElectron::unpack_reverse(int n, int *list, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecElectron::unpack_reverse_one(int i, double *buf)
int AtomVecElectron::unpack_reverse_hybrid(int n, int *list, double *buf)
{
erforce[i] += buf[0];
return 1;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
erforce[j] += buf[m++];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -457,12 +479,18 @@ int AtomVecElectron::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecElectron::pack_border_one(int i, double *buf)
int AtomVecElectron::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = q[i];
buf[1] = spin[i];
buf[2] = eradius[i];
return 3;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = q[j];
buf[m++] = spin[j];
buf[m++] = eradius[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -514,12 +542,18 @@ void AtomVecElectron::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecElectron::unpack_border_one(int i, double *buf)
int AtomVecElectron::unpack_border_hybrid(int n, int first, double *buf)
{
q[i] = buf[0];
spin[i] = static_cast<int> (buf[1]);
eradius[i] = buf[2];
return 3;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
q[i] = buf[m++];
spin[i] = static_cast<int> (buf[m++]);
eradius[i] = buf[m++];
}
return m;
}
/* ----------------------------------------------------------------------

12
src/USER-EFF/atom_vec_electron.h
View File

@ -33,20 +33,20 @@ class AtomVecElectron : public AtomVec {
void copy(int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_one(int, double *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_one(int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_one(int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, int *, double *);
int unpack_reverse_one(int, double *);
int unpack_reverse_hybrid(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

4
src/atom.cpp
View File

@ -99,7 +99,7 @@ Atom::Atom(LAMMPS *lmp) : Pointers(lmp)
// initialize atom style and array existence flags
// customize by adding new flag
sphere_flag = ellipsoid_flag = peri_flag = dipole_flag = electron_flag = 0;
sphere_flag = ellipsoid_flag = peri_flag = electron_flag = 0;
molecule_flag = q_flag = mu_flag = 0;
rmass_flag = radius_flag = omega_flag = torque_flag = 0;
@ -253,7 +253,7 @@ void Atom::create_avec(const char *style, int narg, char **arg)
// may have been set by old avec
// customize by adding new flag
sphere_flag = ellipsoid_flag = peri_flag = dipole_flag = electron_flag = 0;
sphere_flag = ellipsoid_flag = peri_flag = electron_flag = 0;
molecule_flag = q_flag = mu_flag = 0;
rmass_flag = radius_flag = omega_flag = torque_flag = 0;

2
src/atom.h
View File

@ -78,7 +78,7 @@ class Atom : protected Pointers {
// atom style and per-atom array existence flags
// customize by adding new flag
int sphere_flag,ellipsoid_flag,peri_flag,dipole_flag,electron_flag;
int sphere_flag,ellipsoid_flag,peri_flag,electron_flag;
int molecule_flag,q_flag,mu_flag;
int rmass_flag,radius_flag,omega_flag,torque_flag;

12
src/atom_vec.h
View File

@ -47,22 +47,22 @@ class AtomVec : protected Pointers {
virtual int pack_comm(int, int *, double *, int, int *) = 0;
virtual int pack_comm_vel(int, int *, double *, int, int *) = 0;
virtual int pack_comm_one(int, double *) {return 0;}
virtual int pack_comm_hybrid(int, int *, double *) {return 0;}
virtual void unpack_comm(int, int, double *) = 0;
virtual void unpack_comm_vel(int, int, double *) = 0;
virtual int unpack_comm_one(int, double *) {return 0;}
virtual int unpack_comm_hybrid(int, int, double *) {return 0;}
virtual int pack_reverse(int, int, double *) = 0;
virtual int pack_reverse_one(int, double *) {return 0;}
virtual int pack_reverse_hybrid(int, int, double *) {return 0;}
virtual void unpack_reverse(int, int *, double *) = 0;
virtual int unpack_reverse_one(int, double *) {return 0;}
virtual int unpack_reverse_hybrid(int, int *, double *) {return 0;}
virtual int pack_border(int, int *, double *, int, int *) = 0;
virtual int pack_border_vel(int, int *, double *, int, int *) = 0;
virtual int pack_border_one(int, double *) {return 0;}
virtual int pack_border_hybrid(int, int *, double *) {return 0;}
virtual void unpack_border(int, int, double *) = 0;
virtual void unpack_border_vel(int, int, double *) = 0;
virtual int unpack_border_one(int, double *) {return 0;}
virtual int unpack_border_hybrid(int, int, double *) {return 0;}
virtual int pack_exchange(int, double *) = 0;
virtual int unpack_exchange(double *) = 0;

23
src/atom_vec_charge.cpp
View File

@ -392,10 +392,16 @@ int AtomVecCharge::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecCharge::pack_border_one(int i, double *buf)
int AtomVecCharge::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = q[i];
return 1;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = q[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -443,10 +449,15 @@ void AtomVecCharge::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecCharge::unpack_border_one(int i, double *buf)
int AtomVecCharge::unpack_border_hybrid(int n, int first, double *buf)
{
q[i] = buf[0];
return 1;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++)
q[i] = buf[m++];
return m;
}
/* ----------------------------------------------------------------------

4
src/atom_vec_charge.h
View File

@ -38,10 +38,10 @@ class AtomVecCharge : public AtomVec {
void unpack_reverse(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

109
src/atom_vec_hybrid.cpp
View File

@ -187,8 +187,6 @@ int AtomVecHybrid::pack_comm(int n, int *list, double *buf,
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_comm_one(j,&buf[m]);
}
} else {
if (domain->triclinic == 0) {
@ -205,10 +203,14 @@ int AtomVecHybrid::pack_comm(int n, int *list, double *buf,
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_comm_one(j,&buf[m]);
}
}
// pack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_comm_hybrid(n,list,&buf[m]);
return m;
}
@ -242,8 +244,6 @@ int AtomVecHybrid::pack_comm_vel(int n, int *list, double *buf,
buf[m++] = angmom[j][1];
buf[m++] = angmom[j][2];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_comm_one(j,&buf[m]);
}
} else {
if (domain->triclinic == 0) {
@ -274,8 +274,6 @@ int AtomVecHybrid::pack_comm_vel(int n, int *list, double *buf,
buf[m++] = angmom[j][1];
buf[m++] = angmom[j][2];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_comm_one(j,&buf[m]);
}
} else {
dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
@ -305,11 +303,15 @@ int AtomVecHybrid::pack_comm_vel(int n, int *list, double *buf,
buf[m++] = angmom[j][1];
buf[m++] = angmom[j][2];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_comm_one(j,&buf[m]);
}
}
}
// pack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_comm_hybrid(n,list,&buf[m]);
return m;
}
@ -317,28 +319,31 @@ int AtomVecHybrid::pack_comm_vel(int n, int *list, double *buf,
void AtomVecHybrid::unpack_comm(int n, int first, double *buf)
{
int i,k,last;
int i,k,m,last;
int m = 0;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
x[i][0] = buf[m++];
x[i][1] = buf[m++];
x[i][2] = buf[m++];
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_comm_one(i,&buf[m]);
}
// unpack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_comm_hybrid(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
void AtomVecHybrid::unpack_comm_vel(int n, int first, double *buf)
{
int i,k,last;
int i,k,m,last;
int omega_flag = atom->omega_flag;
int angmom_flag = atom->angmom_flag;
int m = 0;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
x[i][0] = buf[m++];
@ -357,26 +362,33 @@ void AtomVecHybrid::unpack_comm_vel(int n, int first, double *buf)
angmom[i][1] = buf[m++];
angmom[i][2] = buf[m++];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_comm_one(i,&buf[m]);
}
// unpack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_comm_hybrid(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
int AtomVecHybrid::pack_reverse(int n, int first, double *buf)
{
int i,k,last;
int i,k,m,last;
int m = 0;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
buf[m++] = f[i][0];
buf[m++] = f[i][1];
buf[m++] = f[i][2];
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_reverse_one(i,&buf[m]);
}
// pack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_reverse_hybrid(n,first,&buf[m]);
return m;
}
@ -392,9 +404,12 @@ void AtomVecHybrid::unpack_reverse(int n, int *list, double *buf)
f[j][0] += buf[m++];
f[j][1] += buf[m++];
f[j][2] += buf[m++];
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_reverse_one(j,&buf[m]);
}
// unpack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_reverse_hybrid(n,list,&buf[m]);
}
/* ---------------------------------------------------------------------- */
@ -415,8 +430,6 @@ int AtomVecHybrid::pack_border(int n, int *list, double *buf,
buf[m++] = tag[j];
buf[m++] = type[j];
buf[m++] = mask[j];
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_border_one(j,&buf[m]);
}
} else {
if (domain->triclinic == 0) {
@ -436,10 +449,14 @@ int AtomVecHybrid::pack_border(int n, int *list, double *buf,
buf[m++] = tag[j];
buf[m++] = type[j];
buf[m++] = mask[j];
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_border_one(j,&buf[m]);
}
}
// pack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_border_hybrid(n,list,&buf[m]);
return m;
}
@ -476,8 +493,6 @@ int AtomVecHybrid::pack_border_vel(int n, int *list, double *buf,
buf[m++] = angmom[j][1];
buf[m++] = angmom[j][2];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_border_one(j,&buf[m]);
}
} else {
if (domain->triclinic == 0) {
@ -511,8 +526,6 @@ int AtomVecHybrid::pack_border_vel(int n, int *list, double *buf,
buf[m++] = angmom[j][1];
buf[m++] = angmom[j][2];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_border_one(j,&buf[m]);
}
} else {
dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
@ -545,11 +558,15 @@ int AtomVecHybrid::pack_border_vel(int n, int *list, double *buf,
buf[m++] = angmom[j][1];
buf[m++] = angmom[j][2];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_border_one(j,&buf[m]);
}
}
}
// pack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_border_hybrid(n,list,&buf[m]);
return m;
}
@ -569,9 +586,12 @@ void AtomVecHybrid::unpack_border(int n, int first, double *buf)
tag[i] = static_cast<int> (buf[m++]);
type[i] = static_cast<int> (buf[m++]);
mask[i] = static_cast<int> (buf[m++]);
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_border_one(i,&buf[m]);
}
// unpack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_border_hybrid(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
@ -605,9 +625,12 @@ void AtomVecHybrid::unpack_border_vel(int n, int first, double *buf)
angmom[i][1] = buf[m++];
angmom[i][2] = buf[m++];
}
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_border_one(i,&buf[m]);
}
// unpack sub-style contributions as contiguous chunks
for (k = 0; k < nstyles; k++)
m += styles[k]->unpack_border_hybrid(n,first,&buf[m]);
}
/* ----------------------------------------------------------------------
@ -617,12 +640,12 @@ void AtomVecHybrid::unpack_border_vel(int n, int first, double *buf)
int AtomVecHybrid::pack_exchange(int i, double *buf)
{
int k;
int k,m;
int tmp = atom->nextra_grow;
atom->nextra_grow = 0;
int m = 0;
m = 0;
for (k = 0; k < nstyles; k++)
m += styles[k]->pack_exchange(i,&buf[m]);
@ -644,14 +667,16 @@ int AtomVecHybrid::pack_exchange(int i, double *buf)
int AtomVecHybrid::unpack_exchange(double *buf)
{
int k,m;
int nlocal = atom->nlocal;
if (nlocal == nmax) grow(0);
int tmp = atom->nextra_grow;
atom->nextra_grow = 0;
int m = 0;
for (int k = 0; k < nstyles; k++) {
m = 0;
for (k = 0; k < nstyles; k++) {
m += styles[k]->unpack_exchange(&buf[m]);
atom->nlocal--;
}

88
src/atom_vec_sphere.cpp
View File

@ -363,13 +363,19 @@ int AtomVecSphere::pack_comm_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecSphere::pack_comm_one(int i, double *buf)
int AtomVecSphere::pack_comm_hybrid(int n, int *list, double *buf)
{
int i,j,m;
if (radvary == 0) return 0;
buf[0] = radius[i];
buf[1] = rmass[i];
return 2;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = radius[i];
buf[m++] = rmass[i];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -440,13 +446,19 @@ void AtomVecSphere::unpack_comm_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecSphere::unpack_comm_one(int i, double *buf)
int AtomVecSphere::unpack_comm_hybrid(int n, int first, double *buf)
{
int i,m,last;
if (radvary == 0) return 0;
radius[i] = buf[0];
rmass[i] = buf[1];
return 2;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
radius[i] = buf[m++];
rmass[i] = buf[m++];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -470,12 +482,18 @@ int AtomVecSphere::pack_reverse(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecSphere::pack_reverse_one(int i, double *buf)
int AtomVecSphere::pack_reverse_hybrid(int n, int first, double *buf)
{
buf[0] = torque[i][0];
buf[1] = torque[i][1];
buf[2] = torque[i][2];
return 3;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
buf[m++] = torque[i][0];
buf[m++] = torque[i][1];
buf[m++] = torque[i][2];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -498,12 +516,18 @@ void AtomVecSphere::unpack_reverse(int n, int *list, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecSphere::unpack_reverse_one(int i, double *buf)
int AtomVecSphere::unpack_reverse_hybrid(int n, int *list, double *buf)
{
torque[i][0] += buf[0];
torque[i][1] += buf[1];
torque[i][2] += buf[2];
return 3;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
torque[j][0] += buf[m++];
torque[j][1] += buf[m++];
torque[j][2] += buf[m++];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -641,11 +665,17 @@ int AtomVecSphere::pack_border_vel(int n, int *list, double *buf,
/* ---------------------------------------------------------------------- */
int AtomVecSphere::pack_border_one(int i, double *buf)
int AtomVecSphere::pack_border_hybrid(int n, int *list, double *buf)
{
buf[0] = radius[i];
buf[1] = rmass[i];
return 2;
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = radius[j];
buf[m++] = rmass[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
@ -699,11 +729,17 @@ void AtomVecSphere::unpack_border_vel(int n, int first, double *buf)
/* ---------------------------------------------------------------------- */
int AtomVecSphere::unpack_border_one(int i, double *buf)
int AtomVecSphere::unpack_border_hybrid(int n, int first, double *buf)
{
radius[i] = buf[0];
rmass[i] = buf[1];
return 2;
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
radius[i] = buf[m++];
rmass[i] = buf[m++];
}
return m;
}
/* ----------------------------------------------------------------------

12
src/atom_vec_sphere.h
View File

@ -34,20 +34,20 @@ class AtomVecSphere : public AtomVec {
void copy(int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_one(int, double *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_one(int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_one(int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, int *, double *);
int unpack_reverse_one(int, double *);
int unpack_reverse_hybrid(int, int *, double *);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_one(int, double *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_one(int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();

2
src/pair_dpd_tstat.cpp
View File

@ -56,7 +56,7 @@ void PairDPDTstat::compute(int eflag, int vflag)
temperature = t_start + delta * (t_stop-t_start);
double boltz = force->boltz;
for (i = 1; i <= atom->ntypes; i++)
for (j = i+1; j <= atom->ntypes; j++)
for (j = i; j <= atom->ntypes; j++)
sigma[i][j] = sigma[j][i] = sqrt(2.0*boltz*temperature*gamma[i][j]);
}