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

added atom styles with bonus data, also a few USER packages

Browse Source
This commit is contained in:
Steve Plimpton
2019-11-27 16:03:50 -07:00
parent 6c18e366d7
commit 4f6cb13592
24 changed files with 1022 additions and 7384 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/MOLECULE/atom_vec_template.cpp
View File

@ -97,7 +97,7 @@ void AtomVecTemplate::process_args(int narg, char **arg)
}
/* ----------------------------------------------------------------------
initialize other atom quantities
initialize non-zero atom quantities
------------------------------------------------------------------------- */
void AtomVecTemplate::create_atom_post(int ilocal)

14
src/PERI/atom_vec_peri.cpp
View File

@ -70,21 +70,17 @@ AtomVecPeri::AtomVecPeri(LAMMPS *lmp) : AtomVec(lmp)
}
/* ----------------------------------------------------------------------
create one atom of itype at coord
modify what default AtomVec::create_atom() just created
initialize non-zero atom quantities
------------------------------------------------------------------------- */
void AtomVecPeri::create_atom(int itype, double *coord)
void AtomVecPeri::create_atom_post(int ilocal)
{
AtomVec::create_atom(itype,coord);
int ilocal = atom->nlocal-1;
atom->vfrac[ilocal] = 1.0;
atom->rmass[ilocal] = 1.0;
atom->s0[ilocal] = DBL_MAX;
atom->x0[ilocal][0] = coord[0];
atom->x0[ilocal][1] = coord[1];
atom->x0[ilocal][2] = coord[2];
atom->x0[ilocal][0] = atom->x[ilocal][0];
atom->x0[ilocal][1] = atom->x[ilocal][1];
atom->x0[ilocal][2] = atom->x[ilocal][2];
}
/* ----------------------------------------------------------------------

2
src/PERI/atom_vec_peri.h
View File

@ -27,7 +27,7 @@ namespace LAMMPS_NS {
class AtomVecPeri : public AtomVec {
public:
AtomVecPeri(class LAMMPS *);
void create_atom(int, double *);
void create_atom_post(int);
void data_atom_post(int);
int property_atom(char *);
void pack_property_atom(int, double *, int, int);

929
src/USER-DPD/atom_vec_dpd.cpp
View File

@ -17,13 +17,7 @@
#include "atom_vec_dpd.h"
#include "atom.h"
#include "comm.h"
#include "domain.h"
#include "modify.h"
#include "fix.h"
#include "memory.h"
#include "error.h"
#include "utils.h"
using namespace LAMMPS_NS;
@ -34,904 +28,55 @@ AtomVecDPD::AtomVecDPD(LAMMPS *lmp) : AtomVec(lmp)
molecular = 0;
mass_type = 1;
comm_x_only = comm_f_only = 0; // we communicate not only x forward but also dpdTheta
size_forward = 7; // 3 + dpdTheta + uCond + uMech + uChem
size_reverse = 3; // 3
size_border = 12; // 6 + dpdTheta + uCond + uMech + uChem + uCG + uCGnew
size_velocity = 3;
size_data_atom = 6; // we read id + type + dpdTheta + x + y + z
size_data_vel = 4;
xcol_data = 4; // 1=id 2=type 3=dpdTheta 4=x
atom->rho_flag = 1;
atom->dpd_flag = 1;
// strings with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings
// order of fields in the string does not matter
// except fields_data_atom and fields_data_vel which must match data file
fields_grow = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem";
fields_copy = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_comm = (char *) "dpdTheta uCond uMech uChem";
fields_comm_vel = (char *) "dpdTheta uCond uMech uChem";
fields_reverse = NULL;
fields_border = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_border_vel = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_exchange = (char *) "dpdTheta uCond uMech uChem uCG uCGnew";
fields_restart = (char *) "dpdTheta uCond uMech uChem";
fields_create = (char *) "rho dpdTheta uCond uMech uChem uCG uCGnew duChem";
fields_data_atom = (char *) "id type dpdTheta x";
fields_data_vel = (char *) "omega";
setup_fields();
}
/* ----------------------------------------------------------------------
grow atom arrays
n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n
initialize other atom quantities after AtomVec::unpack_restart()
------------------------------------------------------------------------- */
void AtomVecDPD::grow(int n)
void AtomVecDPD::unpack_restart_init(int ilocal)
{
if (n == 0) grow_nmax();
else nmax = n;
atom->nmax = nmax;
if (nmax < 0)
error->one(FLERR,"Per-processor system is too big");
tag = memory->grow(atom->tag,nmax,"atom:tag");
type = memory->grow(atom->type,nmax,"atom:type");
mask = memory->grow(atom->mask,nmax,"atom:mask");
image = memory->grow(atom->image,nmax,"atom:image");
x = memory->grow(atom->x,nmax,3,"atom:x");
v = memory->grow(atom->v,nmax,3,"atom:v");
f = memory->grow(atom->f,nmax*comm->nthreads,3,"atom:f");
rho = memory->grow(atom->rho, nmax, "atom:rho");
dpdTheta = memory->grow(atom->dpdTheta, nmax, "atom:dpdTheta");
uCond = memory->grow(atom->uCond,nmax,"atom:uCond");
uMech = memory->grow(atom->uMech,nmax,"atom:uMech");
uChem = memory->grow(atom->uChem,nmax,"atom:uChem");
uCG = memory->grow(atom->uCG,nmax,"atom:uCG");
uCGnew = memory->grow(atom->uCGnew,nmax,"atom:uCGnew");
duChem = memory->grow(atom->duChem,nmax,"atom:duChem");
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->grow_arrays(nmax);
atom->uCG[ilocal] = 0.0;
atom->uCGnew[ilocal] = 0.0;
}
/* ----------------------------------------------------------------------
reset local array ptrs
modify what AtomVec::data_atom() just unpacked
or initialize other atom quantities
------------------------------------------------------------------------- */
void AtomVecDPD::grow_reset()
void AtomVecDPD::data_atom_post(int ilocal)
{
tag = atom->tag; type = atom->type;
mask = atom->mask; image = atom->image;
x = atom->x; v = atom->v; f = atom->f;
rho = atom->rho;
dpdTheta = atom->dpdTheta;
uCond = atom->uCond;
uMech = atom->uMech;
uChem = atom->uChem;
uCG = atom->uCG;
uCGnew = atom->uCGnew;
duChem = atom->duChem;
}
/* ----------------------------------------------------------------------
copy atom I info to atom J
------------------------------------------------------------------------- */
void AtomVecDPD::copy(int i, int j, int delflag)
{
tag[j] = tag[i];
type[j] = type[i];
mask[j] = mask[i];
image[j] = image[i];
x[j][0] = x[i][0];
x[j][1] = x[i][1];
x[j][2] = x[i][2];
v[j][0] = v[i][0];
v[j][1] = v[i][1];
v[j][2] = v[i][2];
dpdTheta[j] = dpdTheta[i];
uCond[j] = uCond[i];
uMech[j] = uMech[i];
uChem[j] = uChem[i];
uCG[j] = uCG[i];
uCGnew[j] = uCGnew[i];
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::pack_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
{
int i,j,m;
double dx,dy,dz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz;
dy = pbc[1]*domain->yprd + pbc[3]*domain->yz;
dz = pbc[2]*domain->zprd;
}
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
}
}
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::pack_comm_vel(int n, int *list, double *buf,
int pbc_flag, int *pbc)
{
int i,j,m;
double dx,dy,dz,dvx,dvy,dvz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz;
dy = pbc[1]*domain->yprd + pbc[3]*domain->yz;
dz = pbc[2]*domain->zprd;
}
if (!deform_vremap) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
}
} else {
dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3];
dvz = pbc[2]*h_rate[2];
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
if (mask[i] & deform_groupbit) {
buf[m++] = v[j][0] + dvx;
buf[m++] = v[j][1] + dvy;
buf[m++] = v[j][2] + dvz;
} else {
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
}
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
}
}
}
return m;
}
/* ---------------------------------------------------------------------- */
void AtomVecDPD::unpack_comm(int n, int first, double *buf)
{
int i,m,last;
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++];
dpdTheta[i] = buf[m++];
uCond[i] = buf[m++];
uMech[i] = buf[m++];
uChem[i] = buf[m++];
}
}
/* ---------------------------------------------------------------------- */
void AtomVecDPD::unpack_comm_vel(int n, int first, double *buf)
{
int i,m,last;
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++];
v[i][0] = buf[m++];
v[i][1] = buf[m++];
v[i][2] = buf[m++];
dpdTheta[i] = buf[m++];
uCond[i] = buf[m++];
uMech[i] = buf[m++];
uChem[i] = buf[m++];
}
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::pack_reverse(int n, int first, double *buf)
{
int i,m,last;
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];
}
return m;
}
/* ---------------------------------------------------------------------- */
void AtomVecDPD::unpack_reverse(int n, int *list, double *buf)
{
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
f[j][0] += buf[m++];
f[j][1] += buf[m++];
f[j][2] += buf[m++];
}
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::pack_border(int n, int *list, double *buf,
int pbc_flag, int *pbc)
{
int i,j,m;
double dx,dy,dz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
buf[m++] = uCG[j];
buf[m++] = uCGnew[j];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0];
dy = pbc[1];
dz = pbc[2];
}
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
buf[m++] = uCG[j];
buf[m++] = uCGnew[j];
}
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::pack_border_vel(int n, int *list, double *buf,
int pbc_flag, int *pbc)
{
int i,j,m;
double dx,dy,dz,dvx,dvy,dvz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
buf[m++] = uCG[j];
buf[m++] = uCGnew[j];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0];
dy = pbc[1];
dz = pbc[2];
}
if (!deform_vremap) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
buf[m++] = uCG[j];
buf[m++] = uCGnew[j];
}
} else {
dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3];
dvz = pbc[2]*h_rate[2];
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
if (mask[i] & deform_groupbit) {
buf[m++] = v[j][0] + dvx;
buf[m++] = v[j][1] + dvy;
buf[m++] = v[j][2] + dvz;
} else {
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
}
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
buf[m++] = uCG[j];
buf[m++] = uCGnew[j];
}
}
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::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++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::pack_border_hybrid(int n, int *list, double *buf)
{
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = dpdTheta[j];
buf[m++] = uCond[j];
buf[m++] = uMech[j];
buf[m++] = uChem[j];
buf[m++] = uCG[j];
buf[m++] = uCGnew[j];
}
return m;
}
/* ---------------------------------------------------------------------- */
void AtomVecDPD::unpack_border(int n, int first, double *buf)
{
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
if (i == nmax) grow(0);
x[i][0] = buf[m++];
x[i][1] = buf[m++];
x[i][2] = buf[m++];
tag[i] = (tagint) ubuf(buf[m++]).i;
type[i] = (int) ubuf(buf[m++]).i;
mask[i] = (int) ubuf(buf[m++]).i;
dpdTheta[i] = buf[m++];
uCond[i] = buf[m++];
uMech[i] = buf[m++];
uChem[i] = buf[m++];
uCG[i] = buf[m++];
uCGnew[i] = buf[m++];
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->
unpack_border(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
void AtomVecDPD::unpack_border_vel(int n, int first, double *buf)
{
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
if (i == nmax) grow(0);
x[i][0] = buf[m++];
x[i][1] = buf[m++];
x[i][2] = buf[m++];
tag[i] = (tagint) ubuf(buf[m++]).i;
type[i] = (int) ubuf(buf[m++]).i;
mask[i] = (int) ubuf(buf[m++]).i;
v[i][0] = buf[m++];
v[i][1] = buf[m++];
v[i][2] = buf[m++];
dpdTheta[i] = buf[m++];
uCond[i] = buf[m++];
uMech[i] = buf[m++];
uChem[i] = buf[m++];
uCG[i] = buf[m++];
uCGnew[i] = buf[m++];
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->
unpack_border(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::unpack_comm_hybrid(int n, int first, double *buf)
{
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
dpdTheta[i] = buf[m++];
uCond[i] = buf[m++];
uMech[i] = buf[m++];
uChem[i] = buf[m++];
}
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::unpack_border_hybrid(int n, int first, double *buf)
{
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
dpdTheta[i] = buf[m++];
uCond[i] = buf[m++];
uMech[i] = buf[m++];
uChem[i] = buf[m++];
uCG[i] = buf[m++];
uCGnew[i] = buf[m++];
}
return m;
}
/* ----------------------------------------------------------------------
pack data for atom I for sending to another proc
xyz must be 1st 3 values, so comm::exchange() can test on them
------------------------------------------------------------------------- */
int AtomVecDPD::pack_exchange(int i, double *buf)
{
int m = 1;
buf[m++] = x[i][0];
buf[m++] = x[i][1];
buf[m++] = x[i][2];
buf[m++] = v[i][0];
buf[m++] = v[i][1];
buf[m++] = v[i][2];
buf[m++] = ubuf(tag[i]).d;
buf[m++] = ubuf(type[i]).d;
buf[m++] = ubuf(mask[i]).d;
buf[m++] = ubuf(image[i]).d;
buf[m++] = dpdTheta[i];
buf[m++] = uCond[i];
buf[m++] = uMech[i];
buf[m++] = uChem[i];
buf[m++] = uCG[i];
buf[m++] = uCGnew[i];
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf[m]);
buf[0] = m;
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecDPD::unpack_exchange(double *buf)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) grow(0);
int m = 1;
x[nlocal][0] = buf[m++];
x[nlocal][1] = buf[m++];
x[nlocal][2] = buf[m++];
v[nlocal][0] = buf[m++];
v[nlocal][1] = buf[m++];
v[nlocal][2] = buf[m++];
tag[nlocal] = (tagint) ubuf(buf[m++]).i;
type[nlocal] = (int) ubuf(buf[m++]).i;
mask[nlocal] = (int) ubuf(buf[m++]).i;
image[nlocal] = (imageint) ubuf(buf[m++]).i;
dpdTheta[nlocal] = buf[m++];
uCond[nlocal] = buf[m++];
uMech[nlocal] = buf[m++];
uChem[nlocal] = buf[m++];
uCG[nlocal] = buf[m++];
uCGnew[nlocal] = buf[m++];
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
m += modify->fix[atom->extra_grow[iextra]]->
unpack_exchange(nlocal,&buf[m]);
atom->nlocal++;
return m;
}
/* ----------------------------------------------------------------------
size of restart data for all atoms owned by this proc
include extra data stored by fixes
------------------------------------------------------------------------- */
int AtomVecDPD::size_restart()
{
int i;
int nlocal = atom->nlocal;
int n = 15 * nlocal; // 11 + dpdTheta + uCond + uMech + uChem
if (atom->nextra_restart)
for (int iextra = 0; iextra < atom->nextra_restart; iextra++)
for (i = 0; i < nlocal; i++)
n += modify->fix[atom->extra_restart[iextra]]->size_restart(i);
return n;
}
/* ----------------------------------------------------------------------
pack atom I's data for restart file including extra quantities
xyz must be 1st 3 values, so that read_restart can test on them
molecular types may be negative, but write as positive
------------------------------------------------------------------------- */
int AtomVecDPD::pack_restart(int i, double *buf)
{
int m = 1;
buf[m++] = x[i][0];
buf[m++] = x[i][1];
buf[m++] = x[i][2];
buf[m++] = ubuf(tag[i]).d;
buf[m++] = ubuf(type[i]).d;
buf[m++] = ubuf(mask[i]).d;
buf[m++] = ubuf(image[i]).d;
buf[m++] = v[i][0];
buf[m++] = v[i][1];
buf[m++] = v[i][2];
buf[m++] = dpdTheta[i];
buf[m++] = uCond[i];
buf[m++] = uMech[i];
buf[m++] = uChem[i];
if (atom->nextra_restart)
for (int iextra = 0; iextra < atom->nextra_restart; iextra++)
m += modify->fix[atom->extra_restart[iextra]]->pack_restart(i,&buf[m]);
buf[0] = m;
return m;
}
/* ----------------------------------------------------------------------
unpack data for one atom from restart file including extra quantities
------------------------------------------------------------------------- */
int AtomVecDPD::unpack_restart(double *buf)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) {
grow(0);
if (atom->nextra_store)
memory->grow(atom->extra,nmax,atom->nextra_store,"atom:extra");
}
int m = 1;
x[nlocal][0] = buf[m++];
x[nlocal][1] = buf[m++];
x[nlocal][2] = buf[m++];
tag[nlocal] = (tagint) ubuf(buf[m++]).i;
type[nlocal] = (int) ubuf(buf[m++]).i;
mask[nlocal] = (int) ubuf(buf[m++]).i;
image[nlocal] = (imageint) ubuf(buf[m++]).i;
v[nlocal][0] = buf[m++];
v[nlocal][1] = buf[m++];
v[nlocal][2] = buf[m++];
dpdTheta[nlocal] = buf[m++];
uCond[nlocal] = buf[m++];
uMech[nlocal] = buf[m++];
uChem[nlocal] = buf[m++];
uCG[nlocal] = 0.0;
uCGnew[nlocal] = 0.0;
double **extra = atom->extra;
if (atom->nextra_store) {
int size = static_cast<int> (buf[0]) - m;
for (int i = 0; i < size; i++) extra[nlocal][i] = buf[m++];
}
atom->nlocal++;
return m;
}
/* ----------------------------------------------------------------------
create one atom of itype at coord
set other values to defaults
------------------------------------------------------------------------- */
void AtomVecDPD::create_atom(int itype, double *coord)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) grow(0);
tag[nlocal] = 0;
type[nlocal] = itype;
x[nlocal][0] = coord[0];
x[nlocal][1] = coord[1];
x[nlocal][2] = coord[2];
mask[nlocal] = 1;
image[nlocal] = ((imageint) IMGMAX << IMG2BITS) |
((imageint) IMGMAX << IMGBITS) | IMGMAX;
v[nlocal][0] = 0.0;
v[nlocal][1] = 0.0;
v[nlocal][2] = 0.0;
rho[nlocal] = 0.0;
dpdTheta[nlocal] = 0.0;
uCond[nlocal] = 0.0;
uMech[nlocal] = 0.0;
uChem[nlocal] = 0.0;
uCG[nlocal] = 0.0;
uCGnew[nlocal] = 0.0;
duChem[nlocal] = 0.0;
atom->nlocal++;
}
/* ----------------------------------------------------------------------
unpack one line from Atoms section of data file
initialize other atom quantities
------------------------------------------------------------------------- */
void AtomVecDPD::data_atom(double *coord, tagint imagetmp, char **values)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) grow(0);
tag[nlocal] = utils::tnumeric(FLERR,values[0],true,lmp);
type[nlocal] = utils::inumeric(FLERR,values[1],true,lmp);
if (type[nlocal] <= 0 || type[nlocal] > atom->ntypes)
error->one(FLERR,"Invalid atom type in Atoms section of data file");
dpdTheta[nlocal] = utils::numeric(FLERR,values[2],true,lmp);
if (dpdTheta[nlocal] <= 0)
error->one(FLERR,"Internal temperature in Atoms section of date file must be > zero");
x[nlocal][0] = coord[0];
x[nlocal][1] = coord[1];
x[nlocal][2] = coord[2];
image[nlocal] = imagetmp;
mask[nlocal] = 1;
v[nlocal][0] = 0.0;
v[nlocal][1] = 0.0;
v[nlocal][2] = 0.0;
rho[nlocal] = 0.0;
uCond[nlocal] = 0.0;
uMech[nlocal] = 0.0;
uChem[nlocal] = 0.0;
uCG[nlocal] = 0.0;
uCGnew[nlocal] = 0.0;
atom->nlocal++;
}
/* ----------------------------------------------------------------------
unpack hybrid quantities from one line in Atoms section of data file
initialize other atom quantities for this sub-style
------------------------------------------------------------------------- */
int AtomVecDPD::data_atom_hybrid(int nlocal, char **values)
{
dpdTheta[nlocal] = utils::numeric(FLERR,values[0],true,lmp);
return 1;
}
/* ----------------------------------------------------------------------
pack atom info for data file including 3 image flags
------------------------------------------------------------------------- */
void AtomVecDPD::pack_data(double **buf)
{
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
buf[i][0] = ubuf(tag[i]).d;
buf[i][1] = ubuf(type[i]).d;
buf[i][2] = dpdTheta[i];
buf[i][3] = x[i][0];
buf[i][4] = x[i][1];
buf[i][5] = x[i][2];
buf[i][6] = ubuf((image[i] & IMGMASK) - IMGMAX).d;
buf[i][7] = ubuf((image[i] >> IMGBITS & IMGMASK) - IMGMAX).d;
buf[i][8] = ubuf((image[i] >> IMG2BITS) - IMGMAX).d;
}
}
/* ----------------------------------------------------------------------
pack hybrid atom info for data file
------------------------------------------------------------------------- */
int AtomVecDPD::pack_data_hybrid(int i, double *buf)
{
buf[0] = dpdTheta[i];
return 1;
}
/* ----------------------------------------------------------------------
write atom info to data file including 3 image flags
------------------------------------------------------------------------- */
void AtomVecDPD::write_data(FILE *fp, int n, double **buf)
{
for (int i = 0; i < n; i++)
fprintf(fp,TAGINT_FORMAT " %d %-1.16e %-1.16e %-1.16e %-1.16e %d %d %d\n",
(tagint) ubuf(buf[i][0]).i,(int) ubuf(buf[i][1]).i,
buf[i][2],buf[i][3],buf[i][4],buf[i][5],
(int) ubuf(buf[i][6]).i,(int) ubuf(buf[i][7]).i,
(int) ubuf(buf[i][8]).i);
}
/* ----------------------------------------------------------------------
write hybrid atom info to data file
------------------------------------------------------------------------- */
int AtomVecDPD::write_data_hybrid(FILE *fp, double *buf)
{
fprintf(fp," %-1.16e",buf[0]);
return 1;
}
/* ----------------------------------------------------------------------
return # of bytes of allocated memory
------------------------------------------------------------------------- */
bigint AtomVecDPD::memory_usage()
{
bigint bytes = 0;
if (atom->memcheck("tag")) bytes += memory->usage(tag,nmax);
if (atom->memcheck("type")) bytes += memory->usage(type,nmax);
if (atom->memcheck("mask")) bytes += memory->usage(mask,nmax);
if (atom->memcheck("image")) bytes += memory->usage(image,nmax);
if (atom->memcheck("x")) bytes += memory->usage(x,nmax,3);
if (atom->memcheck("v")) bytes += memory->usage(v,nmax,3);
if (atom->memcheck("f")) bytes += memory->usage(f,nmax*comm->nthreads,3);
if (atom->memcheck("rho")) bytes += memory->usage(rho,nmax);
if (atom->memcheck("dpdTheta")) bytes += memory->usage(dpdTheta,nmax);
if (atom->memcheck("uCond")) bytes += memory->usage(uCond,nmax);
if (atom->memcheck("uMech")) bytes += memory->usage(uMech,nmax);
if (atom->memcheck("uChem")) bytes += memory->usage(uChem,nmax);
if (atom->memcheck("uCG")) bytes += memory->usage(uCG,nmax);
if (atom->memcheck("uCGnew")) bytes += memory->usage(uCGnew,nmax);
if (atom->memcheck("duChem")) bytes += memory->usage(duChem,nmax);
return bytes;
atom->rho[ilocal] = 0.0;
atom->uCond[ilocal] = 0.0;
atom->uMech[ilocal] = 0.0;
atom->uChem[ilocal] = 0.0;
atom->uCG[ilocal] = 0.0;
atom->uCGnew[ilocal] = 0.0;
if (atom->dpdTheta[ilocal] <= 0)
error->one(FLERR,"Internal temperature in Atoms section of date file "
"must be > zero");
}

