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

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

Browse Source
This commit is contained in:
sjplimp
2011-01-11 00:41:00 +00:00
parent 4bc2d6f332
commit 82ec94916d
79 changed files with 458 additions and 315 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/CLASS2/dihedral_class2.cpp
View File

@ -19,6 +19,7 @@
#include "string.h"
#include "stdlib.h"
#include "dihedral_class2.h"
#include "lmptype.h"
#include "atom.h"
#include "neighbor.h"
#include "update.h"
@ -209,9 +210,9 @@ void DihedralClass2::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Dihedral problem: %d %d %d %d %d %d",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Dihedral problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",

9
src/CLASS2/improper_class2.cpp
View File

@ -19,6 +19,7 @@
#include "string.h"
#include "stdlib.h"
#include "improper_class2.h"
#include "lmptype.h"
#include "atom.h"
#include "neighbor.h"
#include "update.h"
@ -156,11 +157,13 @@ void ImproperClass2::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Improper problem: %d %d %d %d %d %d",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Improper problem: %%d %s %%d %%d %%d %%d",
BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",
me,x[i1][0],x[i1][1],x[i1][2]);
fprintf(screen," 2nd atom: %d %g %g %g\n",

9
src/GPU/pair_cg_cmm_coul_long_gpu.cpp
View File

@ -19,6 +19,7 @@
#include "stdio.h"
#include "stdlib.h"
#include "pair_cg_cmm_coul_long_gpu.h"
#include "lmptype.h"
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
@ -94,6 +95,10 @@ PairCGCMMCoulLongGPU::~PairCGCMMCoulLongGPU()
void PairCGCMMCoulLongGPU::compute(int eflag, int vflag)
{
if (update->ntimestep > MAXSMALLINT)
error->all("Timestep too big for GPU pair style");
int ntimestep = update->ntimestep;
if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = 0;
@ -104,7 +109,7 @@ void PairCGCMMCoulLongGPU::compute(int eflag, int vflag)
if (gpu_mode == GPU_NEIGH) {
inum = atom->nlocal;
gpulist = cmml_gpu_compute_n(update->ntimestep, neighbor->ago, inum, nall,
gpulist = cmml_gpu_compute_n(ntimestep, neighbor->ago, inum, nall,
atom->x, atom->type, domain->sublo,
domain->subhi, atom->tag, atom->nspecial,
atom->special, eflag, vflag, eflag_atom,
@ -112,7 +117,7 @@ void PairCGCMMCoulLongGPU::compute(int eflag, int vflag)
atom->q);
} else {
inum = list->inum;
cmml_gpu_compute(update->ntimestep, neighbor->ago, inum, nall, atom->x,
cmml_gpu_compute(ntimestep, neighbor->ago, inum, nall, atom->x,
atom->type, list->ilist, list->numneigh, list->firstneigh,
eflag, vflag, eflag_atom, vflag_atom, host_start, cpu_time,
success, atom->q);

9
src/GPU/pair_cg_cmm_gpu.cpp
View File

@ -19,6 +19,7 @@
#include "stdio.h"
#include "stdlib.h"
#include "pair_cg_cmm_gpu.h"
#include "lmptype.h"
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
@ -83,6 +84,10 @@ PairCGCMMGPU::~PairCGCMMGPU()
void PairCGCMMGPU::compute(int eflag, int vflag)
{
if (update->ntimestep > MAXSMALLINT)
error->all("Timestep too big for GPU pair style");
int ntimestep = update->ntimestep;
if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = 0;
@ -93,14 +98,14 @@ void PairCGCMMGPU::compute(int eflag, int vflag)
if (gpu_mode == GPU_NEIGH) {
inum = atom->nlocal;
gpulist = cmm_gpu_compute_n(update->ntimestep, neighbor->ago, inum, nall,
gpulist = cmm_gpu_compute_n(ntimestep, neighbor->ago, inum, nall,
atom->x, atom->type, domain->sublo,
domain->subhi, atom->tag, atom->nspecial,
atom->special, eflag, vflag, eflag_atom,
vflag_atom, host_start, cpu_time, success);
} else {
inum = list->inum;
cmm_gpu_compute(update->ntimestep, neighbor->ago, inum, nall, atom->x,
cmm_gpu_compute(ntimestep, neighbor->ago, inum, nall, atom->x,
atom->type, list->ilist, list->numneigh, list->firstneigh,
eflag, vflag, eflag_atom, vflag_atom, host_start, cpu_time,
success);

9
src/GPU/pair_gayberne_gpu.cpp
View File

@ -19,6 +19,7 @@
#include "stdio.h"
#include "stdlib.h"
#include "pair_gayberne_gpu.h"
#include "lmptype.h"
#include "math_extra.h"
#include "atom.h"
#include "atom_vec.h"
@ -88,6 +89,10 @@ PairGayBerneGPU::~PairGayBerneGPU()
void PairGayBerneGPU::compute(int eflag, int vflag)
{
if (update->ntimestep > MAXSMALLINT)
error->all("Timestep too big for GPU pair style");
int ntimestep = update->ntimestep;
if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = 0;
@ -98,13 +103,13 @@ void PairGayBerneGPU::compute(int eflag, int vflag)
if (gpu_mode == GPU_NEIGH) {
inum = atom->nlocal;
gpulist = gb_gpu_compute_n(update->ntimestep, neighbor->ago, inum, nall,
gpulist = gb_gpu_compute_n(ntimestep, neighbor->ago, inum, nall,
atom->x, atom->type, domain->sublo, domain->subhi,
eflag, vflag, eflag_atom, vflag_atom, host_start,
cpu_time, success, atom->quat);
} else {
inum = list->inum;
olist = gb_gpu_compute(update->ntimestep, neighbor->ago, inum, nall, atom->x,
olist = gb_gpu_compute(ntimestep, neighbor->ago, inum, nall, atom->x,
atom->type, list->ilist, list->numneigh,
list->firstneigh, eflag, vflag, eflag_atom,
vflag_atom, host_start, cpu_time, success,

9
src/GPU/pair_lj96_cut_gpu.cpp
View File

@ -19,6 +19,7 @@
#include "stdio.h"
#include "stdlib.h"
#include "pair_lj96_cut_gpu.h"
#include "lmptype.h"
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
@ -82,6 +83,10 @@ PairLJ96CutGPU::~PairLJ96CutGPU()
void PairLJ96CutGPU::compute(int eflag, int vflag)
{
if (update->ntimestep > MAXSMALLINT)
error->all("Timestep too big for GPU pair style");
int ntimestep = update->ntimestep;
if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = 0;
@ -92,14 +97,14 @@ void PairLJ96CutGPU::compute(int eflag, int vflag)
if (gpu_mode == GPU_NEIGH) {
inum = atom->nlocal;
gpulist = lj96_gpu_compute_n(update->ntimestep, neighbor->ago, inum, nall,
gpulist = lj96_gpu_compute_n(ntimestep, neighbor->ago, inum, nall,
atom->x, atom->type, domain->sublo,
domain->subhi, atom->tag, atom->nspecial,
atom->special, eflag, vflag, eflag_atom,
vflag_atom, host_start, cpu_time, success);
} else {
inum = list->inum;
lj96_gpu_compute(update->ntimestep, neighbor->ago, inum, nall, atom->x,
lj96_gpu_compute(ntimestep, neighbor->ago, inum, nall, atom->x,
atom->type, list->ilist, list->numneigh, list->firstneigh,
eflag, vflag, eflag_atom, vflag_atom, host_start, cpu_time,
success);

9
src/GPU/pair_lj_cut_coul_cut_gpu.cpp
View File

@ -19,6 +19,7 @@
#include "stdio.h"
#include "stdlib.h"
#include "pair_lj_cut_coul_cut_gpu.h"
#include "lmptype.h"
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
@ -84,6 +85,10 @@ PairLJCutCoulCutGPU::~PairLJCutCoulCutGPU()
void PairLJCutCoulCutGPU::compute(int eflag, int vflag)
{
if (update->ntimestep > MAXSMALLINT)
error->all("Timestep too big for GPU pair style");
int ntimestep = update->ntimestep;
if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = 0;
@ -94,7 +99,7 @@ void PairLJCutCoulCutGPU::compute(int eflag, int vflag)
if (gpu_mode == GPU_NEIGH) {
inum = atom->nlocal;
gpulist = ljc_gpu_compute_n(update->ntimestep, neighbor->ago, inum, nall,
gpulist = ljc_gpu_compute_n(ntimestep, neighbor->ago, inum, nall,
atom->x, atom->type, domain->sublo,
domain->subhi, atom->tag, atom->nspecial,
atom->special, eflag, vflag, eflag_atom,
@ -102,7 +107,7 @@ void PairLJCutCoulCutGPU::compute(int eflag, int vflag)
atom->q);
} else {
inum = list->inum;
ljc_gpu_compute(update->ntimestep, neighbor->ago, inum, nall, atom->x,
ljc_gpu_compute(ntimestep, neighbor->ago, inum, nall, atom->x,
atom->type, list->ilist, list->numneigh, list->firstneigh,
eflag, vflag, eflag_atom, vflag_atom, host_start, cpu_time,
success, atom->q);

9
src/GPU/pair_lj_cut_coul_long_gpu.cpp
View File

@ -19,6 +19,7 @@
#include "stdio.h"
#include "stdlib.h"
#include "pair_lj_cut_coul_long_gpu.h"
#include "lmptype.h"
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
@ -94,6 +95,10 @@ PairLJCutCoulLongGPU::~PairLJCutCoulLongGPU()
void PairLJCutCoulLongGPU::compute(int eflag, int vflag)
{
if (update->ntimestep > MAXSMALLINT)
error->all("Timestep too big for GPU pair style");
int ntimestep = update->ntimestep;
if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = 0;
@ -104,7 +109,7 @@ void PairLJCutCoulLongGPU::compute(int eflag, int vflag)
if (gpu_mode == GPU_NEIGH) {
inum = atom->nlocal;
gpulist = ljcl_gpu_compute_n(update->ntimestep, neighbor->ago, inum, nall,
gpulist = ljcl_gpu_compute_n(ntimestep, neighbor->ago, inum, nall,
atom->x, atom->type, domain->sublo,
domain->subhi, atom->tag, atom->nspecial,
atom->special, eflag, vflag, eflag_atom,
@ -112,7 +117,7 @@ void PairLJCutCoulLongGPU::compute(int eflag, int vflag)
atom->q);
} else {
inum = list->inum;
ljcl_gpu_compute(update->ntimestep, neighbor->ago, inum, nall, atom->x,
ljcl_gpu_compute(ntimestep, neighbor->ago, inum, nall, atom->x,
atom->type, list->ilist, list->numneigh, list->firstneigh,
eflag, vflag, eflag_atom, vflag_atom, host_start, cpu_time,
success, atom->q);

9
src/GPU/pair_lj_cut_gpu.cpp
View File

@ -19,6 +19,7 @@
#include "stdio.h"
#include "stdlib.h"
#include "pair_lj_cut_gpu.h"
#include "lmptype.h"
#include "atom.h"
#include "atom_vec.h"
#include "comm.h"
@ -82,6 +83,10 @@ PairLJCutGPU::~PairLJCutGPU()
void PairLJCutGPU::compute(int eflag, int vflag)
{
if (update->ntimestep > MAXSMALLINT)
error->all("Timestep too big for GPU pair style");
int ntimestep = update->ntimestep;
if (eflag || vflag) ev_setup(eflag,vflag);
else evflag = vflag_fdotr = 0;
@ -92,14 +97,14 @@ void PairLJCutGPU::compute(int eflag, int vflag)
if (gpu_mode == GPU_NEIGH) {
inum = atom->nlocal;
gpulist = ljl_gpu_compute_n(update->ntimestep, neighbor->ago, inum, nall,
gpulist = ljl_gpu_compute_n(ntimestep, neighbor->ago, inum, nall,
atom->x, atom->type, domain->sublo,
domain->subhi, atom->tag, atom->nspecial,
atom->special, eflag, vflag, eflag_atom,
vflag_atom, host_start, cpu_time, success);
} else {
inum = list->inum;
ljl_gpu_compute(update->ntimestep, neighbor->ago, inum, nall, atom->x,
ljl_gpu_compute(ntimestep, neighbor->ago, inum, nall, atom->x,
atom->type, list->ilist, list->numneigh, list->firstneigh,
eflag, vflag, eflag_atom, vflag_atom, host_start, cpu_time,
success);

8
src/MANYBODY/fix_qeq_comb.cpp
View File

@ -20,6 +20,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_qeq_comb.h"
#include "lmptype.h"
#include "atom.h"
#include "force.h"
#include "group.h"
@ -171,8 +172,11 @@ void FixQEQComb::post_force(int vflag)
// charge-equilibration loop
if (me == 0 && fp)
fprintf(fp,"Charge equilibration on step %d\n",update->ntimestep);
if (me == 0 && fp) {
char fstr[64];
sprintf(fstr,"Charge equilibration on step %s\n",BIGINT_FORMAT);
fprintf(fp,fstr,update->ntimestep);
}
heatpq = 0.01;
qmass = 0.06;

12
src/MOLECULE/bond_fene.cpp
View File

@ -14,6 +14,7 @@
#include "math.h"
#include "stdlib.h"
#include "bond_fene.h"
#include "lmptype.h"
#include "atom.h"
#include "neighbor.h"
#include "domain.h"
@ -85,9 +86,9 @@ void BondFENE::compute(int eflag, int vflag)
// if r > 2*r0 something serious is wrong, abort
if (rlogarg < 0.1) {
char str[128];
sprintf(str,"FENE bond too long: %d %d %d %g",
update->ntimestep,atom->tag[i1],atom->tag[i2],sqrt(rsq));
char str[128],fstr[64];
sprintf(fstr,"FENE bond too long: %s %%d %%d %%g",BIGINT_FORMAT);
sprintf(str,fstr,update->ntimestep,atom->tag[i1],atom->tag[i2],sqrt(rsq));
error->warning(str,0);
if (rlogarg <= -3.0) error->one("Bad FENE bond");
rlogarg = 0.1;
@ -242,8 +243,9 @@ double BondFENE::single(int type, double rsq, int i, int j)
// if r > 2*r0 something serious is wrong, abort
if (rlogarg < 0.1) {
char str[128];
sprintf(str,"FENE bond too long: %d %g",update->ntimestep,sqrt(rsq));
char str[128],fstr[64];
sprintf(fstr,"FENE bond too long: %s %%g",BIGINT_FORMAT);
sprintf(str,fstr,update->ntimestep,sqrt(rsq));
error->warning(str,0);
if (rlogarg <= -3.0) error->one("Bad FENE bond");
rlogarg = 0.1;

12
src/MOLECULE/bond_fene_expand.cpp
View File

@ -14,6 +14,7 @@
#include "math.h"
#include "stdlib.h"
#include "bond_fene_expand.h"
#include "lmptype.h"
#include "atom.h"
#include "neighbor.h"
#include "domain.h"
@ -90,9 +91,9 @@ void BondFENEExpand::compute(int eflag, int vflag)
// if r > 2*r0 something serious is wrong, abort
if (rlogarg < 0.1) {
char str[128];
sprintf(str,"FENE bond too long: %d %d %d %g",
update->ntimestep,atom->tag[i1],atom->tag[i2],sqrt(rsq));
char str[128],fstr[64];
sprintf(fstr,"FENE bond too long: %s %%d %%d %%g",BIGINT_FORMAT);
sprintf(str,fstr,update->ntimestep,atom->tag[i1],atom->tag[i2],sqrt(rsq));
error->warning(str,0);
if (rlogarg <= -3.0) error->one("Bad FENE bond");
rlogarg = 0.1;
@ -256,8 +257,9 @@ double BondFENEExpand::single(int type, double rsq, int i, int j)
// if r > 2*r0 something serious is wrong, abort
if (rlogarg < 0.1) {
char str[128];
sprintf(str,"FENE bond too long: %d %g",update->ntimestep,sqrt(rsq));
char str[128],fstr[64];
sprintf(fstr,"FENE bond too long: %s %%g",BIGINT_FORMAT);
sprintf(str,fstr,update->ntimestep,sqrt(rsq));
error->warning(str,0);
if (rlogarg <= -3.0) error->one("Bad FENE bond");
rlogarg = 0.1;

7
src/MOLECULE/dihedral_charmm.cpp
View File

@ -19,6 +19,7 @@
#include "math.h"
#include "stdlib.h"
#include "dihedral_charmm.h"
#include "lmptype.h"
#include "atom.h"
#include "comm.h"
#include "neighbor.h"
@ -146,9 +147,9 @@ void DihedralCharmm::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Dihedral problem: %d %d %d %d %d %d",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Dihedral problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",

7
src/MOLECULE/dihedral_harmonic.cpp
View File

@ -19,6 +19,7 @@
#include "math.h"
#include "stdlib.h"
#include "dihedral_harmonic.h"
#include "lmptype.h"
#include "atom.h"
#include "comm.h"
#include "neighbor.h"
@ -136,9 +137,9 @@ void DihedralHarmonic::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Dihedral problem: %d %d %d %d %d %d",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Dihedral problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",

7
src/MOLECULE/dihedral_helix.cpp
View File

@ -20,6 +20,7 @@
#include "stdlib.h"
#include "mpi.h"
#include "dihedral_helix.h"
#include "lmptype.h"
#include "atom.h"
#include "neighbor.h"
#include "domain.h"
@ -168,9 +169,9 @@ void DihedralHelix::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Dihedral problem: %d %d %d %d %d %d",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Dihedral problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",

17
src/MOLECULE/dihedral_multi_harmonic.cpp
View File

@ -18,6 +18,7 @@
#include "math.h"
#include "stdlib.h"
#include "dihedral_multi_harmonic.h"
#include "lmptype.h"
#include "atom.h"
#include "neighbor.h"
#include "domain.h"
@ -158,20 +159,22 @@ void DihedralMultiHarmonic::compute(int eflag, int vflag)
// error check
if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Dihedral problem: %d %d %d %d %d %d",
comm->me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Dihedral problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",
comm->me,x[i1][0],x[i1][1],x[i1][2]);
me,x[i1][0],x[i1][1],x[i1][2]);
fprintf(screen," 2nd atom: %d %g %g %g\n",
comm->me,x[i2][0],x[i2][1],x[i2][2]);
me,x[i2][0],x[i2][1],x[i2][2]);
fprintf(screen," 3rd atom: %d %g %g %g\n",
comm->me,x[i3][0],x[i3][1],x[i3][2]);
me,x[i3][0],x[i3][1],x[i3][2]);
fprintf(screen," 4th atom: %d %g %g %g\n",
comm->me,x[i4][0],x[i4][1],x[i4][2]);
me,x[i4][0],x[i4][1],x[i4][2]);
}
}

17
src/MOLECULE/dihedral_opls.cpp
View File

@ -18,6 +18,7 @@
#include "math.h"
#include "stdlib.h"
#include "dihedral_opls.h"
#include "lmptype.h"
#include "atom.h"
#include "comm.h"
#include "neighbor.h"
@ -164,20 +165,22 @@ void DihedralOPLS::compute(int eflag, int vflag)
// error check
if (c > 1.0 + TOLERANCE || c < (-1.0 - TOLERANCE)) {
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Dihedral problem: %d %d %d %d %d %d",
comm->me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Dihedral problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",
comm->me,x[i1][0],x[i1][1],x[i1][2]);
me,x[i1][0],x[i1][1],x[i1][2]);
fprintf(screen," 2nd atom: %d %g %g %g\n",
comm->me,x[i2][0],x[i2][1],x[i2][2]);
me,x[i2][0],x[i2][1],x[i2][2]);
fprintf(screen," 3rd atom: %d %g %g %g\n",
comm->me,x[i3][0],x[i3][1],x[i3][2]);
me,x[i3][0],x[i3][1],x[i3][2]);
fprintf(screen," 4th atom: %d %g %g %g\n",
comm->me,x[i4][0],x[i4][1],x[i4][2]);
me,x[i4][0],x[i4][1],x[i4][2]);
}
}

7
src/MOLECULE/improper_cvff.cpp
View File

@ -15,6 +15,7 @@
#include "math.h"
#include "stdlib.h"
#include "improper_cvff.h"
#include "lmptype.h"
#include "atom.h"
#include "comm.h"
#include "neighbor.h"
@ -150,9 +151,9 @@ void ImproperCvff::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Improper problem: %d %d %d %d %d %d",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Improper problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",

7
src/MOLECULE/improper_harmonic.cpp
View File

@ -15,6 +15,7 @@
#include "math.h"
#include "stdlib.h"
#include "improper_harmonic.h"
#include "lmptype.h"
#include "atom.h"
#include "comm.h"
#include "neighbor.h"
@ -121,9 +122,9 @@ void ImproperHarmonic::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
char str[128];
sprintf(str,"Improper problem: %d %d %d %d %d %d",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Improper problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",

6
src/MOLECULE/improper_umbrella.cpp
View File

@ -128,9 +128,11 @@ void ImproperUmbrella::compute(int eflag, int vflag)
int me;
MPI_Comm_rank(world,&me);
if (screen) {
fprintf(screen,"Improper problem: %d %d %d %d %d %d\n",
me,update->ntimestep,
char str[128],fstr[64];
sprintf(fstr,"Improper problem: %%d %s %%d %%d %%d %%d",BIGINT_FORMAT);
sprintf(str,fstr,me,update->ntimestep,
atom->tag[i1],atom->tag[i2],atom->tag[i3],atom->tag[i4]);
error->warning(str,0);
fprintf(screen," 1st atom: %d %g %g %g\n",
me,x[i1][0],x[i1][1],x[i1][2]);
fprintf(screen," 2nd atom: %d %g %g %g\n",

7
src/REAX/fix_reax_bonds.cpp
View File

@ -18,6 +18,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_reax_bonds.h"
#include "lmptype.h"
#include "pair_reax_fortran.h"
#include "atom.h"
#include "update.h"
@ -98,7 +99,7 @@ void FixReaxBonds::end_of_step()
/* ---------------------------------------------------------------------- */
void FixReaxBonds::OutputReaxBonds(int timestep, FILE *fp)
void FixReaxBonds::OutputReaxBonds(bigint ntimestep, FILE *fp)
{
int nparticles,nparticles_tot,nbuf,nbuf_local,most,j;
int ii,jn,mbond,numbonds,nsbmax,nsbmax_most;
@ -120,7 +121,9 @@ void FixReaxBonds::OutputReaxBonds(int timestep, FILE *fp)
MPI_Allreduce(&nsbmax,&nsbmax_most,1,MPI_INT,MPI_MAX,world);
if (me == 0) {
fprintf(fp,"# Timestep %d \n",timestep);
char fstr[32];
sprintf(fstr,"# Timestep %d \n",BIGINT_FORMAT);
fprintf(fp,fstr,ntimestep);
fprintf(fp,"# \n");
fprintf(fp,"# Number of particles %d \n",nparticles_tot);
fprintf(fp,"# \n");

1
src/REPLICA/fix_event.h
View File

@ -20,7 +20,6 @@ namespace LAMMPS_NS {
class FixEvent : public Fix {
public:
FixEvent(class LAMMPS *, int, char **);
virtual ~FixEvent()=0; // Use destructor to make base class virtual
int setmask();

5
src/REPLICA/fix_event_prd.cpp
View File

@ -18,6 +18,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_event_prd.h"
#include "lmptype.h"
#include "atom.h"
#include "update.h"
#include "domain.h"
@ -50,10 +51,10 @@ FixEventPRD::FixEventPRD(LAMMPS *lmp, int narg, char **arg) :
update clock = elapsed time since last event, across all replicas
------------------------------------------------------------------------- */
void FixEventPRD::store_event_prd(int timestep, int delta_clock)
void FixEventPRD::store_event_prd(bigint ntimestep, int delta_clock)
{
store_event();
event_timestep = timestep;
event_timestep = ntimestep;
clock += delta_clock;
event_number++;
}

5
src/REPLICA/fix_event_prd.h
View File

@ -21,13 +21,14 @@ FixStyle(EVENT/PRD,FixEventPRD)
#define LMP_FIX_EVENT_PRD_H
#include "fix_event.h"
#include "lmptype.h"
namespace LAMMPS_NS {
class FixEventPRD : public FixEvent {
public:
int event_number; // event counter
int event_timestep; // timestep of last event on any replica
bigint event_timestep; // timestep of last event on any replica
int clock; // total elapsed timesteps across all replicas
int replica_number; // replica where last event occured
int correlated_event; // 1 if last event was correlated, 0 otherwise
@ -41,7 +42,7 @@ class FixEventPRD : public FixEvent {
// methods specific to FixEventPRD, invoked by PRD
void store_event_prd(int, int);
void store_event_prd(bigint, int);
private:

5
src/REPLICA/fix_event_tad.cpp
View File

@ -18,6 +18,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_event_tad.h"
#include "lmptype.h"
#include "atom.h"
#include "update.h"
#include "domain.h"
@ -50,10 +51,10 @@ FixEventTAD::FixEventTAD(LAMMPS *lmp, int narg, char **arg) :
set event_timestep = when event occurred
------------------------------------------------------------------------- */
void FixEventTAD::store_event_tad(int timestep)
void FixEventTAD::store_event_tad(bigint ntimestep)
{
store_event();
event_timestep = timestep;
event_timestep = ntimestep;
}
/* ----------------------------------------------------------------------

5
src/REPLICA/fix_event_tad.h
View File

@ -21,13 +21,14 @@ FixStyle(EVENT/TAD,FixEventTAD)
#define LMP_FIX_EVENT_TAD_H
#include "fix_event.h"
#include "lmptype.h"
namespace LAMMPS_NS {
class FixEventTAD : public FixEvent {
public:
int event_number; // event counter
int event_timestep; // timestep of last event
bigint event_timestep; // timestep of last event
double tlo; // event time at low temperature
double ebarrier; // energy barrier for this event
@ -39,7 +40,7 @@ class FixEventTAD : public FixEvent {
// methods specific to FixEventTAD, invoked by TAD
void store_event_tad(int);
void store_event_tad(bigint);
private:

7
src/REPLICA/neb.cpp
View File

@ -16,6 +16,7 @@
#include "stdlib.h"
#include "string.h"
#include "neb.h"
#include "lmptype.h"
#include "universe.h"
#include "atom.h"
#include "update.h"
@ -482,8 +483,10 @@ void NEB::print_status()
}
if (me_universe == 0) {
char fstr[32];
sprintf(fstr,"%s %%g %%g ",BIGINT_FORMAT);
if (universe->uscreen) {
fprintf(universe->uscreen,"%d %g %g ",update->ntimestep,
fprintf(universe->uscreen,fstr,update->ntimestep,
fmaxreplica,fmaxatom);
fprintf(universe->uscreen,"%g %g %g ",
gradvnorm0,gradvnorm1,gradvnormc);
@ -493,7 +496,7 @@ void NEB::print_status()
fprintf(universe->uscreen,"\n");
}
if (universe->ulogfile) {
fprintf(universe->ulogfile,"%d %g %g ",update->ntimestep,
fprintf(universe->ulogfile,fstr,update->ntimestep,
fmaxreplica,fmaxatom);
fprintf(universe->ulogfile,"%g %g %g ",
gradvnorm0,gradvnorm1,gradvnormc);

12
src/REPLICA/prd.cpp
View File

@ -424,7 +424,7 @@ void PRD::command(int narg, char **arg)
void PRD::dephase()
{
int ntimestep_hold = update->ntimestep;
bigint ntimestep_hold = update->ntimestep;
update->whichflag = 1;
update->nsteps = n_dephase*t_dephase;
@ -486,8 +486,8 @@ void PRD::dynamics()
void PRD::quench()
{
int ntimestep_hold = update->ntimestep;
int endstep_hold = update->endstep;
bigint ntimestep_hold = update->ntimestep;
bigint endstep_hold = update->endstep;
// need to change whichflag so that minimize->setup() calling
// modify->setup() will call fix->min_setup()
@ -649,8 +649,10 @@ void PRD::log_event()
{
timer->array[TIME_LOOP] = time_start;
if (universe->me == 0) {
char fstr[32];
sprintf(fstr,"%s %%.3f %%d %%d %%d %%d %%d\n",BIGINT_FORMAT);
if (universe->uscreen)
fprintf(universe->uscreen,"%d %.3f %d %d %d %d %d\n",
fprintf(universe->uscreen,fstr,
fix_event->event_timestep,
timer->elapsed(TIME_LOOP),
fix_event->clock,
@ -658,7 +660,7 @@ void PRD::log_event()
fix_event->ncoincident,
fix_event->replica_number);
if (universe->ulogfile)
fprintf(universe->ulogfile,"%d %.3f %d %d %d %d %d\n",
fprintf(universe->ulogfile,fstr,
fix_event->event_timestep,
timer->elapsed(TIME_LOOP),
fix_event->clock,

32
src/REPLICA/tad.cpp
View File

@ -79,7 +79,8 @@ void TAD::command(int narg, char **arg)
if (domain->box_exist == 0)
error->all("tad command before simulation box is defined");
if (universe->nworlds == 1) error->all("Cannot use TAD with a single replica for NEB");
if (universe->nworlds == 1)
error->all("Cannot use TAD with a single replica for NEB");
if (universe->nworlds != universe->nprocs)
error->all("Can only use TAD with 1-processor replicas for NEB");
if (atom->sortfreq > 0)
@ -222,11 +223,9 @@ void TAD::command(int narg, char **arg)
if (me_universe == 0) {
if (universe->uscreen)
fprintf(universe->uscreen,"Step CPU Clock Event "
"\n");
fprintf(universe->uscreen,"Step CPU Clock Event\n");
if (universe->ulogfile)
fprintf(universe->ulogfile,"Step CPU Clock Event "
"\n");
fprintf(universe->ulogfile,"Step CPU Clock Event\n");
}
ulogfile_lammps = universe->ulogfile;
@ -452,8 +451,8 @@ void TAD::dynamics()
void TAD::quench()
{
int ntimestep_hold = update->ntimestep;
int endstep_hold = update->endstep;
bigint ntimestep_hold = update->ntimestep;
bigint endstep_hold = update->endstep;
// need to change whichflag so that minimize->setup() calling
// modify->setup() will call fix->min_setup()
@ -518,14 +517,16 @@ void TAD::log_event()
{
timer->array[TIME_LOOP] = time_start;
if (universe->me == 0) {
char fstr[32];
sprintf(fstr,"%s %%.3f %%.3f %%d\n",BIGINT_FORMAT);
if (universe->uscreen)
fprintf(universe->uscreen,"%d %.3f %.3f %d\n",
fprintf(universe->uscreen,fstr,
fix_event->event_timestep,
timer->elapsed(TIME_LOOP),
fix_event->tlo,
fix_event->event_number);
if (universe->ulogfile)
fprintf(universe->ulogfile,"%d %.3f %.3f %d\n",
fprintf(universe->ulogfile,fstr,
fix_event->event_timestep,
timer->elapsed(TIME_LOOP),
fix_event->tlo,
@ -913,7 +914,7 @@ void TAD::compute_tlo(int ievent)
// first-replica output about each event
if (universe->me == 0) {
char str[128];
char str[128],fstr[128];
double tfrac = 0.0;
if (ievent > 0) tfrac = delthi/deltstop;
// sprintf(str,
@ -921,15 +922,14 @@ void TAD::compute_tlo(int ievent)
// ievent,ebarrier,deltlo,delthi,tfrac);
// error->warning(str);
sprintf(fstr,"New event: t_hi = %s ievent = %%d eb = %%g "
"dt_lo = %%g dt_hi/t_stop = %%g \n",BIGINT_FORMAT);
if (screen)
fprintf(screen,
"New event: t_hi = %d ievent = %d eb = %g dt_lo = %g dt_hi/t_stop = %g \n",
fix_event_list[ievent]->event_timestep,
fprintf(screen,fstr,fix_event_list[ievent]->event_timestep,
ievent,ebarrier,deltlo,tfrac);
if (logfile)
fprintf(logfile,
"New event: t_hi = %d ievent = %d eb = %g dt_lo = %g dt_hi/t_stop = %g \n",
fix_event_list[ievent]->event_timestep,
fprintf(logfile,fstr,fix_event_list[ievent]->event_timestep,
ievent,ebarrier,deltlo,tfrac);
}

9
src/REPLICA/temper.cpp
View File

@ -19,6 +19,7 @@
#include "stdlib.h"
#include "string.h"
#include "temper.h"
#include "lmptype.h"
#include "universe.h"
#include "domain.h"
#include "atom.h"
@ -342,15 +343,15 @@ void Temper::scale_velocities(int t_partner, int t_me)
void Temper::print_status()
{
if (universe->uscreen) {
fprintf(universe->uscreen,"%d ",update->ntimestep);
fprintf(universe->uscreen,BIGINT_FORMAT,update->ntimestep);
for (int i = 0; i < nworlds; i++)
fprintf(universe->uscreen,"%d ",world2temp[i]);
fprintf(universe->uscreen," %d",world2temp[i]);
fprintf(universe->uscreen,"\n");
}
if (universe->ulogfile) {
fprintf(universe->ulogfile,"%d ",update->ntimestep);
fprintf(universe->ulogfile,BIGINT_FORMAT,update->ntimestep);
for (int i = 0; i < nworlds; i++)
fprintf(universe->ulogfile,"%d ",world2temp[i]);
fprintf(universe->ulogfile," %d",world2temp[i]);
fprintf(universe->ulogfile,"\n");
fflush(universe->ulogfile);
}

62
src/SRD/fix_srd.cpp
View File

@ -692,8 +692,9 @@ void FixSRD::post_force(int vflag)
if (ix < 0 || ix >= nbin2x || iy < 0 || iy >= nbin2y ||
iz < 0 || iz >= nbin2z) {
printf("SRD particle %d on step %d\n",
atom->tag[i],update->ntimestep);
char fstr[64];
sprintf(fstr,"SRD particle %%d on step %s\n",BIGINT_FORMAT);
printf(fstr,atom->tag[i],update->ntimestep);
printf("v = %g %g %g\n",v[i][0],v[i][1],v[i][2]);
printf("x = %g %g %g\n",x[i][0],x[i][1],x[i][2]);
printf("ix,iy,iz nx,ny,nz = %d %d %d %d %d %d\n",
@ -1150,28 +1151,22 @@ void FixSRD::collisions_single()
if (t_remain > dt) {
ninside++;
if (insideflag == INSIDE_ERROR) {
char str[128];
if (type != WALL)
sprintf(str,"SRD particle %d started "
"inside big particle %d on step %d bounce %d\n",
if (insideflag == INSIDE_ERROR || insideflag == INSIDE_WARN) {
char str[128],fstr[128];
if (type != WALL) {
sprintf(fstr,"SRD particle %%d started "
"inside big particle %%d on step %s bounce %%d\n",
BIGINT_FORMAT);
sprintf(str,fstr,
atom->tag[i],atom->tag[j],update->ntimestep,ibounce+1);
else
sprintf(str,"SRD particle %d started "
"inside wall %d on step %d bounce %d\n",
atom->tag[i],j,update->ntimestep,ibounce+1);
error->one(str);
}
if (insideflag == INSIDE_WARN) {
char str[128];
if (type != WALL)
sprintf(str,"SRD particle %d started "
"inside big particle %d on step %d bounce %d\n",
atom->tag[i],atom->tag[j],update->ntimestep,ibounce+1);
else
sprintf(str,"SRD particle %d started "
"inside wall %d on step %d bounce %d\n",
} else {
sprintf(fstr,"SRD particle %%d started "
"inside wall %%d on step %s bounce %%d\n",
BIGINT_FORMAT);
sprintf(str,fstr,
atom->tag[i],j,update->ntimestep,ibounce+1);
}
if (insideflag == INSIDE_ERROR) error->one(str);
error->warning(str);
}
break;
@ -1300,18 +1295,14 @@ void FixSRD::collisions_multi()
if (t_remain > dt || t_remain < 0.0) {
ninside++;
if (insideflag == INSIDE_ERROR) {
char str[128];
sprintf(str,"SRD particle %d started "
"inside big particle %d on step %d bounce %d\n",
atom->tag[i],atom->tag[j],update->ntimestep,ibounce+1);
error->one(str);
}
if (insideflag == INSIDE_WARN) {
char str[128];
sprintf(str,"SRD particle %d started "
"inside big particle %d on step %d bounce %d\n",
if (insideflag == INSIDE_ERROR || insideflag == INSIDE_WARN) {
char str[128],fstr[128];
sprintf(fstr,"SRD particle %%d started "
"inside big particle %%d on step %s bounce %%d\n",
BIGINT_FORMAT);
sprintf(str,fstr,
atom->tag[i],atom->tag[j],update->ntimestep,ibounce+1);
if (insideflag == INSIDE_ERROR) error->one(str);
error->warning(str);
}
t_first = 0.0;
@ -2081,8 +2072,9 @@ int FixSRD::update_srd(int i, double dt, double *xscoll, double *vsnew,
xs[1] < srdlo[1] || xs[1] > srdhi[1] ||
xs[2] < srdlo[2] || xs[2] > srdhi[2]) {
printf("Bad SRD particle move\n");
printf(" particle %d on proc %d at timestep %d\n",
atom->tag[i],me,update->ntimestep);
char fstr[64];
sprintf(fstr," particle %%d on proc %%d at timestep %s\n",BIGINT_FORMAT);
printf(fstr,atom->tag[i],me,update->ntimestep);
printf(" xnew %g %g %g\n",xs[0],xs[1],xs[2]);
printf(" srdlo/hi x %g %g\n",srdlo[0],srdhi[0]);
printf(" srdlo/hi y %g %g\n",srdlo[1],srdhi[1]);

2
src/SRD/fix_wall_srd.cpp
View File

@ -230,7 +230,7 @@ void FixWallSRD::wall_params(int flag)
if (varflag) modify->clearstep_compute();
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
for (int m = 0; m < nwall; m++) {
if (wallstyle[m] == VARIABLE)

3
src/SRD/fix_wall_srd.h
View File

@ -21,6 +21,7 @@ FixStyle(wall/srd,FixWallSRD)
#define LMP_FIX_WALL_SRD_H
#include "fix.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -47,7 +48,7 @@ class FixWallSRD : public Fix {
double dt;
double xwalllast[6];
int laststep;
bigint laststep;
double **fwall_all;
int force_flag;

10
src/XTC/dump_xtc.cpp
View File

@ -68,7 +68,8 @@ DumpXTC::DumpXTC(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg)
// allocate global array for atom coords
bigint n = group->count(igroup);
if (n > MAXSMALLINT) error->all("Too many atoms for dump xtc");
if (n > MAXSMALLINT/3/sizeof(float))
error->all("Too many atoms for dump xtc");
natoms = static_cast<int> (n);
coords = (float *) memory->smalloc(3*natoms*sizeof(float),"dump:coords");
@ -138,6 +139,9 @@ void DumpXTC::write_header(bigint nbig)
{
if (nbig > MAXSMALLINT) error->all("Too many atoms for dump xtc");
int n = nbig;
if (update->ntimestep > MAXSMALLINT)
error->all("Too big a timestep for dump xtc");
int ntimestep = update->ntimestep;
// all procs realloc coords if total count grew
@ -154,8 +158,8 @@ void DumpXTC::write_header(bigint nbig)
int tmp = XTC_MAGIC;
xdr_int(&xd,&tmp);
xdr_int(&xd,&n);
xdr_int(&xd,&update->ntimestep);
float time_value = update->ntimestep * update->dt;
xdr_int(&xd,&ntimestep);
float time_value = ntimestep * update->dt;
xdr_float(&xd,&time_value);
// cell basis vectors

2
src/atom.h
View File

@ -108,7 +108,7 @@ class Atom : protected Pointers {
// spatial sorting of atoms
int sortfreq; // sort atoms every this many steps, 0 = off
int nextsort; // next timestep to sort on
bigint nextsort; // next timestep to sort on
// functions

9
src/compute.cpp
View File

@ -16,6 +16,7 @@
#include "string.h"
#include "ctype.h"
#include "compute.h"
#include "lmptype.h"
#include "atom.h"
#include "domain.h"
#include "comm.h"
@ -147,7 +148,7 @@ void Compute::reset_extra_compute_fix(char *)
search from top downward, since list of times is in decreasing order
------------------------------------------------------------------------- */
void Compute::addstep(int ntimestep)
void Compute::addstep(bigint ntimestep)
{
// i = location in list to insert ntimestep
@ -162,8 +163,8 @@ void Compute::addstep(int ntimestep)
if (ntime == maxtime) {
maxtime += DELTA;
tlist = (int *)
memory->srealloc(tlist,maxtime*sizeof(int),"compute:tlist");
tlist = (bigint *)
memory->srealloc(tlist,maxtime*sizeof(bigint),"compute:tlist");
}
// move remainder of list upward and insert ntimestep
@ -179,7 +180,7 @@ void Compute::addstep(int ntimestep)
search from top downward, since list of times is in decreasing order
------------------------------------------------------------------------- */
int Compute::matchstep(int ntimestep)
int Compute::matchstep(bigint ntimestep)
{
for (int i = ntime-1; i >= 0; i--) {
if (ntimestep < tlist[i]) return 0;

19
src/compute.h
View File

@ -15,6 +15,7 @@
#define LMP_COMPUTE_H
#include "pointers.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -63,14 +64,14 @@ class Compute : protected Pointers {
int timeflag; // 1 if Compute stores list of timesteps it's called on
int ntime; // # of entries in time list
int maxtime; // max # of entries time list can hold
int *tlist; // time list of steps the Compute is called on
bigint *tlist; // list of timesteps the Compute is called on
int invoked_flag; // non-zero if invoked or accessed this step, 0 if not
int invoked_scalar; // last timestep on which compute_scalar() was invoked
int invoked_vector; // ditto for compute_vector()
int invoked_array; // ditto for compute_array()
int invoked_peratom; // ditto for compute_peratom()
int invoked_local; // ditto for compute_local()
int invoked_flag; // non-zero if invoked or accessed this step, 0 if not
bigint invoked_scalar; // last timestep on which compute_scalar() was invoked
bigint invoked_vector; // ditto for compute_vector()
bigint invoked_array; // ditto for compute_array()
bigint invoked_peratom; // ditto for compute_peratom()
bigint invoked_local; // ditto for compute_local()
double dof; // degrees-of-freedom for temperature
@ -103,8 +104,8 @@ class Compute : protected Pointers {
virtual void reset_extra_compute_fix(char *);
void addstep(int);
int matchstep(int);
void addstep(bigint);
int matchstep(bigint);
void clearstep();
virtual double memory_usage() {return 0.0;}

4
src/dump.cpp
View File

@ -359,7 +359,9 @@ void Dump::openfile()
filecurrent = new char[strlen(filename) + 16];
char *ptr = strchr(filename,'*');
*ptr = '\0';
sprintf(filecurrent,"%s%d%s",filename,update->ntimestep,ptr+1);
char fstr[16];
sprintf(fstr,"%%s%s%%s",BIGINT_FORMAT);
sprintf(filecurrent,fstr,filename,update->ntimestep,ptr+1);
*ptr = '*';
}

10
src/dump_atom.cpp
View File

@ -162,8 +162,7 @@ void DumpAtom::write_data(int n, double *mybuf)
void DumpAtom::header_binary(bigint ndump)
{
bigint ntimestep = update->ntimestep;
fwrite(&ntimestep,sizeof(bigint),1,fp);
fwrite(&update->ntimestep,sizeof(bigint),1,fp);
fwrite(&ndump,sizeof(bigint),1,fp);
fwrite(&domain->triclinic,sizeof(int),1,fp);
fwrite(&boxxlo,sizeof(double),1,fp);
@ -183,8 +182,7 @@ void DumpAtom::header_binary(bigint ndump)
void DumpAtom::header_binary_triclinic(bigint ndump)
{
bigint ntimestep = update->ntimestep;
fwrite(&ntimestep,sizeof(bigint),1,fp);
fwrite(&update->ntimestep,sizeof(bigint),1,fp);
fwrite(&ndump,sizeof(bigint),1,fp);
fwrite(&domain->triclinic,sizeof(int),1,fp);
fwrite(&boxxlo,sizeof(double),1,fp);
@ -208,7 +206,7 @@ void DumpAtom::header_binary_triclinic(bigint ndump)
void DumpAtom::header_item(bigint ndump)
{
fprintf(fp,"ITEM: TIMESTEP\n");
fprintf(fp,"%d\n",update->ntimestep);
fprintf(fp,BIGINT_FORMAT_NL,update->ntimestep);
fprintf(fp,"ITEM: NUMBER OF ATOMS\n");
fprintf(fp,BIGINT_FORMAT_NL,ndump);
fprintf(fp,"ITEM: BOX BOUNDS\n");
@ -223,7 +221,7 @@ void DumpAtom::header_item(bigint ndump)
void DumpAtom::header_item_triclinic(bigint ndump)
{
fprintf(fp,"ITEM: TIMESTEP\n");
fprintf(fp,"%d\n",update->ntimestep);
fprintf(fp,BIGINT_FORMAT_NL,update->ntimestep);
fprintf(fp,"ITEM: NUMBER OF ATOMS\n");
fprintf(fp,BIGINT_FORMAT_NL,ndump);
fprintf(fp,"ITEM: BOX BOUNDS xy xz yz\n");

10
src/dump_custom.cpp
View File

@ -246,8 +246,7 @@ void DumpCustom::write_header(bigint ndump)
void DumpCustom::header_binary(bigint ndump)
{
bigint ntimestep = update->ntimestep;
fwrite(&ntimestep,sizeof(int),1,fp);
fwrite(&update->ntimestep,sizeof(bigint),1,fp);
fwrite(&ndump,sizeof(bigint),1,fp);
fwrite(&domain->triclinic,sizeof(int),1,fp);
fwrite(&boxxlo,sizeof(double),1,fp);
@ -267,7 +266,7 @@ void DumpCustom::header_binary(bigint ndump)
void DumpCustom::header_binary_triclinic(bigint ndump)
{
fwrite(&update->ntimestep,sizeof(int),1,fp);
fwrite(&update->ntimestep,sizeof(bigint),1,fp);
fwrite(&ndump,sizeof(bigint),1,fp);
fwrite(&domain->triclinic,sizeof(int),1,fp);
fwrite(&boxxlo,sizeof(double),1,fp);
@ -291,7 +290,7 @@ void DumpCustom::header_binary_triclinic(bigint ndump)
void DumpCustom::header_item(bigint ndump)
{
fprintf(fp,"ITEM: TIMESTEP\n");
fprintf(fp,"%d\n",update->ntimestep);
fprintf(fp,BIGINT_FORMAT_NL,update->ntimestep);
fprintf(fp,"ITEM: NUMBER OF ATOMS\n");
fprintf(fp,BIGINT_FORMAT_NL,ndump);
fprintf(fp,"ITEM: BOX BOUNDS\n");
@ -306,7 +305,7 @@ void DumpCustom::header_item(bigint ndump)
void DumpCustom::header_item_triclinic(bigint ndump)
{
fprintf(fp,"ITEM: TIMESTEP\n");
fprintf(fp,"%d\n",update->ntimestep);
fprintf(fp,BIGINT_FORMAT_NL,update->ntimestep);
fprintf(fp,"ITEM: NUMBER OF ATOMS\n");
fprintf(fp,BIGINT_FORMAT_NL,ndump);
fprintf(fp,"ITEM: BOX BOUNDS xy xz yz\n");
@ -344,7 +343,6 @@ int DumpCustom::count()
// invoke Computes for per-atom quantities
if (ncompute) {
int ntimestep = update->ntimestep;
for (i = 0; i < ncompute; i++)
if (!(compute[i]->invoked_flag & INVOKED_PERATOM)) {
compute[i]->compute_peratom();

10
src/dump_dcd.cpp
View File

@ -69,7 +69,7 @@ DumpDCD::DumpDCD(LAMMPS *lmp, int narg, char **arg) : Dump(lmp, narg, arg)
// allocate global array for atom coords
bigint n = group->count(igroup);
if (n > MAXSMALLINT) error->all("Too many atoms for dump dcd");
if (n > MAXSMALLINT/sizeof(float)) error->all("Too many atoms for dump dcd");
natoms = static_cast<int> (n);
coords = (float *) memory->smalloc(3*natoms*sizeof(float),"dump:coords");
@ -125,6 +125,8 @@ void DumpDCD::openfile()
void DumpDCD::write_header(bigint n)
{
if (n != natoms) error->all("Dump dcd of non-matching # of atoms");
if (update->ntimestep > MAXSMALLINT)
error->all("Too big a timestep for dump dcd");
// first time, write header for entire file
@ -323,14 +325,16 @@ void DumpDCD::write_dcd_header(const char *remarks)
time_t cur_time;
struct tm *tmbuf;
int ntimestep = update->ntimestep;
out_integer = 84;
fwrite_int32(fp,out_integer);
strcpy(title_string,"CORD");
fwrite(title_string,4,1,fp);
fwrite_int32(fp,0); // NFILE = # of snapshots in file
fwrite_int32(fp,update->ntimestep); // START = timestep of first snapshot
fwrite_int32(fp,ntimestep); // START = timestep of first snapshot
fwrite_int32(fp,nevery_save); // SKIP = interval between snapshots
fwrite_int32(fp,update->ntimestep); // NSTEP = timestep of last snapshot
fwrite_int32(fp,ntimestep); // NSTEP = timestep of last snapshot
fwrite_int32(fp,0); // NAMD writes NSTEP or ISTART
fwrite_int32(fp,0);
fwrite_int32(fp,0);

3
src/dump_local.cpp
View File

@ -191,7 +191,7 @@ void DumpLocal::write_header(bigint ndump)
{
if (me == 0) {
fprintf(fp,"ITEM: TIMESTEP\n");
fprintf(fp,"%d\n",update->ntimestep);
fprintf(fp,BIGINT_FORMAT_NL,update->ntimestep);
fprintf(fp,"ITEM: NUMBER OF %s\n",label);
fprintf(fp,BIGINT_FORMAT_NL,ndump);
fprintf(fp,"ITEM: %s %s\n",label,columns);
@ -207,7 +207,6 @@ int DumpLocal::count()
// invoke Computes for local quantities
if (ncompute) {
int ntimestep = update->ntimestep;
for (i = 0; i < ncompute; i++) {
if (!(compute[i]->invoked_flag & INVOKED_LOCAL)) {
compute[i]->compute_local();

3
src/fix.h
View File

@ -15,6 +15,7 @@
#define LMP_FIX_H
#include "pointers.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -29,7 +30,7 @@ class Fix : protected Pointers {
int box_change; // 1 if Fix changes box, 0 if not
int box_change_size; // 1 if Fix changes box size, 0 if not
int box_change_shape; // 1 if Fix changes box shape, 0 if not
int next_reneighbor; // next timestep to force a reneighboring
bigint next_reneighbor; // next timestep to force a reneighboring
int thermo_energy; // 1 if fix_modify enabled ThEng, 0 if not
int nevery; // how often to call an end_of_step fix
int rigid_flag; // 1 if Fix integrates rigid bodies, 0 if not

7
src/fix_ave_atom.cpp
View File

@ -14,6 +14,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_ave_atom.h"
#include "lmptype.h"
#include "atom.h"
#include "domain.h"
#include "update.h"
@ -276,7 +277,7 @@ void FixAveAtom::end_of_step()
// skip if not step which requires doing something
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
if (ntimestep != nvalid) return;
// zero if first step
@ -435,9 +436,9 @@ int FixAveAtom::unpack_exchange(int nlocal, double *buf)
else backup from next multiple of nfreq
------------------------------------------------------------------------- */
int FixAveAtom::nextvalid()
bigint FixAveAtom::nextvalid()
{
int nvalid = (update->ntimestep/peratom_freq)*peratom_freq + peratom_freq;
bigint nvalid = (update->ntimestep/peratom_freq)*peratom_freq + peratom_freq;
if (nvalid-peratom_freq == update->ntimestep && nrepeat == 1)
nvalid = update->ntimestep;
else

7
src/fix_ave_atom.h
View File

@ -22,6 +22,7 @@ FixStyle(ave/atom,FixAveAtom)
#include "stdio.h"
#include "fix.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -42,13 +43,13 @@ class FixAveAtom : public Fix {
private:
int nvalues;
int nrepeat,nvalid,irepeat;
int nrepeat,irepeat;
bigint nvalid;
int *which,*argindex,*value2index;
char **ids;
double **array;
int nextvalid();
bigint nextvalid();
};
}

11
src/fix_ave_correlate.cpp
View File

@ -20,6 +20,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_ave_correlate.h"
#include "lmptype.h"
#include "update.h"
#include "modify.h"
#include "compute.h"
@ -383,7 +384,7 @@ void FixAveCorrelate::end_of_step()
// skip if not step which requires doing something
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
if (ntimestep != nvalid) return;
// accumulate results of computes,fixes,variables to origin
@ -466,7 +467,9 @@ void FixAveCorrelate::end_of_step()
// output to file
if (fp && me == 0) {
fprintf(fp,"%d %d\n",ntimestep,nrepeat);
char fstr[16];
sprintf(fstr,"%s %%d\n",BIGINT_FORMAT);
fprintf(fp,fstr,ntimestep,nrepeat);
for (i = 0; i < nrepeat; i++) {
fprintf(fp,"%d %d %d",i+1,i*nevery,count[i]);
if (count[i])
@ -585,9 +588,9 @@ double FixAveCorrelate::compute_array(int i, int j)
startstep is lower bound
------------------------------------------------------------------------- */
int FixAveCorrelate::nextvalid()
bigint FixAveCorrelate::nextvalid()
{
int nvalid = update->ntimestep;
bigint nvalid = update->ntimestep;
if (startstep > nvalid) nvalid = startstep;
if (nvalid % nevery) nvalid = (nvalid/nevery)*nevery + nevery;
return nvalid;

6
src/fix_ave_correlate.h
View File

@ -22,6 +22,7 @@ FixStyle(ave/correlate,FixAveCorrelate)
#include "stdio.h"
#include "fix.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -37,7 +38,8 @@ class FixAveCorrelate : public Fix {
private:
int me,nvalues;
int nrepeat,nfreq,nvalid;
int nrepeat,nfreq;
bigint nvalid;
int *which,*argindex,*value2index;
char **ids;
FILE *fp;
@ -58,7 +60,7 @@ class FixAveCorrelate : public Fix {
double **save_corr;
void accumulate();
int nextvalid();
bigint nextvalid();
};
}

12
src/fix_ave_histo.cpp
View File

@ -14,6 +14,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_ave_histo.h"
#include "lmptype.h"
#include "atom.h"
#include "update.h"
#include "modify.h"
@ -568,7 +569,7 @@ void FixAveHisto::end_of_step()
// skip if not step which requires doing something
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
if (ntimestep != nvalid) return;
// zero if first step
@ -788,8 +789,9 @@ void FixAveHisto::end_of_step()
// output result to file
if (fp && me == 0) {
fprintf(fp,"%d %d %g %g %g %g\n",
ntimestep,nbins,
char fstr[32];
sprintf(fstr,"%s %%d %%g %%g %%g %%g\n",BIGINT_FORMAT);
fprintf(fp,fstr,ntimestep,nbins,
stats_total[0],stats_total[1],stats_total[2],stats_total[3]);
if (stats_total[0] != 0.0)
for (i = 0; i < nbins; i++)
@ -989,9 +991,9 @@ void FixAveHisto::allocate_values(int n)
else backup from next multiple of nfreq
------------------------------------------------------------------------- */
int FixAveHisto::nextvalid()
bigint FixAveHisto::nextvalid()
{
int nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
bigint nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
if (nvalid-nfreq == update->ntimestep && nrepeat == 1)
nvalid = update->ntimestep;
else

6
src/fix_ave_histo.h
View File

@ -22,6 +22,7 @@ FixStyle(ave/histo,FixAveHisto)
#include "stdio.h"
#include "fix.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -38,7 +39,8 @@ class FixAveHisto : public Fix {
private:
int me,nvalues;
int nrepeat,nfreq,nvalid,irepeat;
int nrepeat,nfreq,irepeat;
bigint nvalid;
int *which,*argindex,*value2index;
char **ids;
FILE *fp;
@ -65,7 +67,7 @@ class FixAveHisto : public Fix {
void bin_atoms(double *, int);
void options(int, char **);
void allocate_values(int);
int nextvalid();
bigint nextvalid();
};
}

11
src/fix_ave_spatial.cpp
View File

@ -18,6 +18,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_ave_spatial.h"
#include "lmptype.h"
#include "atom.h"
#include "update.h"
#include "force.h"
@ -494,7 +495,7 @@ void FixAveSpatial::end_of_step()
// skip if not step which requires doing something
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
if (ntimestep != nvalid) return;
// zero out arrays that accumulate over many samples
@ -788,7 +789,9 @@ void FixAveSpatial::end_of_step()
// output result to file
if (fp && me == 0) {
fprintf(fp,"%d %d\n",ntimestep,nbins);
char fstr[16];
sprintf(fstr,"%s %%d\n",BIGINT_FORMAT);
fprintf(fp,fstr,ntimestep,nbins);
if (ndim == 1)
for (m = 0; m < nbins; m++) {
fprintf(fp," %d %g %g",m+1,coord[m][0],
@ -1268,9 +1271,9 @@ double FixAveSpatial::compute_array(int i, int j)
else backup from next multiple of nfreq
------------------------------------------------------------------------- */
int FixAveSpatial::nextvalid()
bigint FixAveSpatial::nextvalid()
{
int nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
bigint nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
if (nvalid-nfreq == update->ntimestep && nrepeat == 1)
nvalid = update->ntimestep;
else

6
src/fix_ave_spatial.h
View File

@ -22,6 +22,7 @@ FixStyle(ave/spatial,FixAveSpatial)
#include "stdio.h"
#include "fix.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -38,7 +39,8 @@ class FixAveSpatial : public Fix {
private:
int me,nvalues;
int nrepeat,nfreq,nvalid,irepeat;
int nrepeat,nfreq,irepeat;
bigint nvalid;
int ndim,normflag,regionflag,iregion;
char *tstring,*sstring,*idregion;
int *which,*argindex,*value2index;
@ -72,7 +74,7 @@ class FixAveSpatial : public Fix {
void atom2bin1d();
void atom2bin2d();
void atom2bin3d();
int nextvalid();
bigint nextvalid();
};
}

17
src/fix_ave_time.cpp
View File

@ -18,6 +18,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_ave_time.h"
#include "lmptype.h"
#include "update.h"
#include "modify.h"
#include "compute.h"
@ -506,7 +507,7 @@ void FixAveTime::end_of_step()
{
// skip if not step which requires doing something
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
if (ntimestep != nvalid) return;
if (mode == SCALAR) invoke_scalar(ntimestep);
@ -515,7 +516,7 @@ void FixAveTime::end_of_step()
/* ---------------------------------------------------------------------- */
void FixAveTime::invoke_scalar(int ntimestep)
void FixAveTime::invoke_scalar(bigint ntimestep)
{
int i,m;
double scalar;
@ -629,7 +630,7 @@ void FixAveTime::invoke_scalar(int ntimestep)
// output result to file
if (fp && me == 0) {
fprintf(fp,"%d",ntimestep);
fprintf(fp,BIGINT_FORMAT,ntimestep);
for (i = 0; i < nvalues; i++) fprintf(fp," %g",vector_total[i]/norm);
fprintf(fp,"\n");
fflush(fp);
@ -638,7 +639,7 @@ void FixAveTime::invoke_scalar(int ntimestep)
/* ---------------------------------------------------------------------- */
void FixAveTime::invoke_vector(int ntimestep)
void FixAveTime::invoke_vector(bigint ntimestep)
{
int i,j,m;
@ -769,7 +770,9 @@ void FixAveTime::invoke_vector(int ntimestep)
// output result to file
if (fp && me == 0) {
fprintf(fp,"%d %d\n",ntimestep,nrows);
char fstr[16];
sprintf(fstr,"%s %%d\n",BIGINT_FORMAT);
fprintf(fp,fstr,ntimestep,nrows);
for (i = 0; i < nrows; i++) {
fprintf(fp,"%d",i+1);
for (j = 0; j < nvalues; j++) fprintf(fp," %g",array_total[i][j]/norm);
@ -920,9 +923,9 @@ void FixAveTime::allocate_values(int n)
else backup from next multiple of nfreq
------------------------------------------------------------------------- */
int FixAveTime::nextvalid()
bigint FixAveTime::nextvalid()
{
int nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
bigint nvalid = (update->ntimestep/nfreq)*nfreq + nfreq;
if (nvalid-nfreq == update->ntimestep && nrepeat == 1)
nvalid = update->ntimestep;
else

10
src/fix_ave_time.h
View File

@ -22,6 +22,7 @@ FixStyle(ave/time,FixAveTime)
#include "stdio.h"
#include "fix.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -39,7 +40,8 @@ class FixAveTime : public Fix {
private:
int me,nvalues;
int nrepeat,nfreq,nvalid,irepeat;
int nrepeat,nfreq,irepeat;
bigint nvalid;
int *which,*argindex,*value2index,*offcol;
char **ids;
FILE *fp;
@ -59,11 +61,11 @@ class FixAveTime : public Fix {
double **array_total;
double ***array_list;
void invoke_scalar(int);
void invoke_vector(int);
void invoke_scalar(bigint);
void invoke_vector(bigint);
void options(int, char **);
void allocate_values(int);
int nextvalid();
bigint nextvalid();
};
}

30
src/fix_shake.cpp
View File

@ -17,6 +17,7 @@
#include "string.h"
#include "stdio.h"
#include "fix_shake.h"
#include "lmptype.h"
#include "atom.h"
#include "atom_vec.h"
#include "update.h"
@ -390,7 +391,7 @@ void FixShake::setup(int vflag)
// setup SHAKE output
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
next_output = ntimestep + output_every;
if (output_every == 0) next_output = update->laststep + 1;
if (output_every && ntimestep % output_every != 0)
@ -453,8 +454,10 @@ void FixShake::pre_neighbor()
atom1 = atom->map(shake_atom[i][0]);
atom2 = atom->map(shake_atom[i][1]);
if (atom1 == -1 || atom2 == -1) {
char str[128];
sprintf(str,"Shake atoms %d %d missing on proc %d at step %d",
char str[128],fstr[64];
sprintf(fstr,"Shake atoms %%d %%d missing on proc %%d at step %s",
BIGINT_FORMAT);
sprintf(str,fstr,
shake_atom[i][0],shake_atom[i][1],me,update->ntimestep);
error->one(str);
}
@ -464,8 +467,10 @@ void FixShake::pre_neighbor()
atom2 = atom->map(shake_atom[i][1]);
atom3 = atom->map(shake_atom[i][2]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1) {
char str[128];
sprintf(str,"Shake atoms %d %d %d missing on proc %d at step %d",
char str[128],fstr[64];
sprintf(fstr,"Shake atoms %%d %%d %%d missing on proc %%d at step %s",
BIGINT_FORMAT);
sprintf(str,fstr,
shake_atom[i][0],shake_atom[i][1],shake_atom[i][2],
me,update->ntimestep);
error->one(str);
@ -477,8 +482,11 @@ void FixShake::pre_neighbor()
atom3 = atom->map(shake_atom[i][2]);
atom4 = atom->map(shake_atom[i][3]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1 || atom4 == -1) {
char str[128];
sprintf(str,"Shake atoms %d %d %d %d missing on proc %d at step %d",
char str[128],fstr[64];
sprintf(fstr,
"Shake atoms %%d %%d %%d %%d missing on proc %%d at step %s",
BIGINT_FORMAT);
sprintf(str,fstr,
shake_atom[i][0],shake_atom[i][1],
shake_atom[i][2],shake_atom[i][3],
me,update->ntimestep);
@ -2139,9 +2147,10 @@ void FixShake::stats()
// print stats only for non-zero counts
if (me == 0) {
char fstr[64];
sprintf(fstr,"SHAKE stats (type/ave/delta) on step %s\n",BIGINT_FORMAT);
if (screen) {
fprintf(screen,"SHAKE stats (type/ave/delta) on step %d\n",
update->ntimestep);
fprintf(screen,fstr,update->ntimestep);
for (i = 1; i < nb; i++)
if (b_count_all[i])
fprintf(screen," %d %g %g\n",i,
@ -2152,8 +2161,7 @@ void FixShake::stats()
a_ave_all[i]/a_count_all[i],a_max_all[i]-a_min_all[i]);
}
if (logfile) {
fprintf(logfile,"SHAKE stats (type/ave/delta) on step %d\n",
update->ntimestep);
fprintf(logfile,fstr,update->ntimestep);
for (i = 0; i < nb; i++)
if (b_count_all[i])
fprintf(logfile," %d %g %g\n",i,

3
src/fix_shake.h
View File

@ -21,6 +21,7 @@ FixStyle(shake,FixShake)
#define LMP_FIX_SHAKE_H
#include "fix.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -53,7 +54,7 @@ class FixShake : public Fix {
double tolerance; // SHAKE tolerance
int max_iter; // max # of SHAKE iterations
int output_every; // SHAKE stat output every so often
int next_output; // timestep for next output
bigint next_output; // timestep for next output
// settings from input command
int *bond_flag,*angle_flag; // bond/angle types to constrain

6
src/fix_tmd.cpp
View File

@ -21,6 +21,7 @@
#include "stdlib.h"
#include "string.h"
#include "fix_tmd.h"
#include "lmptype.h"
#include "atom.h"
#include "update.h"
#include "modify.h"
@ -284,8 +285,9 @@ void FixTMD::initial_integrate(int vflag)
work_lambda += lambda*(rho_target - rho_old);
if (!(update->ntimestep % nfileevery) &&
(previous_stat != update->ntimestep)) {
fprintf(fp,"%d %g %g %g %g %g %g %g\n",
update->ntimestep,rho_target,rho_old,
char fstr[64];
sprintf(fstr,"%s %%g %%g %%g %%g %%g %%g %%g\n",BIGINT_FORMAT);
fprintf(fp,fstr,update->ntimestep,rho_target,rho_old,
gamma_back,gamma_forward,lambda,work_lambda,work_analytical);
fflush(fp);
previous_stat = update->ntimestep;

3
src/fix_tmd.h
View File

@ -43,7 +43,8 @@ class FixTMD : public Fix {
private:
int me;
int nfileevery,previous_stat,compressed;
int nfileevery,compressed;
bigint previous_stat;
FILE *fp;
double rho_start,rho_stop,rho_old,masstotal;
double dtv,dtf;

5
src/fix_ttm.cpp
View File

@ -21,6 +21,7 @@
#include "string.h"
#include "stdlib.h"
#include "fix_ttm.h"
#include "lmptype.h"
#include "atom.h"
#include "force.h"
#include "update.h"
@ -525,7 +526,7 @@ void FixTTM::end_of_step()
total_nnodes,MPI_DOUBLE,MPI_SUM,world);
if (me == 0) {
fprintf(fp,"%d ",update->ntimestep);
fprintf(fp,BIGINT_FORMAT,update->ntimestep);
double T_a;
for (int ixnode = 0; ixnode < nxnodes; ixnode++)
@ -535,7 +536,7 @@ void FixTTM::end_of_step()
if (nsum_all[ixnode][iynode][iznode] > 0)
T_a = sum_mass_vsq_all[ixnode][iynode][iznode]/
(3.0*force->boltz*nsum_all[ixnode][iynode][iznode]/force->mvv2e);
fprintf(fp,"%f ",T_a);
fprintf(fp," %f",T_a);
}
fprintf(fp,"\t");

3
src/integrate.cpp
View File

@ -13,6 +13,7 @@
#include "stdlib.h"
#include "integrate.h"
#include "lmptype.h"
#include "update.h"
#include "modify.h"
#include "compute.h"
@ -93,7 +94,7 @@ void Integrate::ev_setup()
vflag = 5 or 6 = both global and per-atom virial
------------------------------------------------------------------------- */
void Integrate::ev_set(int ntimestep)
void Integrate::ev_set(bigint ntimestep)
{
int i,flag;

3
src/integrate.h
View File

@ -15,6 +15,7 @@
#define LMP_INTEGRATE_H
#include "pointers.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -42,7 +43,7 @@ class Integrate : protected Pointers {
class Compute **vlist_atom;
void ev_setup();
void ev_set(int);
void ev_set(bigint);
};
}

9
src/lmptype.h
View File

@ -61,6 +61,9 @@ typedef int64_t bigint;
#define TAGINT_FORMAT_NL "%d\n"
#define BIGINT_FORMAT_NL "%lld\n"
#define ATOTAGINT atoi
#define ATOBIGINT atoll
// for molecular problems that exceed 2 billion (2^31) atoms
// 32-bit smallint, 64-bit tagint and bigint
// NOTE: 64-bit tagint is not yet supported
@ -81,6 +84,9 @@ typedef int64_t bigint;
#define BIGINT_FORMAT "%lld"
#define TAGINT_FORMAT_NL "%lld\n"
#define BIGINT_FORMAT_NL "%lld\n"
#define ATOTAGINT atoll
#define ATOBIGINT atoll
*/
// for machines that do not support 64-bit ints
@ -102,6 +108,9 @@ typedef int bigint;
#define BIGINT_FORMAT "%d"
#define TAGINT_FORMAT_NL "%d\n"
#define BIGINT_FORMAT_NL "%d\n"
#define ATOTAGINT atoi
#define ATOBIGINT atoi
*/
}

3
src/min.cpp
View File

@ -23,6 +23,7 @@
#include "stdlib.h"
#include "string.h"
#include "min.h"
#include "lmptype.h"
#include "atom.h"
#include "domain.h"
#include "comm.h"
@ -648,7 +649,7 @@ void Min::ev_setup()
vflag = 5 or 6 = both global and per-atom virial
------------------------------------------------------------------------- */
void Min::ev_set(int ntimestep)
void Min::ev_set(bigint ntimestep)
{
int i,flag;

2
src/min.h
View File

@ -98,7 +98,7 @@ class Min : protected Pointers {
double compute_force_norm_inf();
void ev_setup();
void ev_set(int);
void ev_set(bigint);
char *stopstrings(int);
};

5
src/min_fire.cpp
View File

@ -81,15 +81,16 @@ void MinFire::reset_vectors()
int MinFire::iterate(int maxiter)
{
int ntimestep,flag,flagall;
bigint ntimestep;
double vmax,vdotf,vdotfall,vdotv,vdotvall,fdotf,fdotfall;
double scale1,scale2;
double dtvone,dtv,dtfm;
int flag,flagall;
alpha_final = 0.0;
double alpha = ALPHA0;
double dtmax = TMAX * dt;
int last_negative = update->ntimestep;
bigint last_negative = update->ntimestep;
for (int iter = 0; iter < maxiter; iter++) {
ntimestep = ++update->ntimestep;

6
src/min_quickmin.cpp
View File

@ -14,6 +14,7 @@
#include "mpi.h"
#include "math.h"
#include "min_quickmin.h"
#include "lmptype.h"
#include "universe.h"
#include "atom.h"
#include "force.h"
@ -79,12 +80,13 @@ void MinQuickMin::reset_vectors()
int MinQuickMin::iterate(int maxiter)
{
int ntimestep,flag,flagall;
bigint ntimestep;
double vmax,vdotf,vdotfall,fdotf,fdotfall,scale;
double dtvone,dtv,dtfm;
int flag,flagall;
alpha_final = 0.0;
int last_negative = update->ntimestep;
bigint last_negative = update->ntimestep;
for (int iter = 0; iter < maxiter; iter++) {
ntimestep = ++update->ntimestep;

4
src/modify.cpp
View File

@ -831,7 +831,7 @@ void Modify::clearstep_compute()
called everywhere that computes are used, after computes are invoked
------------------------------------------------------------------------- */
void Modify::addstep_compute(int newstep)
void Modify::addstep_compute(bigint newstep)
{
for (int icompute = 0; icompute < n_timeflag; icompute++)
if (compute[list_timeflag[icompute]]->invoked_flag)
@ -845,7 +845,7 @@ void Modify::addstep_compute(int newstep)
do not loop only over n_timeflag, since may not be set yet
------------------------------------------------------------------------- */
void Modify::addstep_compute_all(int newstep)
void Modify::addstep_compute_all(bigint newstep)
{
for (int icompute = 0; icompute < ncompute; icompute++)
if (compute[icompute]->timeflag) compute[icompute]->addstep(newstep);

5
src/modify.h
View File

@ -16,6 +16,7 @@
#include "stdio.h"
#include "pointers.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -88,8 +89,8 @@ class Modify : protected Pointers {
void delete_compute(char *);
int find_compute(char *);
void clearstep_compute();
void addstep_compute(int);
void addstep_compute_all(int);
void addstep_compute(bigint);
void addstep_compute_all(bigint);
void write_restart(FILE *);
int read_restart(FILE *);

51
src/neigh_bond.cpp
View File

@ -12,6 +12,7 @@
------------------------------------------------------------------------- */
#include "neighbor.h"
#include "lmptype.h"
#include "atom.h"
#include "force.h"
#include "update.h"
@ -41,9 +42,10 @@ void Neighbor::bond_all()
for (m = 0; m < num_bond[i]; m++) {
atom1 = atom->map(bond_atom[i][m]);
if (atom1 == -1) {
char str[128];
sprintf(str,"Bond atoms %d %d missing on proc %d at step %d",
tag[i],bond_atom[i][m],me,update->ntimestep);
char str[128],fstr[64];
sprintf(fstr,"Bond atoms %%d %%d missing on proc %%d at step %s",
BIGINT_FORMAT);
sprintf(str,fstr,tag[i],bond_atom[i][m],me,update->ntimestep);
error->one(str);
}
if (newton_bond || i < atom1) {
@ -80,9 +82,10 @@ void Neighbor::bond_partial()
if (bond_type[i][m] <= 0) continue;
atom1 = atom->map(bond_atom[i][m]);
if (atom1 == -1) {
char str[128];
sprintf(str,"Bond atoms %d %d missing on proc %d at step %d",
tag[i],bond_atom[i][m],me,update->ntimestep);
char str[128],fstr[64];
sprintf(fstr,"Bond atoms %%d %%d missing on proc %%d at step %s",
BIGINT_FORMAT);
sprintf(str,fstr,tag[i],bond_atom[i][m],me,update->ntimestep);
error->one(str);
}
if (newton_bond || i < atom1) {
@ -121,8 +124,10 @@ void Neighbor::angle_all()
atom2 = atom->map(angle_atom2[i][m]);
atom3 = atom->map(angle_atom3[i][m]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1) {
char str[128];
sprintf(str,"Angle atoms %d %d %d missing on proc %d at step %d",
char str[128],fstr[64];
sprintf(fstr,"Angle atoms %%d %%d %%d missing on proc %%d at step %s",
BIGINT_FORMAT);
sprintf(str,fstr,
angle_atom1[i][m],angle_atom2[i][m],angle_atom3[i][m],
me,update->ntimestep);
error->one(str);
@ -165,8 +170,10 @@ void Neighbor::angle_partial()
atom2 = atom->map(angle_atom2[i][m]);
atom3 = atom->map(angle_atom3[i][m]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1) {
char str[128];
sprintf(str,"Angle atoms %d %d %d missing on proc %d at step %d",
char str[128],fstr[64];
sprintf(fstr,"Angle atoms %%d %%d %%d missing on proc %%d at step %s",
BIGINT_FORMAT);
sprintf(str,fstr,
angle_atom1[i][m],angle_atom2[i][m],angle_atom3[i][m],
me,update->ntimestep);
error->one(str);
@ -210,8 +217,10 @@ void Neighbor::dihedral_all()
atom3 = atom->map(dihedral_atom3[i][m]);
atom4 = atom->map(dihedral_atom4[i][m]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1 || atom4 == -1) {
char str[128];
sprintf(str,"Dihedral atoms %d %d %d %d missing on proc %d at step %d",
char str[128],fstr[128];
sprintf(fstr,"Dihedral atoms %%d %%d %%d %%d "
"missing on proc %%d at step %s",BIGINT_FORMAT);
sprintf(str,fstr,
dihedral_atom1[i][m],dihedral_atom2[i][m],
dihedral_atom3[i][m],dihedral_atom4[i][m],
me,update->ntimestep);
@ -260,8 +269,10 @@ void Neighbor::dihedral_partial()
atom3 = atom->map(dihedral_atom3[i][m]);
atom4 = atom->map(dihedral_atom4[i][m]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1 || atom4 == -1) {
char str[128];
sprintf(str,"Dihedral atoms %d %d %d %d missing on proc %d at step %d",
char str[128],fstr[128];
sprintf(fstr,"Dihedral atoms %%d %%d %%d %%d "
"missing on proc %%d at step %s",BIGINT_FORMAT);
sprintf(str,fstr,
dihedral_atom1[i][m],dihedral_atom2[i][m],
dihedral_atom3[i][m],dihedral_atom4[i][m],
me,update->ntimestep);
@ -309,8 +320,10 @@ void Neighbor::improper_all()
atom3 = atom->map(improper_atom3[i][m]);
atom4 = atom->map(improper_atom4[i][m]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1 || atom4 == -1) {
char str[128];
sprintf(str,"Improper atoms %d %d %d %d missing on proc %d at step %d",
char str[128],fstr[128];
sprintf(fstr,"Improper atoms %%d %%d %%d %%d "
"missing on proc %%d at step %s",BIGINT_FORMAT);
sprintf(str,fstr,
improper_atom1[i][m],improper_atom2[i][m],
improper_atom3[i][m],improper_atom4[i][m],
me,update->ntimestep);
@ -359,8 +372,10 @@ void Neighbor::improper_partial()
atom3 = atom->map(improper_atom3[i][m]);
atom4 = atom->map(improper_atom4[i][m]);
if (atom1 == -1 || atom2 == -1 || atom3 == -1 || atom4 == -1) {
char str[128];
sprintf(str,"Improper atoms %d %d %d %d missing on proc %d at step %d",
char str[128],fstr[128];
sprintf(fstr,"Improper atoms %%d %%d %%d %%d "
"missing on proc %%d at step %s",BIGINT_FORMAT);
sprintf(str,fstr,
improper_atom1[i][m],improper_atom2[i][m],
improper_atom3[i][m],improper_atom4[i][m],
me,update->ntimestep);

24
src/output.cpp
View File

@ -148,7 +148,7 @@ void Output::init()
void Output::setup(int flag)
{
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
// perform dump at start of run if current timestep is multiple of every
// and last dump was not on this timestep
@ -239,7 +239,7 @@ void Output::setup(int flag)
do dump/restart before thermo so thermo CPU time will include them
------------------------------------------------------------------------- */
void Output::write(int ntimestep)
void Output::write(bigint ntimestep)
{
// next_dump does not force output on last step of run
// wrap dumps that invoke computes with clear/add
@ -273,7 +273,9 @@ void Output::write(int ntimestep)
char *file = new char[strlen(restart1) + 16];
char *ptr = strchr(restart1,'*');
*ptr = '\0';
sprintf(file,"%s%d%s",restart1,ntimestep,ptr+1);
char fstr[16];
sprintf(fstr,"%%s%s%%s",BIGINT_FORMAT);
sprintf(file,fstr,restart1,ntimestep,ptr+1);
*ptr = '*';
restart->write(file);
delete [] file;
@ -316,7 +318,7 @@ void Output::write(int ntimestep)
force a snapshot to be written for all dumps
------------------------------------------------------------------------- */
void Output::write_dump(int ntimestep)
void Output::write_dump(bigint ntimestep)
{
for (int idump = 0; idump < ndump; idump++) {
dump[idump]->write();
@ -328,13 +330,15 @@ void Output::write_dump(int ntimestep)
force a restart file to be written
------------------------------------------------------------------------- */
void Output::write_restart(int ntimestep)
void Output::write_restart(bigint ntimestep)
{
if (restart_toggle == 0) {
char *file = new char[strlen(restart1) + 16];
char *ptr = strchr(restart1,'*');
*ptr = '\0';
sprintf(file,"%s%d%s",restart1,ntimestep,ptr+1);
char fstr[16];
sprintf(fstr,"%%s%s%%s",BIGINT_FORMAT);
sprintf(file,fstr,restart1,ntimestep,ptr+1);
*ptr = '*';
restart->write(file);
delete [] file;
@ -373,10 +377,10 @@ void Output::add_dump(int narg, char **arg)
memory->srealloc(dump,max_dump*sizeof(Dump *),"output:dump");
every_dump = (int *)
memory->srealloc(every_dump,max_dump*sizeof(int),"output:every_dump");
next_dump = (int *)
memory->srealloc(next_dump,max_dump*sizeof(int),"output:next_dump");
last_dump = (int *)
memory->srealloc(last_dump,max_dump*sizeof(int),"output:last_dump");
next_dump = (bigint *)
memory->srealloc(next_dump,max_dump*sizeof(bigint),"output:next_dump");
last_dump = (bigint *)
memory->srealloc(last_dump,max_dump*sizeof(bigint),"output:last_dump");
var_dump = (char **)
memory->srealloc(var_dump,max_dump*sizeof(char *),"output:var_dump");
ivar_dump = (int *)

23
src/output.h
View File

@ -15,33 +15,34 @@
#define LMP_OUTPUT_H
#include "pointers.h"
#include "lmptype.h"
namespace LAMMPS_NS {
class Output : protected Pointers {
public:
int next; // next timestep for any kind of output
bigint next; // next timestep for any kind of output
int next_thermo; // next timestep for thermo output
bigint next_thermo; // next timestep for thermo output
int thermo_every; // thermo output every this many steps
int last_thermo; // last timestep thermo was output
bigint last_thermo; // last timestep thermo was output
char *var_thermo; // variable name for thermo frequency
int ivar_thermo; // variable index for thermo frequency
class Thermo *thermo; // Thermodynamic computations
int ndump; // # of Dumps defined
int max_dump; // max size of Dump list
int next_dump_any; // next timestep for any Dump
bigint next_dump_any; // next timestep for any Dump
int *every_dump; // output of each Dump every this many steps
int *next_dump; // next timestep to do each Dump
int *last_dump; // last timestep each a snapshot was output
bigint *next_dump; // next timestep to do each Dump
bigint *last_dump; // last timestep each snapshot was output
char **var_dump; // variable name for dump frequency
int *ivar_dump; // variable index for dump frequency
class Dump **dump; // list of defined Dumps
int next_restart; // next timestep to write a restart file
bigint next_restart; // next timestep to write a restart file
int restart_every; // write a restart file every this many steps
int last_restart; // last timestep a restart file was output
bigint last_restart; // last timestep a restart file was output
int restart_toggle; // 0 if use restart1 as prefix
// 1 if use restart1 as file, 2 for restart2
char *restart1,*restart2; // names for restart files
@ -51,9 +52,9 @@ class Output : protected Pointers {
~Output();
void init();
void setup(int); // initial output before run/min
void write(int); // output for current timestep
void write_dump(int); // force output of dump snapshots
void write_restart(int); // force output of a restart file
void write(bigint); // output for current timestep
void write_dump(bigint); // force output of dump snapshots
void write_restart(bigint); // force output of a restart file
void add_dump(int, char **); // add a Dump to Dump list
void modify_dump(int, char **); // modify a Dump

4
src/read_restart.cpp
View File

@ -493,9 +493,7 @@ void ReadRestart::header()
delete [] style;
} else if (flag == NTIMESTEP) {
// placeholder until ntimestep is 8-bytes
bigint ntimestep = read_bigint();
update->ntimestep = static_cast<int> (ntimestep);
update->ntimestep = read_bigint();
// set dimension from restart file

3
src/region.h
View File

@ -15,6 +15,7 @@
#define LMP_REGION_H
#include "pointers.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -60,7 +61,7 @@ class Region : protected Pointers {
char *xstr,*ystr,*zstr,*tstr;
int xvar,yvar,zvar,tvar;
double dx,dy,dz,theta;
int laststep;
bigint laststep;
void forward_transform(double &, double &, double &);
void inverse_transform(double &, double &, double &);

2
src/respa.cpp
View File

@ -445,7 +445,7 @@ void Respa::setup_minimal(int flag)
void Respa::run(int n)
{
int ntimestep;
bigint ntimestep;
for (int i = 0; i < n; i++) {

34
src/thermo.cpp
View File

@ -133,19 +133,18 @@ Thermo::Thermo(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
// format strings
format_multi = (char *) "---------------- Step %8d ----- "
"CPU = %11.4f (sec) ----------------";
char *bigint_format = BIGINT_FORMAT;
char *fformat_multi = (char *) "---------------- Step %%8%s ----- "
"CPU = %%11.4f (sec) ----------------";
sprintf(format_multi,fformat_multi,&bigint_format[1]);
format_float_one_def = (char *) "%12.8g";
format_float_multi_def = (char *) "%14.4f";
format_int_one_def = (char *) "%8d";
format_int_multi_def = (char *) "%14d";
if (sizeof(bigint) == 8) {
format_bigint_one_def = (char *) "%8ld";
format_bigint_multi_def = (char *) "%14ld";
} else if (sizeof(bigint) == 4) {
format_bigint_one_def = (char *) "%8d";
format_bigint_multi_def = (char *) "%14d";
}
sprintf(format_bigint_one_def,"%%8%s",&bigint_format[1]);
sprintf(format_bigint_multi_def,"%%14%s",&bigint_format[1]);
format_float_user = NULL;
format_int_user = NULL;
format_bigint_user = NULL;
@ -281,7 +280,7 @@ void Thermo::compute(int flag)
int i;
firststep = flag;
int ntimestep = update->ntimestep;
bigint ntimestep = update->ntimestep;
// check for lost atoms
// turn off normflag if natoms = 0 to avoid divide by 0
@ -629,11 +628,11 @@ void Thermo::parse_fields(char *str)
while (word) {
if (strcmp(word,"step") == 0) {
addfield("Step",&Thermo::compute_step,INT);
addfield("Step",&Thermo::compute_step,BIGINT);
} else if (strcmp(word,"elapsed") == 0) {
addfield("Elapsed",&Thermo::compute_elapsed,INT);
addfield("Elapsed",&Thermo::compute_elapsed,BIGINT);
} else if (strcmp(word,"elaplong") == 0) {
addfield("Elaplong",&Thermo::compute_elapsed_long,INT);
addfield("Elaplong",&Thermo::compute_elapsed_long,BIGINT);
} else if (strcmp(word,"dt") == 0) {
addfield("Dt",&Thermo::compute_dt,FLOAT);
} else if (strcmp(word,"cpu") == 0) {
@ -942,7 +941,6 @@ int Thermo::evaluate_keyword(char *word, double *answer)
if (strcmp(word,"step") == 0) {
compute_step();
dvalue = ivalue;
} else if (strcmp(word,"elapsed") == 0) {
if (update->whichflag == 0)
@ -1356,27 +1354,27 @@ void Thermo::compute_variable()
one method for every keyword thermo can output
called by compute() or evaluate_keyword()
compute will have already been called
set ivalue/dvalue if value is integer/double
set ivalue/dvalue/bivalue if value is int/double/bigint
customize a new keyword by adding a method
------------------------------------------------------------------------- */
void Thermo::compute_step()
{
ivalue = update->ntimestep;
bivalue = update->ntimestep;
}
/* ---------------------------------------------------------------------- */
void Thermo::compute_elapsed()
{
ivalue = update->ntimestep - update->firststep;
bivalue = update->ntimestep - update->firststep;
}
/* ---------------------------------------------------------------------- */
void Thermo::compute_elapsed_long()
{
ivalue = update->ntimestep - update->beginstep;
bivalue = update->ntimestep - update->beginstep;
}
/* ---------------------------------------------------------------------- */

6
src/thermo.h
View File

@ -46,11 +46,11 @@ class Thermo : protected Pointers {
int *vtype;
char **format,**format_user;
char *format_multi;
char *format_float_one_def,*format_float_multi_def;
char *format_int_one_def,*format_int_multi_def;
char *format_bigint_one_def,*format_bigint_multi_def;
char *format_float_user,*format_int_user,*format_bigint_user;
char format_multi[128];
char format_bigint_one_def[8],format_bigint_multi_def[8];
int normvalue; // use this for normflag unless natoms = 0
int normuserflag; // 0 if user has not set, 1 if has
@ -62,7 +62,7 @@ class Thermo : protected Pointers {
double last_tpcpu,last_spcpu;
double last_time;
int last_step;
bigint last_step;
bigint natoms;

3
src/update.cpp
View File

@ -278,8 +278,9 @@ void Update::reset_timestep(int narg, char **arg)
for (int i = 0; i < modify->ncompute; i++)
if (modify->compute[i]->timeflag) modify->compute[i]->clearstep();
ntimestep = atoi(arg[0]);
ntimestep = ATOBIGINT(arg[0]);
if (ntimestep < 0) error->all("Timestep must be >= 0");
if (ntimestep > MAXBIGINT) error->all("Too big a timestep");
}
/* ----------------------------------------------------------------------

11
src/update.h
View File

@ -15,6 +15,7 @@
#define LMP_UPDATE_H
#include "pointers.h"
#include "lmptype.h"
namespace LAMMPS_NS {
@ -22,19 +23,19 @@ class Update : protected Pointers {
public:
double dt; // timestep
double etol,ftol; // minimizer tolerances on energy/force
int ntimestep; // current step (dynamics or min iterations)
bigint ntimestep; // current step (dynamics or min iterations)
int nsteps; // # of steps to run (dynamics or min iter)
int whichflag; // 0 for unset, 1 for dynamics, 2 for min
int firststep,laststep; // 1st & last step of this run
int beginstep,endstep; // 1st and last step of multiple runs
bigint firststep,laststep; // 1st & last step of this run
bigint beginstep,endstep; // 1st and last step of multiple runs
int first_update; // 0 before initial update, 1 after
int max_eval; // max force evaluations for minimizer
int restrict_output; // 1 if output should not write dump/restart
int setupflag; // set when setup() is computing forces
int multireplica; // 1 if min across replicas, else 0
int eflag_global,eflag_atom; // timestep global/peratom eng is tallied on
int vflag_global,vflag_atom; // ditto for virial
bigint eflag_global,eflag_atom; // timestep global/peratom eng is tallied on
bigint vflag_global,vflag_atom; // ditto for virial
char *unit_style;

3
src/verlet.cpp
View File

@ -188,7 +188,8 @@ void Verlet::setup_minimal(int flag)
void Verlet::run(int n)
{
int nflag,ntimestep,sortflag;
bigint ntimestep;
int nflag,sortflag;
int n_post_integrate = modify->n_post_integrate;
int n_pre_exchange = modify->n_pre_exchange;

8
src/write_restart.cpp
View File

@ -86,7 +86,9 @@ void WriteRestart::command(int narg, char **arg)
if (ptr = strchr(arg[0],'*')) {
*ptr = '\0';
sprintf(file,"%s%d%s",arg[0],update->ntimestep,ptr+1);
char fstr[16];
sprintf(fstr,"%%s%s%%s",BIGINT_FORMAT);
sprintf(file,fstr,arg[0],update->ntimestep,ptr+1);
} else strcpy(file,arg[0]);
// init entire system since comm->exchange is done
@ -300,9 +302,7 @@ void WriteRestart::header()
write_int(TAGINT,sizeof(tagint));
write_int(BIGINT,sizeof(bigint));
write_char(UNITS,update->unit_style);
// placeholder until ntimestep is 8-byte
bigint ntimestep = update->ntimestep;
write_bigint(NTIMESTEP,ntimestep);
write_bigint(NTIMESTEP,update->ntimestep);
write_int(DIMENSION,domain->dimension);
write_int(NPROCS,nprocs);
write_int(PROCGRID_0,comm->procgrid[0]);