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

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

This commit is contained in:
sjplimp 2013-02-08 16:44:04 +00:00
parent 6bdbde76da
commit ce7dede594
66 changed files with 176 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/DIPOLE/atom_vec_dipole.cpp
View File

@ -113,7 +113,7 @@ void AtomVecDipole::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/GRANULAR/fix_wall_gran.cpp
View File

@ -697,7 +697,7 @@ void FixWallGran::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixWallGran::copy_arrays(int i, int j)
void FixWallGran::copy_arrays(int i, int j, int delflag)
{
shear[j][0] = shear[i][0];
shear[j][1] = shear[i][1];

2
src/GRANULAR/fix_wall_gran.h
View File

@ -36,7 +36,7 @@ class FixWallGran : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
void set_arrays(int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/MC/fix_bond_create.cpp
View File

@ -572,7 +572,7 @@ void FixBondCreate::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixBondCreate::copy_arrays(int i, int j)
void FixBondCreate::copy_arrays(int i, int j, int delflag)
{
bondcount[j] = bondcount[i];
}

2
src/MC/fix_bond_create.h
View File

@ -40,7 +40,7 @@ class FixBondCreate : public Fix {
int pack_reverse_comm(int, int, double *);
void unpack_reverse_comm(int, int *, double *);
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
double compute_vector(int);

2
src/MOLECULE/atom_vec_angle.cpp
View File

@ -153,7 +153,7 @@ void AtomVecAngle::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/MOLECULE/atom_vec_bond.cpp
View File

@ -132,7 +132,7 @@ void AtomVecBond::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/MOLECULE/atom_vec_full.cpp
View File

@ -212,7 +212,7 @@ void AtomVecFull::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/MOLECULE/atom_vec_molecular.cpp
View File

@ -210,7 +210,7 @@ void AtomVecMolecular::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/PERI/atom_vec_peri.cpp
View File

@ -121,7 +121,7 @@ void AtomVecPeri::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/PERI/fix_peri_neigh.cpp
View File

@ -367,7 +367,7 @@ void FixPeriNeigh::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixPeriNeigh::copy_arrays(int i, int j)
void FixPeriNeigh::copy_arrays(int i, int j, int delflag)
{
npartner[j] = npartner[i];
for (int m = 0; m < npartner[j]; m++) {

2
src/PERI/fix_peri_neigh.h
View File

@ -42,7 +42,7 @@ class FixPeriNeigh : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
void write_restart(FILE *);

2
src/POEMS/fix_poems.cpp
View File

@ -1528,7 +1528,7 @@ void FixPOEMS::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixPOEMS::copy_arrays(int i, int j)
void FixPOEMS::copy_arrays(int i, int j, int delflag)
{
natom2body[j] = natom2body[i];
for (int k = 0; k < natom2body[j]; k++) atom2body[j][k] = atom2body[i][k];

2
src/POEMS/fix_poems.h
View File

@ -39,7 +39,7 @@ class FixPOEMS : public Fix {
void final_integrate_respa(int, int);
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
double memory_usage();

2
src/REPLICA/fix_event.cpp
View File

@ -193,7 +193,7 @@ void FixEvent::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixEvent::copy_arrays(int i, int j)
void FixEvent::copy_arrays(int i, int j, int delflag)
{
xevent[j][0] = xevent[i][0];
xevent[j][1] = xevent[i][1];

2
src/REPLICA/fix_event.h
View File

@ -26,7 +26,7 @@ class FixEvent : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
virtual void write_restart(FILE *);

4
src/RIGID/fix_rigid.cpp
View File

@ -2165,7 +2165,7 @@ double FixRigid::memory_usage()
int nmax = atom->nmax;
double bytes = nmax * sizeof(int);
bytes += nmax*3 * sizeof(double);
bytes += maxvatom*6 * sizeof(double);
bytes += maxvatom*6 * sizeof(double); // vatom
if (extended) {
bytes += nmax * sizeof(int);
if (orientflag) bytes = nmax*orientflag * sizeof(double);
@ -2193,7 +2193,7 @@ void FixRigid::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixRigid::copy_arrays(int i, int j)
void FixRigid::copy_arrays(int i, int j, int delflag)
{
body[j] = body[i];
displace[j][0] = displace[i][0];

4
src/RIGID/fix_rigid.h
View File

@ -1,4 +1,4 @@
/* -*- c++ -*- ----------------------------------------------------------
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
@ -41,7 +41,7 @@ class FixRigid : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
void set_arrays(int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/USER-ATC/fix_atc.cpp
View File

@ -359,7 +359,7 @@ void FixATC::grow_arrays(int nmax)
atcTransfer_->grow_arrays(nmax);
}
void FixATC::copy_arrays(int i, int j)
void FixATC::copy_arrays(int i, int j, int delflag)
{
atcTransfer_->copy_arrays(i,j);
}

2
src/USER-ATC/fix_atc.h
View File

@ -60,7 +60,7 @@ namespace LAMMPS_NS {
void min_pre_exchange();
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
int pack_comm(int , int *, double *, int, int *);

2
src/USER-AWPMD/atom_vec_wavepacket.cpp
View File

@ -143,7 +143,7 @@ void AtomVecWavepacket::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/USER-CUDA/atom_vec_angle_cuda.cpp
View File

@ -370,7 +370,7 @@ int AtomVecAngleCuda::pack_exchange(int dim, double *buf)
int dm= modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf_p[m]);
m+=dm;
nextra+=dm;
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i);
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i,delflag);
if(m>*maxsend) {grow_send(m,buf_pointer,1); buf_p=*buf_pointer;}
}

2
src/USER-CUDA/atom_vec_atomic_cuda.cpp
View File

@ -330,7 +330,7 @@ int AtomVecAtomicCuda::pack_exchange(int dim, double *buf)
int dm = modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&((*buf_pointer)[m]));
m+=dm;
nextra+=dm;
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i);
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i,delflag);
if(m>*maxsend) grow_send(m,buf_pointer,1);
}
(*buf_pointer)[j+1] = nextra;

2
src/USER-CUDA/atom_vec_charge_cuda.cpp
View File

@ -336,7 +336,7 @@ int AtomVecChargeCuda::pack_exchange(int dim, double *buf)
int dm = modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&((*buf_pointer)[m]));
m+=dm;
nextra+=dm;
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i);
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i,delflag);
if(m>*maxsend) grow_send(m,buf_pointer,1);
}
(*buf_pointer)[j+1] = nextra;

2
src/USER-CUDA/atom_vec_full_cuda.cpp
View File

@ -393,7 +393,7 @@ int AtomVecFullCuda::pack_exchange(int dim, double *buf)
int dm= modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf_p[m]);
m+=dm;
nextra+=dm;
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i);
if(i<nlocal)modify->fix[atom->extra_grow[iextra]]->copy_arrays(copylist[j],i,delflag);
if(m>*maxsend) {grow_send(m,buf_pointer,1); buf_p=*buf_pointer;}
}

2
src/USER-CUDA/fix_shake_cuda.cpp
View File

@ -2581,7 +2581,7 @@ void FixShakeCuda::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixShakeCuda::copy_arrays(int i, int j)
void FixShakeCuda::copy_arrays(int i, int j, int delflag)
{
int flag = shake_flag[j] = shake_flag[i];

2
src/USER-CUDA/fix_shake_cuda.h
View File

@ -39,7 +39,7 @@ class FixShakeCuda : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
void set_arrays(int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

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

@ -123,7 +123,7 @@ void AtomVecElectron::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/USER-REAXC/fix_qeq_reax.cpp
View File

@ -745,7 +745,7 @@ void FixQEqReax::grow_arrays(int nmax)
copy values within fictitious charge arrays
------------------------------------------------------------------------- */
void FixQEqReax::copy_arrays(int i, int j)
void FixQEqReax::copy_arrays(int i, int j, int delflag)
{
for (int m = 0; m < nprev; m++) {
s_hist[j][m] = s_hist[i][m];

2
src/USER-REAXC/fix_qeq_reax.h
View File

@ -124,7 +124,7 @@ class FixQEqReax : public Fix {
void unpack_reverse_comm(int, int *, double *);
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/USER-REAXC/fix_reax_c.cpp
View File

@ -105,7 +105,7 @@ void FixReaxC::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixReaxC::copy_arrays(int i, int j)
void FixReaxC::copy_arrays(int i, int j, int delflag)
{
num_bonds[j] = num_bonds[i];
num_hbonds[j] = num_hbonds[i];

2
src/USER-REAXC/fix_reax_c.h
View File

@ -44,7 +44,7 @@ class FixReaxC : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
int pack_comm(int, int *, double *, int, int *);

2
src/USER-SPH/atom_vec_meso.cpp
View File

@ -129,7 +129,7 @@ void AtomVecMeso::copy(int i, int j, int delflag) {
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i, j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i, j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/atom_vec_atomic.cpp
View File

@ -99,7 +99,7 @@ void AtomVecAtomic::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/atom_vec_body.cpp
View File

@ -226,7 +226,7 @@ void AtomVecBody::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ----------------------------------------------------------------------

2
src/atom_vec_charge.cpp
View File

@ -106,7 +106,7 @@ void AtomVecCharge::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

3
src/atom_vec_ellipsoid.cpp
View File

@ -160,7 +160,7 @@ void AtomVecEllipsoid::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ----------------------------------------------------------------------
@ -801,6 +801,7 @@ void AtomVecEllipsoid::unpack_border_vel(int n, int first, double *buf)
ellipsoid[i] = static_cast<int> (buf[m++]);
if (ellipsoid[i] == 0) ellipsoid[i] = -1;
else {
j = nlocal_bonus + nghost_bonus;
if (j == nmax_bonus) grow_bonus();
shape = bonus[j].shape;
quat = bonus[j].quat;

2
src/atom_vec_hybrid.cpp
View File

@ -187,7 +187,7 @@ void AtomVecHybrid::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/atom_vec_line.cpp
View File

@ -170,7 +170,7 @@ void AtomVecLine::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ----------------------------------------------------------------------

2
src/atom_vec_sphere.cpp
View File

@ -145,7 +145,7 @@ void AtomVecSphere::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ---------------------------------------------------------------------- */

2
src/atom_vec_tri.cpp
View File

@ -172,7 +172,7 @@ void AtomVecTri::copy(int i, int j, int delflag)
if (atom->nextra_grow)
for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j);
modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
}
/* ----------------------------------------------------------------------

104
src/comm.cpp
View File

@ -1160,6 +1160,7 @@ void Comm::reverse_comm_pair(Pair *pair)
/* ----------------------------------------------------------------------
forward communication invoked by a Fix
n = constant number of datums per atom
------------------------------------------------------------------------- */
void Comm::forward_comm_fix(Fix *fix)
@ -1197,6 +1198,7 @@ void Comm::forward_comm_fix(Fix *fix)
/* ----------------------------------------------------------------------
reverse communication invoked by a Fix
n = constant number of datums per atom
------------------------------------------------------------------------- */
void Comm::reverse_comm_fix(Fix *fix)
@ -1231,6 +1233,81 @@ void Comm::reverse_comm_fix(Fix *fix)
}
}
/* ----------------------------------------------------------------------
forward communication invoked by a Fix
n = total datums for all atoms, allows for variable number/atom
------------------------------------------------------------------------- */
void Comm::forward_comm_variable_fix(Fix *fix)
{
int iswap,n;
double *buf;
MPI_Request request;
MPI_Status status;
for (iswap = 0; iswap < nswap; iswap++) {
// pack buffer
n = fix->pack_comm(sendnum[iswap],sendlist[iswap],
buf_send,pbc_flag[iswap],pbc[iswap]);
// exchange with another proc
// if self, set recv buffer to send buffer
if (sendproc[iswap] != me) {
if (recvnum[iswap])
MPI_Irecv(buf_recv,maxrecv,MPI_DOUBLE,recvproc[iswap],0,
world,&request);
if (sendnum[iswap])
MPI_Send(buf_send,n,MPI_DOUBLE,sendproc[iswap],0,world);
if (recvnum[iswap]) MPI_Wait(&request,&status);
buf = buf_recv;
} else buf = buf_send;
// unpack buffer
fix->unpack_comm(recvnum[iswap],firstrecv[iswap],buf);
}
}
/* ----------------------------------------------------------------------
reverse communication invoked by a Fix
n = total datums for all atoms, allows for variable number/atom
------------------------------------------------------------------------- */
void Comm::reverse_comm_variable_fix(Fix *fix)
{
int iswap,n;
double *buf;
MPI_Request request;
MPI_Status status;
for (iswap = nswap-1; iswap >= 0; iswap--) {
// pack buffer
n = fix->pack_reverse_comm(recvnum[iswap],firstrecv[iswap],buf_send);
// exchange with another proc
// if self, set recv buffer to send buffer
if (sendproc[iswap] != me) {
if (sendnum[iswap])
MPI_Irecv(buf_recv,maxrecv,MPI_DOUBLE,sendproc[iswap],0,
world,&request);
if (recvnum[iswap])
MPI_Send(buf_send,n,MPI_DOUBLE,recvproc[iswap],0,world);
if (sendnum[iswap]) MPI_Wait(&request,&status);
buf = buf_recv;
} else buf = buf_send;
// unpack buffer
fix->unpack_reverse_comm(sendnum[iswap],sendlist[iswap],buf);
}
}
/* ----------------------------------------------------------------------
forward communication invoked by a Compute
------------------------------------------------------------------------- */
@ -1377,6 +1454,33 @@ void Comm::reverse_comm_dump(Dump *dump)
}
}
/* ----------------------------------------------------------------------
reverse communication invoked by a Dump
------------------------------------------------------------------------- */
void Comm::ring(int n, int nmax, char *buf, char *bufcopy, int messtag,
void (*callback)(int, char *))
{
MPI_Request request;
MPI_Status status;
int next = me + 1;
int prev = me - 1;
if (next == nprocs) next = 0;
if (prev < 0) prev = nprocs - 1;
for (int loop = 0; loop < nprocs; loop++) {
if (me != next) {
MPI_Irecv(bufcopy,nmax,MPI_CHAR,prev,messtag,world,&request);
MPI_Send(buf,n,MPI_CHAR,next,messtag,world);
MPI_Wait(&request,&status);
MPI_Get_count(&status,MPI_CHAR,&n);
memcpy(buf,bufcopy,n);
callback(n,buf);
}
}
}
/* ----------------------------------------------------------------------
realloc the size of the send buffer as needed with BUFFACTOR & BUFEXTRA
if flag = 1, realloc

6
src/comm.h
View File

@ -53,10 +53,14 @@ class Comm : protected Pointers {
virtual void reverse_comm_pair(class Pair *); // reverse comm from a Pair
virtual void forward_comm_fix(class Fix *); // forward comm from a Fix
virtual void reverse_comm_fix(class Fix *); // reverse comm from a Fix
virtual void forward_comm_variable_fix(class Fix *); // variable-size variant
virtual void reverse_comm_variable_fix(class Fix *); // variable-size variant
virtual void forward_comm_compute(class Compute *); // forward from a Compute
virtual void reverse_comm_compute(class Compute *); // reverse from a Compute
virtual void forward_comm_dump(class Dump *); // forward comm from a Dump
virtual void reverse_comm_dump(class Dump *); // reverse comm from a Dump
void ring(int, int, char *, char *, int,
void (*)(int, char *)); // ring communication
virtual void set(int, char **); // set communication style
void set_processors(int, char **); // set 3d processor grid attributes
@ -112,7 +116,7 @@ class Comm : protected Pointers {
int updown(int, int, int, double, int, double *);
// compare cutoff to procs
virtual void grow_send(int,int); // reallocate send buffer
virtual void grow_send(int, int); // reallocate send buffer
virtual void grow_recv(int); // free/allocate recv buffer
virtual void grow_list(int, int); // reallocate one sendlist
virtual void grow_swap(int); // grow swap and multi arrays

2
src/fix.h
View File

@ -105,7 +105,7 @@ class Fix : protected Pointers {
virtual void restart(char *) {}
virtual void grow_arrays(int) {}
virtual void copy_arrays(int, int) {}
virtual void copy_arrays(int, int, int) {}
virtual void set_arrays(int) {}
virtual int pack_exchange(int, double *) {return 0;}
virtual int unpack_exchange(int, double *) {return 0;}

2
src/fix_ave_atom.cpp
View File

@ -407,7 +407,7 @@ void FixAveAtom::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixAveAtom::copy_arrays(int i, int j)
void FixAveAtom::copy_arrays(int i, int j, int delflag)
{
for (int m = 0; m < nvalues; m++)
array[j][m] = array[i][m];

2
src/fix_ave_atom.h
View File

@ -36,7 +36,7 @@ class FixAveAtom : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
void reset_timestep(bigint);

2
src/fix_external.cpp
View File

@ -160,7 +160,7 @@ void FixExternal::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixExternal::copy_arrays(int i, int j)
void FixExternal::copy_arrays(int i, int j, int delflag)
{
fexternal[j][0] = fexternal[i][0];
fexternal[j][1] = fexternal[i][1];

2
src/fix_external.h
View File

@ -37,7 +37,7 @@ class FixExternal : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/fix_minimize.cpp
View File

@ -187,7 +187,7 @@ void FixMinimize::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixMinimize::copy_arrays(int i, int j)
void FixMinimize::copy_arrays(int i, int j, int delflag)
{
int m,iper,nper,ni,nj;

2
src/fix_minimize.h
View File

@ -35,7 +35,7 @@ class FixMinimize : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/fix_move.cpp
View File

@ -856,7 +856,7 @@ void FixMove::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixMove::copy_arrays(int i, int j)
void FixMove::copy_arrays(int i, int j, int delflag)
{
xoriginal[j][0] = xoriginal[i][0];
xoriginal[j][1] = xoriginal[i][1];

2
src/fix_move.h
View File

@ -40,7 +40,7 @@ class FixMove : public Fix {
void write_restart(FILE *);
void restart(char *);
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
void set_arrays(int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/fix_read_restart.cpp
View File

@ -96,7 +96,7 @@ void FixReadRestart::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixReadRestart::copy_arrays(int i, int j)
void FixReadRestart::copy_arrays(int i, int j, int delflag)
{
count[j] = count[i];
for (int m = 0; m < count[i]; m++) extra[j][m] = extra[i][m];

2
src/fix_read_restart.h
View File

@ -35,7 +35,7 @@ class FixReadRestart : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/fix_respa.cpp
View File

@ -80,7 +80,7 @@ void FixRespa::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixRespa::copy_arrays(int i, int j)
void FixRespa::copy_arrays(int i, int j, int delflag)
{
for (int k = 0; k < nlevels; k++) {
f_level[j][k][0] = f_level[i][k][0];

2
src/fix_respa.h
View File

@ -36,7 +36,7 @@ class FixRespa : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/fix_shake.cpp
View File

@ -2249,7 +2249,7 @@ void FixShake::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixShake::copy_arrays(int i, int j)
void FixShake::copy_arrays(int i, int j, int delflag)
{
int flag = shake_flag[j] = shake_flag[i];
if (flag == 1) {

2
src/fix_shake.h
View File

@ -37,7 +37,7 @@ class FixShake : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
void set_arrays(int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/fix_shear_history.cpp
View File

@ -228,7 +228,7 @@ void FixShearHistory::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixShearHistory::copy_arrays(int i, int j)
void FixShearHistory::copy_arrays(int i, int j, int delflag)
{
npartner[j] = npartner[i];
for (int m = 0; m < npartner[j]; m++) {

2
src/fix_shear_history.h
View File

@ -41,7 +41,7 @@ class FixShearHistory : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
void set_arrays(int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);

2
src/fix_spring_self.cpp
View File

@ -222,7 +222,7 @@ void FixSpringSelf::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixSpringSelf::copy_arrays(int i, int j)
void FixSpringSelf::copy_arrays(int i, int j, int delflag)
{
xoriginal[j][0] = xoriginal[i][0];
xoriginal[j][1] = xoriginal[i][1];

2
src/fix_spring_self.h
View File

@ -39,7 +39,7 @@ class FixSpringSelf : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
int pack_restart(int, double *);

2
src/fix_store_state.cpp
View File

@ -481,7 +481,7 @@ void FixStoreState::grow_arrays(int nmax)
copy values within local atom-based array
------------------------------------------------------------------------- */
void FixStoreState::copy_arrays(int i, int j)
void FixStoreState::copy_arrays(int i, int j, int delflag)
{
for (int m = 0; m < nvalues; m++) values[j][m] = values[i][m];
}

2
src/fix_store_state.h
View File

@ -35,7 +35,7 @@ class FixStoreState : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
int pack_restart(int, double *);

2
src/fix_tmd.cpp
View File

@ -338,7 +338,7 @@ void FixTMD::grow_arrays(int nmax)
copy values within local atom-based arrays
------------------------------------------------------------------------- */
void FixTMD::copy_arrays(int i, int j)
void FixTMD::copy_arrays(int i, int j, int delflag)
{
xf[j][0] = xf[i][0];
xf[j][1] = xf[i][1];

2
src/fix_tmd.h
View File

@ -36,7 +36,7 @@ class FixTMD : public Fix {
double memory_usage();
void grow_arrays(int);
void copy_arrays(int, int);
void copy_arrays(int, int, int);
int pack_exchange(int, double *);
int unpack_exchange(int, double *);
void reset_dt();