51
src/USER-DPD/atom_vec_dpd.h
View File

@ -27,46 +27,8 @@ namespace LAMMPS_NS {
class AtomVecDPD : public AtomVec {
public:
AtomVecDPD(class LAMMPS *);
virtual ~AtomVecDPD() {}
void grow(int);
void grow_reset();
void copy(int, int, int);
virtual int pack_comm(int, int *, double *, int, int *);
virtual int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_hybrid(int, int *, double *);
virtual void unpack_comm(int, int, double *);
virtual void unpack_comm_vel(int, int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
void unpack_reverse(int, int *, double *);
virtual int pack_border(int, int *, double *, int, int *);
virtual int pack_border_vel(int, int *, double *, int, int *);
int pack_border_hybrid(int, int *, double *);
virtual void unpack_border(int, int, double *);
virtual void unpack_border_vel(int, int, double *);
int unpack_border_hybrid(int, int, double *);
virtual int pack_exchange(int, double *);
virtual int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
int data_atom_hybrid(int, char **);
void pack_data(double **);
int pack_data_hybrid(int, double *);
void write_data(FILE *, int, double **);
int write_data_hybrid(FILE *, double *);
bigint memory_usage();
double *uCond,*uMech,*uChem,*uCG,*uCGnew,*rho,*dpdTheta;
double *duChem;
protected:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f;
void unpack_restart_init(int);
void data_atom_post(int);
};
}
@ -76,15 +38,6 @@ class AtomVecDPD : public AtomVec {
/* ERROR/WARNING messages:
E: Per-processor system is too big
The number of owned atoms plus ghost atoms on a single
processor must fit in 32-bit integer.
E: Invalid atom type in Atoms section of data file
Atom types must range from 1 to specified # of types.
E: Internal temperature in Atoms section of data file must be > zero
All internal temperatures must be > zero

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

File diff suppressed because it is too large Load Diff

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

@ -27,56 +27,11 @@ namespace LAMMPS_NS {
class AtomVecElectron : public AtomVec {
public:
AtomVecElectron(class LAMMPS *);
~AtomVecElectron() {}
void grow(int);
void grow_reset();
void copy(int, int, int);
void force_clear(int, size_t);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, 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_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
int data_atom_hybrid(int, char **);
void data_vel(int, char **);
int data_vel_hybrid(int, char **);
void pack_data(double **);
int pack_data_hybrid(int, double *);
void write_data(FILE *, int, double **);
int write_data_hybrid(FILE *, double *);
void pack_vel(double **);
int pack_vel_hybrid(int, double *);
void write_vel(FILE *, int, double **);
int write_vel_hybrid(FILE *, double *);
void create_atom_post(int);
void data_atom_post(int);
int property_atom(char *);
void pack_property_atom(int, double *, int, int);
bigint memory_usage();
private:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f;
int *spin;
double *q,*eradius,*ervel,*erforce;
};
}

819
src/USER-MESO/atom_vec_edpd.cpp
View File

@ -10,6 +10,7 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "atom_vec_edpd.h"
#include <cstring>
#include "atom.h"
@ -28,817 +29,65 @@ using namespace LAMMPS_NS;
AtomVecEDPD::AtomVecEDPD(LAMMPS *lmp) : AtomVec(lmp)
{
if(strcmp(update->unit_style,"lj") != 0)
if (strcmp(update->unit_style,"lj") != 0)
error->all(FLERR,"Atom style edpd requires lj units");
molecular = 0;
mass_type = 1;
forceclearflag = 1;
comm_x_only = comm_f_only = 0;
comm->ghost_velocity = 1;
size_forward = 3 + 5; // edpd_temp + vest[4]
size_reverse = 3 + 1; // edpd_flux
size_border = 6 + 6; // edpd_temp + edpd_cv + vest[4]
size_velocity = 3;
size_data_atom = 5 + 2; // we read id + type + edpd_temp + edpd_cv + xyz[3]
size_data_vel = 4;
xcol_data = 5;
atom->edpd_flag = 1;
atom->vest_flag = 1;
}
/* ----------------------------------------------------------------------
grow atom arrays
n = 0 grows arrays by a chunk
n > 0 allocates arrays to size n
------------------------------------------------------------------------- */
// strings with peratom variables to include in each AtomVec method
// strings cannot contain fields in corresponding AtomVec default strings
// order of fields in the string does not matter
// except fields_data_atom and fields_data_vel which must match data file
void AtomVecEDPD::grow(int n)
{
if (n == 0) grow_nmax();
else nmax = n;
atom->nmax = nmax;
if (nmax < 0 || nmax > MAXSMALLINT)
error->one(FLERR,"Per-processor system is too big");
fields_grow = (char *) "edpd_cv edpd_temp edpd_flux vest";
fields_copy = (char *) "edpd_cv edpd_temp edpd_flux vest";
fields_comm = (char *) "edpd_temp vest";
fields_comm_vel = (char *) "edpd_temp vest";
fields_reverse = (char *) "edpd_flux";
fields_border = (char *) "edpd_cv edpd_temp vest";
fields_border_vel = (char *) "edpd_cv edpd_temp vest";
fields_exchange = (char *) "edpd_cv edpd_temp vest";
fields_restart = (char * ) "edpd_cv edpd_temp vest";
fields_create = (char *) "edpd_cv edpd_temp edpd_flux vest";
fields_data_atom = (char *) "id type edpd_temp edpd_cv x";
fields_data_vel = NULL;
tag = memory->grow(atom->tag,nmax,"atom:tag");
type = memory->grow(atom->type,nmax,"atom:type");
mask = memory->grow(atom->mask,nmax,"atom:mask");
image = memory->grow(atom->image,nmax,"atom:image");
x = memory->grow(atom->x,nmax,3,"atom:x");
v = memory->grow(atom->v,nmax,3,"atom:v");
f = memory->grow(atom->f,nmax*comm->nthreads,3,"atom:f");
edpd_cv= memory->grow(atom->edpd_cv, nmax, "atom:edpd_cv");
edpd_temp = memory->grow(atom->edpd_temp, nmax, "atom:edpd_temp");
edpd_flux = memory->grow(atom->edpd_flux, nmax*comm->nthreads,"atom:edpd_flux");
vest = memory->grow(atom->vest, nmax, 4, "atom:vest");
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->grow_arrays(nmax);
}
/* ----------------------------------------------------------------------
reset local array ptrs
------------------------------------------------------------------------- */
void AtomVecEDPD::grow_reset()
{
tag = atom->tag; type = atom->type;
mask = atom->mask; image = atom->image;
x = atom->x; v = atom->v; f = atom->f;
edpd_cv = atom->cv; edpd_temp = atom->edpd_temp; edpd_flux = atom->edpd_flux;
vest = atom->vest;
}
/* ----------------------------------------------------------------------
copy atom I info to atom J
------------------------------------------------------------------------- */
void AtomVecEDPD::copy(int i, int j, int delflag)
{
tag[j] = tag[i];
type[j] = type[i];
mask[j] = mask[i];
image[j] = image[i];
x[j][0] = x[i][0];
x[j][1] = x[i][1];
x[j][2] = x[i][2];
v[j][0] = v[i][0];
v[j][1] = v[i][1];
v[j][2] = v[i][2];
edpd_temp[j] = edpd_temp[i];
edpd_flux[j] = edpd_flux[i];
edpd_cv[j] = edpd_cv[i];
vest[j][0] = vest[i][0];
vest[j][1] = vest[i][1];
vest[j][2] = vest[i][2];
vest[j][3] = vest[i][3];
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
void AtomVecEDPD::force_clear(int n, size_t nbytes)
{
memset(&edpd_flux[n],0,nbytes);
}
/* ---------------------------------------------------------------------- */
int AtomVecEDPD::pack_comm(int n, int *list, double *buf,
int pbc_flag, int *pbc)
{
int i,j,m;
double dx,dy,dz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = edpd_temp[j];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz;
dy = pbc[1]*domain->yprd + pbc[3]*domain->yz;
dz = pbc[2]*domain->zprd;
}
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = edpd_temp[j];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
}
return m;
setup_fields();
}
/* ---------------------------------------------------------------------- */
int AtomVecEDPD::pack_comm_vel(int n, int *list, double *buf,
int pbc_flag, int *pbc)
void AtomVecEDPD::force_clear(int /*n*/, size_t nbytes)
{
int i,j,m;
double dx,dy,dz,dvx,dvy,dvz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = edpd_temp[j];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz;
dy = pbc[1]*domain->yprd + pbc[3]*domain->yz;
dz = pbc[2]*domain->zprd;
}
if (!deform_vremap) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = edpd_temp[j];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
} else {
dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3];
dvz = pbc[2]*h_rate[2];
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
if (mask[i] & deform_groupbit) {
buf[m++] = v[j][0] + dvx;
buf[m++] = v[j][1] + dvy;
buf[m++] = v[j][2] + dvz;
} else {
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
}
buf[m++] = edpd_temp[j];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
}
}
return m;
}
/* ---------------------------------------------------------------------- */
void AtomVecEDPD::unpack_comm(int n, int first, double *buf)
{
int i,m,last;
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++];
edpd_temp[i] = buf[m++];
vest[i][0] = buf[m++];
vest[i][1] = buf[m++];
vest[i][2] = buf[m++];
vest[i][3] = buf[m++];
}
}
/* ---------------------------------------------------------------------- */
void AtomVecEDPD::unpack_comm_vel(int n, int first, double *buf)
{
int i,m,last;
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++];
v[i][0] = buf[m++];
v[i][1] = buf[m++];
v[i][2] = buf[m++];
edpd_temp[i] = buf[m++];
vest[i][0] = buf[m++];
vest[i][1] = buf[m++];
vest[i][2] = buf[m++];
vest[i][3] = buf[m++];
}
}
/* ---------------------------------------------------------------------- */
int AtomVecEDPD::pack_reverse(int n, int first, double *buf)
{
int i,m,last;
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];
buf[m++] = edpd_flux[i];
}
return m;
}
/* ---------------------------------------------------------------------- */
void AtomVecEDPD::unpack_reverse(int n, int *list, double *buf)
{
int i,j,m;
m = 0;
for (i = 0; i < n; i++) {
j = list[i];
f[j][0] += buf[m++];
f[j][1] += buf[m++];
f[j][2] += buf[m++];
edpd_flux[j] += buf[m++];
}
}
/* ---------------------------------------------------------------------- */
int AtomVecEDPD::pack_border(int n, int *list, double *buf,
int pbc_flag, int *pbc)
{
int i,j,m;
double dx,dy,dz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = edpd_temp[j];
buf[m++] = edpd_cv[j];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0];
dy = pbc[1];
dz = pbc[2];
}
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = edpd_temp[j];
buf[m++] = edpd_cv[j];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecEDPD::pack_border_vel(int n, int *list, double *buf,
int pbc_flag, int *pbc)
{
int i,j,m;
double dx,dy,dz,dvx,dvy,dvz;
m = 0;
if (pbc_flag == 0) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0];
buf[m++] = x[j][1];
buf[m++] = x[j][2];
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = edpd_temp[j];
buf[m++] = edpd_cv[j];
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
} else {
if (domain->triclinic == 0) {
dx = pbc[0]*domain->xprd;
dy = pbc[1]*domain->yprd;
dz = pbc[2]*domain->zprd;
} else {
dx = pbc[0];
dy = pbc[1];
dz = pbc[2];
}
if (!deform_vremap) {
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = edpd_temp[j];
buf[m++] = edpd_cv[j];
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
} else {
dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3];
dvz = pbc[2]*h_rate[2];
for (i = 0; i < n; i++) {
j = list[i];
buf[m++] = x[j][0] + dx;
buf[m++] = x[j][1] + dy;
buf[m++] = x[j][2] + dz;
buf[m++] = ubuf(tag[j]).d;
buf[m++] = ubuf(type[j]).d;
buf[m++] = ubuf(mask[j]).d;
buf[m++] = edpd_temp[j];
buf[m++] = edpd_cv[j];
if (mask[i] & deform_groupbit) {
buf[m++] = v[j][0] + dvx;
buf[m++] = v[j][1] + dvy;
buf[m++] = v[j][2] + dvz;
buf[m++] = vest[j][0] + dvx;
buf[m++] = vest[j][1] + dvy;
buf[m++] = vest[j][2] + dvz;
buf[m++] = vest[j][3];
} else {
buf[m++] = v[j][0];
buf[m++] = v[j][1];
buf[m++] = v[j][2];
buf[m++] = vest[j][0];
buf[m++] = vest[j][1];
buf[m++] = vest[j][2];
buf[m++] = vest[j][3];
}
}
}
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
return m;
}
/* ---------------------------------------------------------------------- */
void AtomVecEDPD::unpack_border(int n, int first, double *buf)
{
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
if (i == nmax) grow(0);
x[i][0] = buf[m++];
x[i][1] = buf[m++];
x[i][2] = buf[m++];
tag[i] = (tagint) ubuf(buf[m++]).i;
type[i] = (int) ubuf(buf[m++]).i;
mask[i] = (int) ubuf(buf[m++]).i;
edpd_temp[i] = buf[m++];
edpd_cv[i] = buf[m++];
vest[i][0] = buf[m++];
vest[i][1] = buf[m++];
vest[i][2] = buf[m++];
vest[i][3] = buf[m++];
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->
unpack_border(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
void AtomVecEDPD::unpack_border_vel(int n, int first, double *buf)
{
int i,m,last;
m = 0;
last = first + n;
for (i = first; i < last; i++) {
if (i == nmax) grow(0);
x[i][0] = buf[m++];
x[i][1] = buf[m++];
x[i][2] = buf[m++];
tag[i] = (tagint) ubuf(buf[m++]).i;
type[i] = (int) ubuf(buf[m++]).i;
mask[i] = (int) ubuf(buf[m++]).i;
edpd_temp[i] = buf[m++];
edpd_cv[i] = buf[m++];
v[i][0] = buf[m++];
v[i][1] = buf[m++];
v[i][2] = buf[m++];
vest[i][0] = buf[m++];
vest[i][1] = buf[m++];
vest[i][2] = buf[m++];
vest[i][3] = buf[m++];
}
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->
unpack_border(n,first,&buf[m]);
memset(&atom->edpd_flux[0],0,nbytes);
}
/* ----------------------------------------------------------------------
pack data for atom I for sending to another proc
xyz must be 1st 3 values, so comm::exchange() can test on them
initialize non-zero atom quantities
------------------------------------------------------------------------- */
int AtomVecEDPD::pack_exchange(int i, double *buf)
void AtomVecEDPD::create_atom_post(int ilocal)
{
int m = 1;
buf[m++] = x[i][0];
buf[m++] = x[i][1];
buf[m++] = x[i][2];
buf[m++] = v[i][0];
buf[m++] = v[i][1];
buf[m++] = v[i][2];
buf[m++] = ubuf(tag[i]).d;
buf[m++] = ubuf(type[i]).d;
buf[m++] = ubuf(mask[i]).d;
buf[m++] = ubuf(image[i]).d;
buf[m++] = edpd_temp[i];
buf[m++] = edpd_cv[i];
buf[m++] = vest[i][0];
buf[m++] = vest[i][1];
buf[m++] = vest[i][2];
buf[m++] = vest[i][3];
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf[m]);
buf[0] = m;
return m;
}
/* ---------------------------------------------------------------------- */
int AtomVecEDPD::unpack_exchange(double *buf)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) grow(0);
int m = 1;
x[nlocal][0] = buf[m++];
x[nlocal][1] = buf[m++];
x[nlocal][2] = buf[m++];
v[nlocal][0] = buf[m++];
v[nlocal][1] = buf[m++];
v[nlocal][2] = buf[m++];
tag[nlocal] = (tagint) ubuf(buf[m++]).i;
type[nlocal] = (int) ubuf(buf[m++]).i;
mask[nlocal] = (int) ubuf(buf[m++]).i;
image[nlocal] = (imageint) ubuf(buf[m++]).i;
edpd_temp[nlocal] = buf[m++];
edpd_cv[nlocal] = buf[m++];
vest[nlocal][0] = buf[m++];
vest[nlocal][1] = buf[m++];
vest[nlocal][2] = buf[m++];
vest[nlocal][3] = buf[m++];
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
m += modify->fix[atom->extra_grow[iextra]]->
unpack_exchange(nlocal,&buf[m]);
atom->nlocal++;
return m;
atom->edpd_temp[ilocal] = 1.0;
atom->edpd_cv[ilocal]= 1.0e5;
atom->vest[ilocal][3] = atom->edpd_temp[ilocal];
}
/* ----------------------------------------------------------------------
size of restart data for all atoms owned by this proc
include extra data stored by fixes
modify what AtomVec::data_atom() just unpacked
or initialize other atom quantities
------------------------------------------------------------------------- */
int AtomVecEDPD::size_restart()
void AtomVecEDPD::data_atom_post(int ilocal)
{
int i;
int nlocal = atom->nlocal;
int n = (11 + 6) * nlocal; // 11 + edpd_temp + edpd_cv + vest[4]
if (atom->nextra_restart)
for (int iextra = 0; iextra < atom->nextra_restart; iextra++)
for (i = 0; i < nlocal; i++)
n += modify->fix[atom->extra_restart[iextra]]->size_restart(i);
return n;
}
/* ----------------------------------------------------------------------
pack atom I's data for restart file including extra quantities
xyz must be 1st 3 values, so that read_restart can test on them
molecular types may be negative, but write as positive
------------------------------------------------------------------------- */
int AtomVecEDPD::pack_restart(int i, double *buf)
{
int m = 1;
buf[m++] = x[i][0];
buf[m++] = x[i][1];
buf[m++] = x[i][2];
buf[m++] = ubuf(tag[i]).d;
buf[m++] = ubuf(type[i]).d;
buf[m++] = ubuf(mask[i]).d;
buf[m++] = ubuf(image[i]).d;
buf[m++] = v[i][0];
buf[m++] = v[i][1];
buf[m++] = v[i][2];
buf[m++] = edpd_temp[i];
buf[m++] = edpd_cv[i];
buf[m++] = vest[i][0];
buf[m++] = vest[i][1];
buf[m++] = vest[i][2];
buf[m++] = vest[i][3];
if (atom->nextra_restart)
for (int iextra = 0; iextra < atom->nextra_restart; iextra++)
m += modify->fix[atom->extra_restart[iextra]]->pack_restart(i,&buf[m]);
buf[0] = m;
return m;
}
/* ----------------------------------------------------------------------
unpack data for one atom from restart file including extra quantities
------------------------------------------------------------------------- */
int AtomVecEDPD::unpack_restart(double *buf)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) {
grow(0);
if (atom->nextra_store)
memory->grow(atom->extra,nmax,atom->nextra_store,"atom:extra");
}
int m = 1;
x[nlocal][0] = buf[m++];
x[nlocal][1] = buf[m++];
x[nlocal][2] = buf[m++];
tag[nlocal] = (tagint) ubuf(buf[m++]).i;
type[nlocal] = (int) ubuf(buf[m++]).i;
mask[nlocal] = (int) ubuf(buf[m++]).i;
image[nlocal] = (imageint) ubuf(buf[m++]).i;
v[nlocal][0] = buf[m++];
v[nlocal][1] = buf[m++];
v[nlocal][2] = buf[m++];
edpd_temp[nlocal] = buf[m++];
edpd_cv[nlocal]= buf[m++];
vest[nlocal][0] = buf[m++];
vest[nlocal][1] = buf[m++];
vest[nlocal][2] = buf[m++];
vest[nlocal][3] = buf[m++];
double **extra = atom->extra;
if (atom->nextra_store) {
int size = static_cast<int> (buf[0]) - m;
for (int i = 0; i < size; i++) extra[nlocal][i] = buf[m++];
}
atom->nlocal++;
return m;
}
/* ----------------------------------------------------------------------
create one atom of itype at coord
set other values to defaults
------------------------------------------------------------------------- */
void AtomVecEDPD::create_atom(int itype, double *coord)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) grow(0);
tag[nlocal] = 0;
type[nlocal] = itype;
x[nlocal][0] = coord[0];
x[nlocal][1] = coord[1];
x[nlocal][2] = coord[2];
mask[nlocal] = 1;
image[nlocal] = ((imageint) IMGMAX << IMG2BITS) |
((imageint) IMGMAX << IMGBITS) | IMGMAX;
v[nlocal][0] = 0.0;
v[nlocal][1] = 0.0;
v[nlocal][2] = 0.0;
edpd_temp[nlocal] = 1.0;
edpd_flux[nlocal] = 0.0;
edpd_cv[nlocal]= 1.0E5;
vest[nlocal][0] = 0.0;
vest[nlocal][1] = 0.0;
vest[nlocal][2] = 0.0;
vest[nlocal][3] = edpd_temp[nlocal];
atom->nlocal++;
}
/* ----------------------------------------------------------------------
unpack one line from Atoms section of data file
initialize other atom quantities
------------------------------------------------------------------------- */
void AtomVecEDPD::data_atom(double *coord, imageint imagetmp, char **values)
{
int nlocal = atom->nlocal;
if (nlocal == nmax) grow(0);
tag[nlocal] = utils::tnumeric(FLERR,values[0],true,lmp);
type[nlocal] = utils::inumeric(FLERR,values[1],true,lmp);
if (type[nlocal] <= 0 || type[nlocal] > atom->ntypes)
error->one(FLERR,"Invalid atom type in Atoms section of data file");
edpd_temp[nlocal] = utils::numeric(FLERR,values[2],true,lmp);
edpd_cv[nlocal] = utils::numeric(FLERR,values[3],true,lmp);
x[nlocal][0] = coord[0];
x[nlocal][1] = coord[1];
x[nlocal][2] = coord[2];
image[nlocal] = imagetmp;
mask[nlocal] = 1;
v[nlocal][0] = 0.0;
v[nlocal][1] = 0.0;
v[nlocal][2] = 0.0;
vest[nlocal][0] = 0.0;
vest[nlocal][1] = 0.0;
vest[nlocal][2] = 0.0;
vest[nlocal][3] = edpd_temp[nlocal];
edpd_flux[nlocal] = 0.0;
atom->nlocal++;
}
/* ----------------------------------------------------------------------
pack atom info for data file including 3 image flags
------------------------------------------------------------------------- */
void AtomVecEDPD::pack_data(double **buf)
{
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) {
buf[i][0] = ubuf(tag[i]).d;
buf[i][1] = ubuf(type[i]).d;
buf[i][2] = edpd_temp[i];
buf[i][3] = edpd_cv[i];
buf[i][4] = x[i][0];
buf[i][5] = x[i][1];
buf[i][6] = x[i][2];
buf[i][7] = ubuf((image[i] & IMGMASK) - IMGMAX).d;
buf[i][8] = ubuf((image[i] >> IMGBITS & IMGMASK) - IMGMAX).d;
buf[i][9] = ubuf((image[i] >> IMG2BITS) - IMGMAX).d;
}
}
/* ----------------------------------------------------------------------
write atom info to data file including 3 image flags
------------------------------------------------------------------------- */
void AtomVecEDPD::write_data(FILE *fp, int n, double **buf)
{
for (int i = 0; i < n; i++)
fprintf(fp,TAGINT_FORMAT " %d %-1.16e %-1.16e %-1.16e %-1.16e %-1.16e %d %d %d\n",
(tagint) ubuf(buf[i][0]).i,(int) ubuf(buf[i][1]).i,
buf[i][2],buf[i][3],buf[i][4],buf[i][5],buf[i][6],
(int) ubuf(buf[i][7]).i,(int) ubuf(buf[i][8]).i,(int) ubuf(buf[i][9]).i);
}
/* ----------------------------------------------------------------------
return # of bytes of allocated memory
------------------------------------------------------------------------- */
bigint AtomVecEDPD::memory_usage()
{
bigint bytes = 0;
if (atom->memcheck("tag")) bytes += memory->usage(tag,nmax);
if (atom->memcheck("type")) bytes += memory->usage(type,nmax);
if (atom->memcheck("mask")) bytes += memory->usage(mask,nmax);
if (atom->memcheck("image")) bytes += memory->usage(image,nmax);
if (atom->memcheck("x")) bytes += memory->usage(x,nmax,3);
if (atom->memcheck("v")) bytes += memory->usage(v,nmax,3);
if (atom->memcheck("f")) bytes += memory->usage(f,nmax*comm->nthreads,3);
if (atom->memcheck("edpd_temp")) bytes += memory->usage(edpd_temp,nmax);
if (atom->memcheck("edpd_flux")) bytes += memory->usage(edpd_flux,nmax*comm->nthreads);
if (atom->memcheck("edpd_cv")) bytes += memory->usage(edpd_cv,nmax);
if (atom->memcheck("vest")) bytes += memory->usage(vest,nmax,4);
return bytes;
atom->edpd_flux[ilocal] = 0.0;
atom->vest[ilocal][0] = 0.0;
atom->vest[ilocal][1] = 0.0;
atom->vest[ilocal][2] = 0.0;
atom->vest[ilocal][3] = atom->edpd_temp[ilocal];
}

34
src/USER-MESO/atom_vec_edpd.h
View File

@ -27,39 +27,9 @@ namespace LAMMPS_NS {
class AtomVecEDPD : public AtomVec {
public:
AtomVecEDPD(class LAMMPS *);
virtual ~AtomVecEDPD() {}
void grow(int);
void grow_reset();
void copy(int, int, int);
void force_clear(int, size_t);
virtual int pack_comm(int, int *, double *, int, int *);
virtual int pack_comm_vel(int, int *, double *, int, int *);
virtual void unpack_comm(int, int, double *);
virtual void unpack_comm_vel(int, int, double *);
int pack_reverse(int, int, double *);
void unpack_reverse(int, int *, double *);
virtual int pack_border(int, int *, double *, int, int *);
virtual int pack_border_vel(int, int *, double *, int, int *);
virtual void unpack_border(int, int, double *);
virtual void unpack_border_vel(int, int, double *);
virtual int pack_exchange(int, double *);
virtual int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
void pack_data(double **);
void write_data(FILE *, int, double **);
bigint memory_usage();
protected:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f;
double **vest; // store intermediate velocity for using mvv integrator
double *edpd_temp,*edpd_flux,*edpd_cv; // temperature, heat flux, and heat capacity
void create_atom_post(int);
void data_atom_post(int);
};
}

30
src/atom.cpp
View File

@ -459,8 +459,8 @@ void Atom::peratom_create()
add_peratom("radius",&radius,DOUBLE,0);
add_peratom("omega",&omega,DOUBLE,3);
add_peratom("amgmom",&angmom,DOUBLE,3);
add_peratom("torque",&torque,DOUBLE,3,1); // set per-thread flag
add_peratom("angmom",&angmom,DOUBLE,3);
add_peratom("ellipsoid",&ellipsoid,INT,0);
add_peratom("line",&line,INT,0);
@ -524,6 +524,31 @@ void Atom::peratom_create()
add_peratom("sp",&sp,DOUBLE,4);
add_peratom("fm",&fm,DOUBLE,3,1);
add_peratom("fm_long",&fm_long,DOUBLE,3,1);
// USER-EFF package
add_peratom("spin",&spin,INT,0);
add_peratom("eradius",&eradius,DOUBLE,0);
add_peratom("ervel",&ervel,DOUBLE,0);
add_peratom("erforce",&erforce,DOUBLE,0,1); // set per-thread flag
// USER-DPD package
add_peratom("rho",&eradius,DOUBLE,0);
add_peratom("dpdTheta",&dpdTheta,DOUBLE,0);
add_peratom("uCond",&uCond,DOUBLE,0);
add_peratom("uMech",&uMech,DOUBLE,0);
add_peratom("uChem",&uChem,DOUBLE,0);
add_peratom("uCG",&uCG,DOUBLE,0);
add_peratom("uCGnew",&uCGnew,DOUBLE,0);
add_peratom("duChem",&duChem,DOUBLE,0);
// USER-MESO package
add_peratom("edpd_cv",&edpd_cv,DOUBLE,0);
add_peratom("edpd_temp",&edpd_temp,DOUBLE,0);
add_peratom("edpd_flux",&edpd_flux,DOUBLE,0,1); // set per-thread flag
add_peratom("vest",&vest,DOUBLE,4);
}
/* ----------------------------------------------------------------------
@ -1605,8 +1630,7 @@ void Atom::data_bonus(int n, char *buf, AtomVec *avec_bonus, tagint id_offset)
call style-specific routine to parse line
------------------------------------------------------------------------- */
void Atom::data_bodies(int n, char *buf, AtomVecBody *avec_body,
tagint id_offset)
void Atom::data_bodies(int n, char *buf, AtomVec *avec_body, tagint id_offset)
{
int j,m,nvalues,tagdata,ninteger,ndouble;

15
src/atom.h
View File

@ -121,7 +121,7 @@ class Atom : protected Pointers {
// USER-MESO package
double **cc, **cc_flux; // cc = chemical concentration
double **cc,**cc_flux; // cc = chemical concentration
double *edpd_temp,*edpd_flux; // temperature and heat flux
double *edpd_cv; // heat capacity
int cc_species;
@ -141,13 +141,12 @@ class Atom : protected Pointers {
double **vest;
// --------------------------------------------------------------------
// 1st customization section: customize by adding new flag
// existence flags for per-atom vectors and arrays
// 1st customization section: customize by adding new flags
// most are existence flags for per-atom vectors and arrays
// 1 if variable is used, 0 if not
int sphere_flag,ellipsoid_flag,line_flag,tri_flag,body_flag;
int peri_flag,electron_flag;
int ecp_flag;
int wavepacket_flag,sph_flag;
int molecule_flag,molindex_flag,molatom_flag;
@ -158,10 +157,14 @@ class Atom : protected Pointers {
int rho_flag,e_flag,cv_flag,vest_flag;
int dpd_flag,edpd_flag,tdpd_flag;
// USER-SPIN package
// SPIN package
int sp_flag;
// USER-EFF package
int ecp_flag;
// USER-SMD package
int smd_flag;
@ -286,7 +289,7 @@ class Atom : protected Pointers {
void data_dihedrals(int, char *, int *, tagint, int);
void data_impropers(int, char *, int *, tagint, int);
void data_bonus(int, char *, class AtomVec *, tagint);
void data_bodies(int, char *, class AtomVecBody *, tagint);
void data_bodies(int, char *, class AtomVec *, tagint);
void data_fix_compute_variable(int, int);
virtual void allocate_type_arrays();

50
src/atom_vec.cpp
View File

@ -38,11 +38,13 @@ enum{DOUBLE,INT,BIGINT};
AtomVec::AtomVec(LAMMPS *lmp) : Pointers(lmp)
{
nmax = 0;
molecular = 0;
bonds_allow = angles_allow = dihedrals_allow = impropers_allow = 0;
mass_type = dipole_type = 0;
forceclearflag = 0;
size_data_bonus = 0;
maxexchange = 0;
bonus_flag = 0;
kokkosable = 0;
@ -309,6 +311,8 @@ void AtomVec::copy(int i, int j, int delflag)
}
}
if (bonus_flag) copy_bonus(i,j,delflag);
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
@ -349,7 +353,7 @@ int AtomVec::pack_comm(int n, int *list, double *buf,
}
}
if (comm) {
if (ncomm) {
for (nn = 0; nn < ncomm; nn++) {
pdata = mcomm.pdata[nn];
datatype = mcomm.datatype[nn];
@ -403,6 +407,8 @@ int AtomVec::pack_comm(int n, int *list, double *buf,
}
}
if (bonus_flag) m += pack_comm_bonus(n,list,&buf[m]);
return m;
}
@ -522,6 +528,8 @@ int AtomVec::pack_comm_vel(int n, int *list, double *buf,
}
}
if (bonus_flag) m += pack_comm_bonus(n,list,&buf[m]);
return m;
}
@ -581,6 +589,8 @@ void AtomVec::unpack_comm(int n, int first, double *buf)
}
}
}
if (bonus_flag) unpack_comm_bonus(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
@ -642,6 +652,8 @@ void AtomVec::unpack_comm_vel(int n, int first, double *buf)
}
}
}
if (bonus_flag) unpack_comm_bonus(n,first,&buf[m]);
}
/* ---------------------------------------------------------------------- */
@ -874,6 +886,8 @@ int AtomVec::pack_border(int n, int *list, double *buf, int pbc_flag, int *pbc)
}
}
if (bonus_flag) m += pack_border_bonus(n,list,&buf[m]);
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
@ -1006,6 +1020,8 @@ int AtomVec::pack_border_vel(int n, int *list, double *buf,
}
}
if (bonus_flag) m += pack_border_bonus(n,list,&buf[m]);
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
@ -1074,6 +1090,8 @@ void AtomVec::unpack_border(int n, int first, double *buf)
}
}
if (bonus_flag) m += unpack_border_bonus(n,first,&buf[m]);
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->
@ -1144,6 +1162,8 @@ void AtomVec::unpack_border_vel(int n, int first, double *buf)
}
}
if (bonus_flag) m += unpack_border_bonus(n,first,&buf[m]);
if (atom->nextra_border)
for (int iextra = 0; iextra < atom->nextra_border; iextra++)
m += modify->fix[atom->extra_border[iextra]]->
@ -1232,6 +1252,8 @@ int AtomVec::pack_exchange(int i, double *buf)
}
}
if (bonus_flag) m += pack_exchange_bonus(i,&buf[m]);
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf[m]);
@ -1322,6 +1344,8 @@ int AtomVec::unpack_exchange(double *buf)
}
}
if (bonus_flag) m += unpack_exchange_bonus(nlocal,&buf[m]);
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
m += modify->fix[atom->extra_grow[iextra]]->
@ -1366,6 +1390,8 @@ int AtomVec::size_restart()
}
}
if (bonus_flag) n += size_restart_bonus();
if (atom->nextra_restart)
for (int iextra = 0; iextra < atom->nextra_restart; iextra++)
for (i = 0; i < nlocal; i++)
@ -1459,6 +1485,8 @@ int AtomVec::pack_restart(int i, double *buf)
}
}
if (bonus_flag) m += pack_restart_bonus(i,&buf[m]);
// if needed, restore values after packing
pack_restart_post(i);
@ -1558,6 +1586,8 @@ int AtomVec::unpack_restart(double *buf)
}
}
if (bonus_flag) m += unpack_restart_bonus(nlocal,&buf[m]);
// if needed, initialize other peratom values
unpack_restart_init(nlocal);
@ -1635,7 +1665,7 @@ void AtomVec::create_atom(int itype, double *coord)
}
}
// if needed, initialize other peratom values
// if needed, initialize non-zero peratom values
create_atom_post(nlocal);
@ -2295,6 +2325,8 @@ bigint AtomVec::memory_usage()
}
}
if (bonus_flag) bytes += memory_usage_bonus();
return bytes;
}
@ -2359,8 +2391,9 @@ void AtomVec::setup_fields()
// NOTE: check for others vars in atom_vec.cpp/h ??
// NOTE: need to set maxexchange, e.g for style hybrid?
if (ncomm == 0) comm_x_only = 1;
else comm_x_only = 0;
comm_x_only = 1;
if (ncomm) comm_x_only = 0;
if (bonus_flag && size_forward_bonus) comm_x_only = 0;
if (nreverse == 0) comm_f_only = 1;
else comm_f_only = 0;
@ -2371,6 +2404,7 @@ void AtomVec::setup_fields()
if (cols == 0) size_forward++;
else size_forward += cols;
}
if (bonus_flag) size_forward += size_forward_bonus;
size_reverse = 3;
for (n = 0; n < nreverse; n++) {
@ -2385,6 +2419,7 @@ void AtomVec::setup_fields()
if (cols == 0) size_border++;
else size_border += cols;
}
if (bonus_flag) size_border += size_border_bonus;
size_velocity = 3;
for (n = 0; n < ncomm_vel; n++) {
@ -2444,7 +2479,10 @@ int AtomVec::process_fields(char *list, const char *default_list, Method *method
for (i = 0; i < nperatom; i++)
if (strcmp(field,peratom[i].name) == 0) break;
if (i == nperatom) error->all(FLERR,"Atom_style unrecognized peratom field");
if (i == nperatom) {
printf("FIELD %s\n",field);
error->all(FLERR,"Atom_style unrecognized peratom field");
}
index[nfield++] = i;
// error if field is in default list or appears multiple times

41
src/atom_vec.h
View File

@ -36,11 +36,16 @@ class AtomVec : protected Pointers {
int size_velocity; // # of velocity based quantities
int size_data_atom; // number of values in Atom line
int size_data_vel; // number of values in Velocity line
int size_data_bonus; // number of values in Bonus line
int xcol_data; // column (1-N) where x is in Atom line
int maxexchange; // max size of exchanged atom
// only needs to be set if size > BUFEXTRA
int bonus_flag; // 1 if stores bonus data
int size_forward_bonus; // # in forward bonus comm
int size_border_bonus; // # in border bonus comm
int size_restart_bonus_one; // # in restart bonus comm
int size_data_bonus; // number of values in Bonus line
class Molecule **onemols; // list of molecules for style template
int nset; // # of molecules in list
@ -62,6 +67,7 @@ class AtomVec : protected Pointers {
AtomVec(class LAMMPS *);
virtual ~AtomVec();
void store_args(int, char **);
virtual void process_args(int, char **);
virtual void init();
@ -70,13 +76,18 @@ class AtomVec : protected Pointers {
void grow(int);
void copy(int, int, int);
void clear_bonus() {}
virtual void copy_bonus(int, int, int) {}
virtual void clear_bonus() {}
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
virtual int pack_comm_bonus(int, int *, double *) {}
virtual void unpack_comm_bonus(int, int, double *) {}
int pack_reverse(int, int, double *);
void unpack_reverse(int, int *, double *);
@ -85,16 +96,27 @@ class AtomVec : protected Pointers {
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
virtual int pack_border_bonus(int, int *, double *) {}
virtual int unpack_border_bonus(int, int, double *) {}
int pack_exchange(int, double *);
int unpack_exchange(double *);
virtual int pack_exchange_bonus(int, double *) {}
virtual int unpack_exchange_bonus(int, double *) {}
int size_restart();
virtual void pack_restart_pre(int) {}
int pack_restart(int, double *);
virtual void pack_restart_post(int) {}
int unpack_restart(double *);
virtual void pack_restart_pre(int) {}
virtual void pack_restart_post(int) {}
virtual void unpack_restart_init(int) {}
virtual int size_restart_bonus() {}
virtual int pack_restart_bonus(int, double *) {}
virtual int unpack_restart_bonus(int, double *) {}
void create_atom(int, double *);
virtual void create_atom_post(int) {}
@ -102,13 +124,15 @@ class AtomVec : protected Pointers {
virtual void data_atom_post(int) {}
void data_atom_bonus(int, char **) {}
void data_vel(int, char **);
void data_body(int, int, int, int *, double *) {}
void pack_data(double **);
void write_data(FILE *, int, double **);
virtual void pack_data_pre(int) {}
void pack_data(double **);
virtual void pack_data_post(int) {}
int pack_data_hybrid(int, double *) {return 0;}
void write_data(FILE *, int, double **);
void data_vel(int, char **);
void pack_vel(double **);
void write_vel(FILE *, int, double **);
@ -125,6 +149,7 @@ class AtomVec : protected Pointers {
void pack_property_atom(int, double *, int, int) {}
bigint memory_usage();
virtual bigint memory_usage_bonus() {}
protected:
int nmax; // local copy of atom->nmax

1179
src/atom_vec_body.cpp
View File

File diff suppressed because it is too large Load Diff

72
src/atom_vec_body.h
View File

@ -42,49 +42,26 @@ class AtomVecBody : public AtomVec {
AtomVecBody(class LAMMPS *);
~AtomVecBody();
void process_args(int, char **);
void grow(int);
void grow_reset();
void copy(int, int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, 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_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
int data_atom_hybrid(int, char **);
void data_vel(int, char **);
int data_vel_hybrid(int, char **);
void pack_data(double **);
int pack_data_hybrid(int, double *);
void write_data(FILE *, int, double **);
int write_data_hybrid(FILE *, double *);
void pack_vel(double **);
int pack_vel_hybrid(int, double *);
void write_vel(FILE *, int, double **);
int write_vel_hybrid(FILE *, double *);
bigint memory_usage();
// manipulate Bonus data structure for extra atom info
void copy_bonus(int, int, int);
void clear_bonus();
int pack_comm_bonus(int, int *, double *);
void unpack_comm_bonus(int, int, double *);
int pack_reverse_bonus(int, int, double *);
int pack_border_bonus(int, int *, double *);
int unpack_border_bonus(int, int, double *);
int pack_exchange_bonus(int, double *);
int unpack_exchange_bonus(int, double *);
int size_restart_bonus();
int pack_restart_bonus(int, double *);
int unpack_restart_bonus(int, double *);
void data_body(int, int, int, int *, double *);
bigint memory_usage_bonus();
void create_atom_post(int);
void data_atom_post(int);
void pack_data_pre(int);
void pack_data_post(int);
// methods used by other classes to query/set body info
@ -94,23 +71,16 @@ class AtomVecBody : public AtomVec {
int nlocal_bonus;
private:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f;
double *radius;
double *rmass;
double **angmom,**torque;
int *body;
int nghost_bonus,nmax_bonus;
int intdoubleratio; // sizeof(double) / sizeof(int)
int intdoubleratio; // sizeof(double) / sizeof(int)
int body_flag;
MyPoolChunk<int> *icp;
MyPoolChunk<double> *dcp;
void grow_bonus();
void copy_bonus(int, int);
void copy_bonus_all(int, int);
// check(int);
};
}

1188
src/atom_vec_ellipsoid.cpp
View File

File diff suppressed because it is too large Load Diff

69
src/atom_vec_ellipsoid.h
View File

@ -35,49 +35,26 @@ class AtomVecEllipsoid : public AtomVec {
AtomVecEllipsoid(class LAMMPS *);
~AtomVecEllipsoid();
void grow(int);
void grow_reset();
void copy(int, int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, 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_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
int data_atom_hybrid(int, char **);
void data_vel(int, char **);
int data_vel_hybrid(int, char **);
void pack_data(double **);
int pack_data_hybrid(int, double *);
void write_data(FILE *, int, double **);
int write_data_hybrid(FILE *, double *);
void pack_vel(double **);
int pack_vel_hybrid(int, double *);
void write_vel(FILE *, int, double **);
int write_vel_hybrid(FILE *, double *);
bigint memory_usage();
// manipulate Bonus data structure for extra atom info
void copy_bonus(int, int, int);
void clear_bonus();
int pack_comm_bonus(int, int *, double *);
void unpack_comm_bonus(int, int, double *);
int pack_reverse_bonus(int, int, double *);
int pack_border_bonus(int, int *, double *);
int unpack_border_bonus(int, int, double *);
int pack_exchange_bonus(int, double *);
int unpack_exchange_bonus(int, double *);
int size_restart_bonus();
int pack_restart_bonus(int, double *);
int unpack_restart_bonus(int, double *);
void data_atom_bonus(int, char **);
bigint memory_usage_bonus();
void create_atom_post(int);
void data_atom_post(int);
void pack_data_pre(int);
void pack_data_post(int);
// unique to AtomVecEllipsoid
@ -86,18 +63,12 @@ class AtomVecEllipsoid : public AtomVec {
int nlocal_bonus;
private:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f;
double *rmass;
double **angmom,**torque;
int *ellipsoid;
int nghost_bonus,nmax_bonus;
int ellipsoid_flag;
double rmass;
void grow_bonus();
void copy_bonus(int, int);
void copy_bonus_all(int, int);
};
}

1173
src/atom_vec_line.cpp
View File

File diff suppressed because it is too large Load Diff

70
src/atom_vec_line.h
View File

@ -35,49 +35,26 @@ class AtomVecLine : public AtomVec {
AtomVecLine(class LAMMPS *);
~AtomVecLine();
void init();
void grow(int);
void grow_reset();
void copy(int, int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, 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_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
int data_atom_hybrid(int, char **);
void data_vel(int, char **);
int data_vel_hybrid(int, char **);
void pack_data(double **);
int pack_data_hybrid(int, double *);
void write_data(FILE *, int, double **);
int write_data_hybrid(FILE *, double *);
void pack_vel(double **);
int pack_vel_hybrid(int, double *);
void write_vel(FILE *, int, double **);
int write_vel_hybrid(FILE *, double *);
bigint memory_usage();
// manipulate Bonus data structure for extra atom info
void copy_bonus(int, int, int);
void clear_bonus();
int pack_comm_bonus(int, int *, double *);
void unpack_comm_bonus(int, int, double *);
int pack_reverse_bonus(int, int, double *);
int pack_border_bonus(int, int *, double *);
int unpack_border_bonus(int, int, double *);
int pack_exchange_bonus(int, double *);
int unpack_exchange_bonus(int, double *);
int size_restart_bonus();
int pack_restart_bonus(int, double *);
int unpack_restart_bonus(int, double *);
void data_atom_bonus(int, char **);
bigint memory_usage_bonus();
void create_atom_post(int);
void data_atom_post(int);
void pack_data_pre(int);
void pack_data_post(int);
// unique to AtomVecLine
@ -86,19 +63,12 @@ class AtomVecLine : public AtomVec {
int nlocal_bonus;
private:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f;
tagint *molecule;
double *rmass,*radius;
double **omega,**torque;
int *line;
int nghost_bonus,nmax_bonus;
int line_flag;
double rmass;
void grow_bonus();
void copy_bonus(int, int);
void copy_bonus_all(int, int);
// void consistency_check(int, char *);
};

4
src/atom_vec_sphere.cpp
View File

@ -94,7 +94,7 @@ void AtomVecSphere::init()
}
/* ----------------------------------------------------------------------
initialize other atom quantities
initialize non-zero atom quantities
------------------------------------------------------------------------- */
void AtomVecSphere::create_atom_post(int ilocal)
@ -117,7 +117,7 @@ void AtomVecSphere::data_atom_post(int ilocal)
4.0*MY_PI/3.0 * radius*radius*radius * atom->rmass[ilocal];
if (atom->rmass[ilocal] <= 0.0)
error->one(FLERR,"Invalid mass in Atoms section of data file");
error->one(FLERR,"Invalid density in Atoms section of data file");
}
/* ----------------------------------------------------------------------

1537
src/atom_vec_tri.cpp
View File

File diff suppressed because it is too large Load Diff

70
src/atom_vec_tri.h
View File

@ -37,49 +37,26 @@ class AtomVecTri : public AtomVec {
AtomVecTri(class LAMMPS *);
~AtomVecTri();
void init();
void grow(int);
void grow_reset();
void copy(int, int, int);
int pack_comm(int, int *, double *, int, int *);
int pack_comm_vel(int, int *, double *, int, int *);
int pack_comm_hybrid(int, int *, double *);
void unpack_comm(int, int, double *);
void unpack_comm_vel(int, int, double *);
int unpack_comm_hybrid(int, int, double *);
int pack_reverse(int, int, double *);
int pack_reverse_hybrid(int, int, double *);
void unpack_reverse(int, 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_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
int data_atom_hybrid(int, char **);
void data_vel(int, char **);
int data_vel_hybrid(int, char **);
void pack_data(double **);
int pack_data_hybrid(int, double *);
void write_data(FILE *, int, double **);
int write_data_hybrid(FILE *, double *);
void pack_vel(double **);
int pack_vel_hybrid(int, double *);
void write_vel(FILE *, int, double **);
int write_vel_hybrid(FILE *, double *);
bigint memory_usage();
// manipulate Bonus data structure for extra atom info
void copy_bonus(int, int, int);
void clear_bonus();
int pack_comm_bonus(int, int *, double *);
void unpack_comm_bonus(int, int, double *);
int pack_reverse_bonus(int, int, double *);
int pack_border_bonus(int, int *, double *);
int unpack_border_bonus(int, int, double *);
int pack_exchange_bonus(int, double *);
int unpack_exchange_bonus(int, double *);
int size_restart_bonus();
int pack_restart_bonus(int, double *);
int unpack_restart_bonus(int, double *);
void data_atom_bonus(int, char **);
bigint memory_usage_bonus();
void create_atom_post(int);
void data_atom_post(int);
void pack_data_pre(int);
void pack_data_post(int);
// unique to AtomVecTri
@ -88,19 +65,12 @@ class AtomVecTri : public AtomVec {
int nlocal_bonus;
private:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f;
tagint *molecule;
double *rmass,*radius;
double **omega,**angmom,**torque;
int *tri;
int nghost_bonus,nmax_bonus;
int tri_flag;
double rmass;
void grow_bonus();
void copy_bonus(int, int);
void copy_bonus_all(int, int);
};
}

6
src/read_data.cpp
View File

@ -568,7 +568,7 @@ void ReadData::command(int narg, char **arg)
if (!avec_body)
error->all(FLERR,"Invalid data file section: Bodies");
if (atomflag == 0) error->all(FLERR,"Must read Atoms before Bodies");
bodies(firstpass);
bodies(firstpass,(AtomVec *) avec_body);
} else if (strcmp(keyword,"Masses") == 0) {
if (firstpass) mass();
@ -1686,7 +1686,7 @@ void ReadData::bonus(bigint nbonus, AtomVec *ptr, const char *type)
if not firstpass, just read past data, but no processing of data
------------------------------------------------------------------------- */
void ReadData::bodies(int firstpass)
void ReadData::bodies(int firstpass, AtomVec *ptr)
{
int m,nchunk,nline,nmax,ninteger,ndouble,nword,ncount,onebody,tmp,rv;
char *eof;
@ -1770,7 +1770,7 @@ void ReadData::bodies(int firstpass)
MPI_Bcast(&m,1,MPI_INT,0,world);
MPI_Bcast(buffer,m,MPI_CHAR,0,world);
if (firstpass) atom->data_bodies(nchunk,buffer,avec_body,id_offset);
if (firstpass) atom->data_bodies(nchunk,buffer,ptr,id_offset);
nread += nchunk;
}

2
src/read_data.h
View File

@ -97,7 +97,7 @@ class ReadData : protected Pointers {
void impropers(int);
void bonus(bigint, class AtomVec *, const char *);
void bodies(int);
void bodies(int, class AtomVec *);
void mass();
void paircoeffs();