/* Increment loop counter */
teller++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
sfree(x);
if (top)
{
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, nat, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, nat);
}
for (i = 0; i < nat; i++)
}
nfr++;
}
- while (read_next_x(oenv, status, &t, nat, xread, box));
+ while (read_next_x(oenv, status, &t, xread, box));
close_trx(status);
sfree(x);
if (filterfile)
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm),
title, &top, &ePBC, &xtop, NULL, topbox, bM);
atoms = &top.atoms;
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, atoms->nr, topbox);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, atoms->nr);
gmx_rmpbc(gpbc, atoms->nr, topbox, xtop);
/* Fitting is only required for the projection */
if (bProj && bFit1)
fprintf(outd, "\n");
}
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (fdist)
}
read_first_frame(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &fr, TRX_NEED_X);
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms, fr.box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
do
{
}
i++;
}
- while (read_next_x(oenv, status, &t, natom, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "Allocated %lu bytes for frames\n",
(unsigned long) (max_nf*isize*sizeof(**xx)));
fprintf(stderr, "Read %d frames from trajectory %s\n", i0, fn);
TRUE);
if (bPBC)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
}
fprintf(stderr, "\nSelect group for least squares fit%s:\n",
/* Prepare reference frame */
if (bPBC)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, atoms->nr, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, atoms->nr);
gmx_rmpbc(gpbc, atoms->nr, box, xref);
}
if (bFit)
rvec_inc(xav[i], xread[index[i]]);
}
}
- while (read_next_x(oenv, status, &t, nat, xread, box));
+ while (read_next_x(oenv, status, &t, xread, box));
close_trj(status);
inv_nframes = 1.0/nframes0;
}
}
}
- while (read_next_x(oenv, status, &t, nat, xread, box) &&
+ while (read_next_x(oenv, status, &t, xread, box) &&
(bRef || nframes < nframes0));
close_trj(status);
gmx_rmpbc_done(gpbc);
clear_rvec(mjd_tmp);
clear_rvec(mdvec);
clear_rvec(tmp);
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms, fr.box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
do
{
snew((*slDensity)[i], *nslices);
}
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr);
/*********** Start processing trajectory ***********/
do
{
}
nr_frames++;
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
gmx_rmpbc_done(gpbc);
/*********** done with status file **********/
snew((*slDensity)[i], *nslices);
}
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr);
/*********** Start processing trajectory ***********/
do
{
}
nr_frames++;
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
gmx_rmpbc_done(gpbc);
/*********** done with status file **********/
}
nfr++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
/* normalize gridpoints */
/****Start trajectory processing***/
/*Initialize Densdevel and PBC-remove*/
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr);
*Densdevel = NULL;
}
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
/*Free memory we no longer need and exit.*/
gkrbin = mk_gkrbin(rcut, rcmax, bPhi, ndegrees);
}
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natom, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natom);
/* Start while loop over frames */
t1 = t0 = t;
}
else
{
- bCont = read_next_x(oenv, status, &t, natom, x, box);
+ bCont = read_next_x(oenv, status, &t, x, box);
}
timecheck = check_times(t);
}
init_nrnb(&nrnb);
if (ir.ePBC != epbcNONE)
{
- gpbc = gmx_rmpbc_init(&top->idef, ir.ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ir.ePBC, natoms);
}
j = 0;
}
j++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (ir.ePBC != epbcNONE)
{
pbc = NULL;
}
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
/* initialisation for correct distance calculations */
teller++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
if (!bCutoff)
accr = NULL;
naccr = 0;
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
t = output_env_conv_time(oenv, t);
remove(pdbfile);
nframe++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
close_trj(status);
if (fTArea)
&xtop, NULL, topbox, TRUE);
if (bTop)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr, topbox);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, topbox, xtop);
}
}
x[nffr - 1] = ptr;
fr++;
}
- while (read_next_x(oenv, in, &(t[nffr - 1]), nat, x[nffr - 1], box[nffr - 1]));
+ while (read_next_x(oenv, in, &(t[nffr - 1]), x[nffr - 1], box[nffr - 1]));
if (bTop)
{
}
if (bTRX)
{
- if (!read_next_x(oenv, status, &t, natoms, xx, boxx) &&
+ if (!read_next_x(oenv, status, &t, xx, boxx) &&
((i+1)*(j+1)*(k+1) < vol))
{
gmx_fatal(FARGS, "Not enough frames in trajectory");
}
if (nz == 0)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
}
do
{
}
j++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (nz == 0)
{
teller = 0;
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
/*********** Start processing trajectory ***********/
do
{
}
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
/*********** done with status file **********/
fprintf(stderr, "\nRead trajectory. Printing parameters to file\n");
#pragma omp single
{
- trrStatus = (read_next_x(oenv, status, &t, natoms, x, box));
+ trrStatus = (read_next_x(oenv, status, &t, x, box));
nframes++;
}
pr_bb(stdout, nres, bb);
}
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
snew(xav, natoms);
teller = 0;
}
}
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
gmx_rmpbc_done(gpbc);
unitaxes[1][1] = 1;
unitaxes[2][2] = 1;
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
teller++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
snew(skmol, maxidx);
/* Must init pbc every step because of pressure coupling */
- set_pbc(&pbc,ePBC,box);
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ set_pbc(&pbc, ePBC, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
gmx_rmpbc(gpbc, natoms, box, x);
*sgmean = 0.0;
}
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
sfree(grpname);
rlo.r = 1.0, rlo.g = 1.0, rlo.b = 1.0;
rhi.r = 0.0, rhi.g = 0.0, rhi.b = 0.0;
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, trxnat, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, trxnat);
if (bFrames)
{
nres, nres, resnr, resnr, mdmat, 0, truncate, rlo, rhi, &nlevels);
}
}
- while (read_next_x(oenv, status, &t, trxnat, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
close_trj(status);
gmx_rmpbc_done(gpbc);
if (NULL != top)
{
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
}
bFirst = TRUE;
output_env_conv_time(oenv, t), rmin, rmax, norm(box[0]), norm(box[1]), norm(box[2]));
bFirst = FALSE;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
if (NULL != top)
{
fprintf(respertime, "\n");
}
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
close_trj(status);
ffclose(dist);
if (bMol)
{
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
}
/* the loop over all frames */
curr->nframes++;
}
- while (read_next_x(oenv, status, &t, natoms, x[cur], box));
+ while (read_next_x(oenv, status, &t, x[cur], box));
fprintf(stderr, "\nUsed %d restart points spaced %g %s over %g %s\n\n",
curr->nrestart,
output_env_conv_time(oenv, dt), output_env_get_time_unit(oenv),
oenv);
/* loop over frames */
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
nframes = 0;
do
{
fprintf(fpsk, "%f %f\n", t, sk);
nframes++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
gmx_rmpbc_done(gpbc);
teller = 0;
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
/*********** Start processing trajectory ***********/
do
{
nr_frames++;
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
/*********** done with status file **********/
fprintf(stderr, "\nRead trajectory. Printing parameters to file\n");
sum_gyro_tot = 0;
sum_pers_tot = 0;
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
frame++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
}
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
/*********** Start processing trajectory ***********/
do
}
nr_frames++;
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
gmx_rmpbc_done(gpbc);
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
fprintf(axis3, "%15.10f %15.10f %15.10f %15.10f\n", t, axes[XX][ZZ], axes[YY][ZZ], axes[ZZ][ZZ]);
fprintf(fmoi, "%15.10f %15.10f %15.10f %15.10f\n", t, moi[XX], moi[YY], moi[ZZ]);
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
invvol_sum = 0;
if (bPBC && (NULL != top))
{
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
}
do
}
nframes++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
if (bPBC && (NULL != top))
/* Prepare reference frame */
if (bPBC)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, box, xp);
}
if (bReset)
}
}
}
- while (read_next_x(oenv, status, &t, natoms_trx, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFile2)
srenew(time2, maxframe2);
}
}
- while (read_next_x(oenv, status, &t, natoms_trx2, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
}
else
rmsnow = rms_diff(isize, d, d_r);
fprintf(fp, "%g %g\n", t, rmsnow);
}
- while (read_next_x(oenv, status, &t, natom, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
ffclose(fp);
if (bFit)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natom, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natom);
}
/* Now read the trj again to compute fluctuations */
count += 1.0;
teller++;
}
- while (read_next_x(oenv, status, &t, natom, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (bFit)
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
snew(x_s, natoms);
- gpbc = gmx_rmpbc_init(&(top->idef), ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&(top->idef), ePBC, natoms);
/* Start the loop over frames */
t1 = t0 = t;
/* Increment loop counter */
teller++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
fprintf(stderr, "\nDone with trajectory\n");
w_rls[a] = (bMW ? top->atoms.atom[index[a]].m : 1.0);
tot_mass += w_rls[a];
}
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
}
nfr_all++;
}
- while (read_next_x(oenv, status, &ti[nfr], natoms, x, box));
+ while (read_next_x(oenv, status, &ti[nfr], x, box));
close_trj(status);
sfree(x);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &x_ref, NULL, box, bMW);
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
gmx_rmpbc(gpbc, top.atoms.nr, box, x_ref);
R[YY][XX], R[YY][YY], R[YY][ZZ],
R[ZZ][XX], R[ZZ][YY], R[ZZ][ZZ]);
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
teller++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
close_trj(status);
/* Prepare reference frame */
if (bPBC)
{
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, top->atoms.nr);
gmx_rmpbc(gpbc, top->atoms.nr, box, x);
}
sfree(sqframecurrent->s);
sfree(sqframecurrent);
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
/* normalize histo */
if (bPBC)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
}
nfr = 0;
}
nfr++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
if (bPBC)
{
distance2; /* same for second of two atoms */
t_trxstatus *status;
int natoms, teller = 0;
- rvec *x0; /* coordinates, and coordinates corrected for pb */
+ rvec *x0; /* coordinates, and coordinates corrected for pb */
matrix box;
- char buf[256]; /* for xvgr title */
- gmx_rmpbc_t gpbc = NULL;
- const char* aleg[2] = { "cos(Angle)", "Angle (degrees)" }; /* legends for sg_angle output file */
+ char buf[256]; /* for xvgr title */
+ gmx_rmpbc_t gpbc = NULL;
+ const char* aleg[2] = { "cos(Angle)", "Angle (degrees)" }; /* legends for sg_angle output file */
if ((natoms = read_first_x(oenv, &status, fn, &t, &x0, box)) == 0)
{
sg_distance2 = xvgropen(d2file, buf, "Time (ps", "Distance (nm)", oenv);
}
- gpbc = gmx_rmpbc_init(&(top->idef), ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&(top->idef), ePBC, natoms);
do
{
}
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
gmx_rmpbc_done(gpbc);
}
snew(xzero, natoms);
- gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
}
}
- while (read_next_x(oenv, status, &t, natoms, x0, box));
+ while (read_next_x(oenv, status, &t, x0, box));
gmx_rmpbc_done(gpbc);
fprintf(stderr, "\n");
if (bTPS)
{
/* make molecules whole again */
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
}
/* start analysis of trajectory */
do
nf++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
/* clean up */
sfree(x);
if (bPBC)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
}
/* This is the main loop over frames */
do
molindex = top->mols.index;
atom = top->atoms.atom;
- gpbc = gmx_rmpbc_init(&top->idef, ir->ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top->idef, ir->ePBC, natoms);
/* start analysis of trajectory */
do
nf++;
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
if (bCom && bPBC)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms, fr.box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
}
do
}
if (bRmPBC)
{
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr, top_box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, top.atoms.nr);
}
}
}
out = open_trx(opt2fn("-o", NFILE, fnm), "w");
}
- gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms, box);
+ gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
gmx_rmpbc(gpbc, natoms, box, x);
write_trx(out, natoms, swi, &top.atoms, 0, t, box, x, NULL, NULL);
}
}
- while (read_next_x(oenv, status, &t, natoms, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (out)
{
nfr++;
}
- while (read_next_x(oenv, status, &t, natom, x, box));
+ while (read_next_x(oenv, status, &t, x, box));
/* clean up */
sfree(x);
if (mpin != NULL)
{
- inp = read_inpfile(mpin, &ninp, NULL, wi);
+ inp = read_inpfile(mpin, &ninp, wi);
}
else
{
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
const real one = 1.0;
const real two = 2.0;
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
const real three = 3.0;
const real two = 2.0;
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
int *global_atom_index)
{
const real half = 0.5;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ki, ai, aj, type;
real dr, dr2, fbond, vbond, fij, vtot;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ki, ai, aj, type;
real dr, dr2, fbond, vbond, fij, vtot;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ki, ai, aj, type;
real dr, dr2, fbond, vbond, fij, vtot, ksh;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ki, ai, aj, type;
real dr, dr2, fbond, vbond, fij, vtot, ksh, khyp, drcut, ddr, ddr3;
real water_pol(int nbonds,
const t_iatom forceatoms[], const t_iparams forceparams[],
- const rvec x[], rvec f[], rvec fshift[],
- const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const rvec x[], rvec f[], rvec gmx_unused fshift[],
+ const t_pbc gmx_unused *pbc, const t_graph gmx_unused *g,
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
/* This routine implements anisotropic polarizibility for water, through
* a shell connected to a dummy with spring constant that differ in the
real thole_pol(int nbonds,
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[], rvec fshift[],
- const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_pbc *pbc, const t_graph gmx_unused *g,
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
/* Interaction between two pairs of particles with opposite charge */
int i, type, a1, da1, a2, da2;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, ai, aj, ak, t1, t2, type;
rvec r_ij, r_kj;
angles_noener_simd(int nbonds,
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[],
- const t_pbc *pbc, const t_graph *g,
- real lambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_pbc *pbc, const t_graph gmx_unused *g,
+ real gmx_unused lambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
#define UNROLL GMX_SIMD_WIDTH_HERE
const int nfa1 = 4;
dr = gmx_simd_align_real(dr_array);
f_buf = gmx_simd_align_real(f_buf_array);
- set_pbc_simd(pbc,&pbc_simd);
+ set_pbc_simd(pbc, &pbc_simd);
one_S = gmx_set1_pr(1.0);
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ai, aj, ak, t1, t2, type;
rvec f_i, f_j, f_k;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ai, aj, ak, t1, t2, type, ki;
rvec r_ij, r_kj, r_ik;
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, j, ai, aj, ak, t1, t2, type;
rvec r_ij, r_kj;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, type, ai, aj, ak, al;
int t1, t2, t3;
pdihs_noener(int nbonds,
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[],
- const t_pbc *pbc, const t_graph *g,
+ const t_pbc gmx_unused *pbc, const t_graph gmx_unused *g,
real lambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, type, ai, aj, ak, al;
int t1, t2, t3;
pdihs_noener_simd(int nbonds,
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[],
- const t_pbc *pbc, const t_graph *g,
- real lambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_pbc *pbc, const t_graph gmx_unused *g,
+ real gmx_unused lambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
#define UNROLL GMX_SIMD_WIDTH_HERE
- const int nfa1 = 5;
- int i, iu, s;
- int type, ai[UNROLL], aj[UNROLL], ak[UNROLL], al[UNROLL];
- int t1[UNROLL], t2[UNROLL], t3[UNROLL];
- real ddphi;
- real dr_array[3*DIM*UNROLL+UNROLL], *dr;
- real buf_array[7*UNROLL+UNROLL], *buf;
+ const int nfa1 = 5;
+ int i, iu, s;
+ int type, ai[UNROLL], aj[UNROLL], ak[UNROLL], al[UNROLL];
+ int t1[UNROLL], t2[UNROLL], t3[UNROLL];
+ real ddphi;
+ real dr_array[3*DIM*UNROLL+UNROLL], *dr;
+ real buf_array[7*UNROLL+UNROLL], *buf;
real *cp, *phi0, *mult, *phi, *p, *q, *sf_i, *msf_l;
- gmx_mm_pr phi0_S, phi_S;
- gmx_mm_pr mx_S, my_S, mz_S;
- gmx_mm_pr nx_S, ny_S, nz_S;
- gmx_mm_pr nrkj_m2_S, nrkj_n2_S;
- gmx_mm_pr cp_S, mdphi_S, mult_S;
- gmx_mm_pr sin_S, cos_S;
- gmx_mm_pr mddphi_S;
- gmx_mm_pr sf_i_S, msf_l_S;
- pbc_simd_t pbc_simd;
+ gmx_mm_pr phi0_S, phi_S;
+ gmx_mm_pr mx_S, my_S, mz_S;
+ gmx_mm_pr nx_S, ny_S, nz_S;
+ gmx_mm_pr nrkj_m2_S, nrkj_n2_S;
+ gmx_mm_pr cp_S, mdphi_S, mult_S;
+ gmx_mm_pr sin_S, cos_S;
+ gmx_mm_pr mddphi_S;
+ gmx_mm_pr sf_i_S, msf_l_S;
+ pbc_simd_t pbc_simd;
/* Ensure SIMD register alignment */
dr = gmx_simd_align_real(dr_array);
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, type, ai, aj, ak, al;
int t1, t2, t3;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
return low_angres(nbonds, forceatoms, forceparams, x, f, fshift, pbc, g,
lambda, dvdlambda, FALSE);
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
return low_angres(nbonds, forceatoms, forceparams, x, f, fshift, pbc, g,
lambda, dvdlambda, TRUE);
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
real vtot = 0;
int ai, aj, ak, al, i, k, type, t1, t2, t3;
}
-real unimplemented(int nbonds,
- const t_iatom forceatoms[], const t_iparams forceparams[],
- const rvec x[], rvec f[], rvec fshift[],
- const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+real unimplemented(int gmx_unused nbonds,
+ const t_iatom gmx_unused forceatoms[], const t_iparams gmx_unused forceparams[],
+ const rvec gmx_unused x[], rvec gmx_unused f[], rvec gmx_unused fshift[],
+ const t_pbc gmx_unused *pbc, const t_graph gmx_unused *g,
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
gmx_impl("*** you are using a not implemented function");
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
const real c0 = 0.0, c1 = 1.0, c2 = 2.0, c3 = 3.0, c4 = 4.0, c5 = 5.0;
int type, ai, aj, ak, al, i, j;
const gmx_cmap_t *cmap_grid,
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, j, k, n, idx;
int ai, aj, ak, al, am;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ki, ai, aj, type;
real dr2, fbond, vbond, fij, vtot;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
int i, ai, aj, ak, type, m, t1, t2;
rvec r_ij, r_kj;
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
/* Potential from Lawrence and Skimmer, Chem. Phys. Lett. 372 (2003)
* pp. 842-847
const t_iatom forceatoms[], const t_iparams forceparams[],
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata gmx_unused *fcd,
+ int gmx_unused *global_atom_index)
{
/* Potential from Lawrence and Skimmer, Chem. Phys. Lett. 372 (2003)
* pp. 842-847
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata *fcd,
+ int gmx_unused *global_atom_index)
{
int i, m, ki, ai, aj, type, table;
real dr, dr2, fbond, vbond, fij, vtot;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata *fcd,
+ int gmx_unused *global_atom_index)
{
int i, ai, aj, ak, t1, t2, type, table;
rvec r_ij, r_kj;
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ const t_mdatoms gmx_unused *md, t_fcdata *fcd,
+ int gmx_unused *global_atom_index)
{
int i, type, ai, aj, ak, al, table;
int t1, t2, t3;
rvec x[], rvec f[], rvec fshift[],
t_forcerec *fr,
const t_pbc *pbc, const t_graph *g,
- gmx_enerdata_t *enerd, gmx_grppairener_t *grpp,
+ gmx_enerdata_t gmx_unused *enerd, gmx_grppairener_t *grpp,
t_nrnb *nrnb,
real *lambda, real *dvdl,
const t_mdatoms *md, t_fcdata *fcd,
to reduce duplication.
*/
-static real calc_one_bond_foreign(FILE *fplog, int ftype, const t_idef *idef,
+static real calc_one_bond_foreign(FILE gmx_unused *fplog, int ftype, const t_idef *idef,
rvec x[], rvec f[], t_forcerec *fr,
const t_pbc *pbc, const t_graph *g,
gmx_grppairener_t *grpp, t_nrnb *nrnb,
real *lambda, real *dvdl,
const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index, gmx_bool bPrintSepPot)
+ int *global_atom_index, gmx_bool gmx_unused bPrintSepPot)
{
int ind, nat1, nbonds, efptFTYPE, nbonds_np;
real v = 0;
real *lambda,
const t_mdatoms *md,
t_fcdata *fcd, int *global_atom_index,
- t_atomtypes *atype, gmx_genborn_t *born,
+ t_atomtypes gmx_unused *atype, gmx_genborn_t gmx_unused *born,
int force_flags,
gmx_bool bPrintSepPot, gmx_large_int_t step)
{
*rcoul2 = sqrt(r2c2);
}
-void calc_cgcm(FILE *fplog, int cg0, int cg1, t_block *cgs,
+void calc_cgcm(FILE gmx_unused *fplog, int cg0, int cg1, t_block *cgs,
rvec pos[], rvec cg_cm[])
{
int icg, k, k0, k1, d;
}
}
-void put_charge_groups_in_box(FILE *fplog, int cg0, int cg1,
+void put_charge_groups_in_box(FILE gmx_unused *fplog, int cg0, int cg1,
int ePBC, matrix box, t_block *cgs,
rvec pos[], rvec cg_cm[])
bool_t res = 0;
char buf[STEPSTRSIZE];
- res = xdr_gmx_large_int(xd, i, "reading checkpoint file");
+ res = xdr_gmx_large_int(xd, i);
if (res == 0)
{
cp_error();
}
}
-static void do_cpt_real_err(XDR *xd, const char *desc, real *f)
+static void do_cpt_real_err(XDR *xd, real *f)
{
bool_t res = 0;
{
for (j = 0; j < DIM; j++)
{
- do_cpt_real_err(xd, desc, &f[i][j]);
+ do_cpt_real_err(xd, &f[i][j]);
}
}
}
}
-static int do_cpt_footer(XDR *xd, gmx_bool bRead, int file_version)
+static int do_cpt_footer(XDR *xd, int file_version)
{
bool_t res = 0;
int magic;
return 0;
}
-static int do_cpt_state(XDR *xd, gmx_bool bRead,
- int fflags, t_state *state,
+static int do_cpt_state(XDR *xd, int fflags, t_state *state,
gmx_bool bReadRNG, FILE *list)
{
int sflags;
return ret;
}
-static int do_cpt_ekinstate(XDR *xd, gmx_bool bRead,
- int fflags, ekinstate_t *ekins,
+static int do_cpt_ekinstate(XDR *xd, int fflags, ekinstate_t *ekins,
FILE *list)
{
int i;
return ret;
}
-static int do_cpt_df_hist(XDR *xd, gmx_bool bRead, int fflags, df_history_t *dfhist, FILE *list)
+static int do_cpt_df_hist(XDR *xd, int fflags, df_history_t *dfhist, FILE *list)
{
int i, nlambda;
int ret;
sfree(bhost);
sfree(fprog);
- if ((do_cpt_state(gmx_fio_getxdr(fp), FALSE, state->flags, state, TRUE, NULL) < 0) ||
- (do_cpt_ekinstate(gmx_fio_getxdr(fp), FALSE, flags_eks, &state->ekinstate, NULL) < 0) ||
+ if ((do_cpt_state(gmx_fio_getxdr(fp), state->flags, state, TRUE, NULL) < 0) ||
+ (do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL) < 0) ||
(do_cpt_enerhist(gmx_fio_getxdr(fp), FALSE, flags_enh, &state->enerhist, NULL) < 0) ||
- (do_cpt_df_hist(gmx_fio_getxdr(fp), FALSE, flags_dfh, &state->dfhist, NULL) < 0) ||
+ (do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL) < 0) ||
(do_cpt_EDstate(gmx_fio_getxdr(fp), FALSE, &state->edsamstate, NULL) < 0) ||
(do_cpt_files(gmx_fio_getxdr(fp), FALSE, &outputfiles, &noutputfiles, NULL,
file_version) < 0))
gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
}
- do_cpt_footer(gmx_fio_getxdr(fp), FALSE, file_version);
+ do_cpt_footer(gmx_fio_getxdr(fp), file_version);
/* we really, REALLY, want to make sure to physically write the checkpoint,
and all the files it depends on, out to disk. Because we've
cr, bPartDecomp, nppnodes_f, npmenodes_f, dd_nc, dd_nc_f);
}
}
- ret = do_cpt_state(gmx_fio_getxdr(fp), TRUE, fflags, state, *bReadRNG, NULL);
+ ret = do_cpt_state(gmx_fio_getxdr(fp), fflags, state, *bReadRNG, NULL);
*init_fep_state = state->fep_state; /* there should be a better way to do this than setting it here.
Investigate for 5.0. */
if (ret)
{
cp_error();
}
- ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), TRUE,
- flags_eks, &state->ekinstate, NULL);
+ ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL);
if (ret)
{
cp_error();
state->enerhist.nsum_sim = *step;
}
- ret = do_cpt_df_hist(gmx_fio_getxdr(fp), TRUE,
- flags_dfh, &state->dfhist, NULL);
+ ret = do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL);
if (ret)
{
cp_error();
cp_error();
}
- ret = do_cpt_footer(gmx_fio_getxdr(fp), TRUE, file_version);
+ ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
if (ret)
{
cp_error();
&(state->dfhist.nlambda), &state->flags, &flags_eks, &flags_enh, &flags_dfh,
&state->edsamstate.nED, NULL);
ret =
- do_cpt_state(gmx_fio_getxdr(fp), TRUE, state->flags, state, bReadRNG, NULL);
+ do_cpt_state(gmx_fio_getxdr(fp), state->flags, state, bReadRNG, NULL);
if (ret)
{
cp_error();
}
- ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), TRUE,
- flags_eks, &state->ekinstate, NULL);
+ ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL);
if (ret)
{
cp_error();
{
cp_error();
}
- ret = do_cpt_df_hist(gmx_fio_getxdr(fp), TRUE,
- flags_dfh, &state->dfhist, NULL);
+ ret = do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL);
if (ret)
{
cp_error();
cp_error();
}
- ret = do_cpt_footer(gmx_fio_getxdr(fp), TRUE, file_version);
+ ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
if (ret)
{
cp_error();
&state.natoms, &state.ngtc, &state.nnhpres, &state.nhchainlength,
&(state.dfhist.nlambda), &state.flags,
&flags_eks, &flags_enh, &flags_dfh, &state.edsamstate.nED, out);
- ret = do_cpt_state(gmx_fio_getxdr(fp), TRUE, state.flags, &state, TRUE, out);
+ ret = do_cpt_state(gmx_fio_getxdr(fp), state.flags, &state, TRUE, out);
if (ret)
{
cp_error();
}
- ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), TRUE,
- flags_eks, &state.ekinstate, out);
+ ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state.ekinstate, out);
if (ret)
{
cp_error();
if (ret == 0)
{
init_df_history(&state.dfhist, state.dfhist.nlambda, 0); /* reinitialize state with correct sizes */
- ret = do_cpt_df_hist(gmx_fio_getxdr(fp), TRUE,
- flags_dfh, &state.dfhist, out);
+ ret = do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state.dfhist, out);
}
if (ret == 0)
if (ret == 0)
{
- ret = do_cpt_footer(gmx_fio_getxdr(fp), TRUE, file_version);
+ ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
}
if (ret)
real ta_disres(int nfa, const t_iatom forceatoms[], const t_iparams ip[],
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata *fcd,
+ int gmx_unused *global_atom_index)
{
const real sixth = 1.0/6.0;
const real seven_three = 7.0/3.0;
-real ewald_LRcorrection(FILE *fplog,
- int start, int end,
+real ewald_LRcorrection(int start, int end,
t_commrec *cr, int thread, t_forcerec *fr,
real *chargeA, real *chargeB,
gmx_bool calc_excl_corr,
/* FW decl. */
void limit_num_gpus_used(gmx_hw_info_t *hwinfo, int count);
-static void sprint_gpus(char *sbuf, const gmx_gpu_info_t *gpu_info, gmx_bool bPrintAll)
+static void sprint_gpus(char *sbuf, const gmx_gpu_info_t *gpu_info)
{
int i, ndev;
char stmp[STRLEN];
if (ngpu > 0)
{
- sprint_gpus(stmp, gpu_info, TRUE);
+ sprint_gpus(stmp, gpu_info);
md_print_warn(cr, fplog, "%d GPU%s detected%s:\n%s\n",
ngpu, (ngpu > 1) ? "s" : "", onhost, stmp);
}
}
}
-static void parse_gpu_id_csv_string(const char *idstr, int *nid, int *idlist)
-{
- /* XXX implement cvs format to support more than 10 different GPUs in a box. */
- gmx_incons("Not implemented yet");
-}
-
void gmx_check_hw_runconf_consistency(FILE *fplog, gmx_hw_info_t *hwinfo,
const t_commrec *cr, int ntmpi_requested,
gmx_bool bUseGPU)
* We assume that this is equal with the number of CPUs reported to be
* online by the OS at the time of the call.
*/
-static int get_nthreads_hw_avail(FILE *fplog, const t_commrec *cr)
+static int get_nthreads_hw_avail(FILE gmx_unused *fplog, const t_commrec gmx_unused *cr)
{
int ret = 0;
int nthreads_hw_avail,
int omp_nthreads_req,
int omp_nthreads_pme_req,
- gmx_bool bThisNodePMEOnly,
+ gmx_bool gmx_unused bThisNodePMEOnly,
gmx_bool bFullOmpSupport)
{
int nth, nth_pmeonly, gmx_maxth, nppn;
gmx_set_thread_affinity(FILE *fplog,
const t_commrec *cr,
gmx_hw_opt_t *hw_opt,
- int nthreads_pme,
- const gmx_hw_info_t *hwinfo,
- const t_inputrec *inputrec)
+ const gmx_hw_info_t *hwinfo)
{
int nth_affinity_set, thread_id_node, thread_id,
nthread_local, nthread_node, nthread_hw_max, nphyscore;
/* check the number of items given against the type */
-void gmx_fio_check_nitem(t_fileio *fio, int eio, int nitem, const char *file,
- int line)
+void gmx_fio_check_nitem(int eio, int nitem, const char *file, int line)
{
if ((nitem != 1) && !((eio == eioNRVEC) || (eio == eioNUCHAR)))
{
return 0;
}
-int gmx_fio_check_file_position(t_fileio *fio)
+int gmx_fio_check_file_position(t_fileio gmx_unused *fio)
{
/* If gmx_off_t is 4 bytes we can not store file offset > 2 GB.
* If we do not have ftello, we will play it safe.
-static gmx_bool do_dummyread(t_fileio *fio, void *item, int nitem, int eio,
- const char *desc, const char *srcfile, int line)
+static gmx_bool do_dummyread(t_fileio gmx_unused *fio, void gmx_unused *item, int gmx_unused nitem, int gmx_unused eio,
+ const char gmx_unused *desc, const char gmx_unused *srcfile, int gmx_unused line)
{
gmx_fatal(FARGS, "File type not set!");
return FALSE;
}
-static gmx_bool do_dummywrite(t_fileio *fio, const void *item, int nitem, int eio,
- const char *desc, const char *srcfile, int line)
+static gmx_bool do_dummywrite(t_fileio gmx_unused *fio, const void gmx_unused *item, int gmx_unused nitem, int gmx_unused eio,
+ const char gmx_unused *desc, const char gmx_unused *srcfile, int gmx_unused line)
{
gmx_fatal(FARGS, "File type not set!");
return FALSE;
unsigned char *ucptr;
FILE *fp = fio->fp;
- gmx_fio_check_nitem(fio, eio, nitem, srcfile, line);
+ gmx_fio_check_nitem(eio, nitem, srcfile, line);
switch (eio)
{
case eioREAL:
#define NEXT_ITEM_BUF_LEN 128
char ni_buf[NEXT_ITEM_BUF_LEN];
- gmx_fio_check_nitem(fio, eio, nitem, srcfile, line);
+ gmx_fio_check_nitem(eio, nitem, srcfile, line);
switch (eio)
{
case eioREAL:
size_t size = 0, wsize;
int ssize;
- gmx_fio_check_nitem(fio, eio, nitem, srcfile, line);
+ gmx_fio_check_nitem(eio, nitem, srcfile, line);
switch (eio)
{
case eioREAL:
size_t size = 0, rsize;
int ssize;
- gmx_fio_check_nitem(fio, eio, nitem, srcfile, line);
+ gmx_fio_check_nitem(eio, nitem, srcfile, line);
switch (eio)
{
case eioREAL:
/* make a debug string if that is requested in the fio */
const char *gmx_fio_dbgstr(t_fileio *fio, const char *desc, char *buf);
/* check the number of items against the allowed number of items */
-void gmx_fio_check_nitem(t_fileio *fio, int eio, int nitem, const char *file,
+void gmx_fio_check_nitem(int eio, int nitem, const char *file,
int line);
/* check the output type against allowed values */
void gmx_fio_fe(t_fileio *fio, int eio, const char *desc, const char *srcfile,
double d = 0;
float f = 0;
- gmx_fio_check_nitem(fio, eio, nitem, srcfile, line);
+ gmx_fio_check_nitem(eio, nitem, srcfile, line);
switch (eio)
{
case eioREAL:
{
sdum = *(gmx_large_int_t *) item;
}
- res = xdr_gmx_large_int(fio->xdr, &sdum, NULL);
+ res = xdr_gmx_large_int(fio->xdr, &sdum);
if (item)
{
*(gmx_large_int_t *) item = sdum;
}
}
-t_commrec *init_par(int *argc, char ***argv_ptr)
+t_commrec *init_par(int gmx_unused *argc, char ***argv_ptr)
{
t_commrec *cr;
char **argv;
}
}
-static int mk_grey(FILE *log, int nnodes, egCol egc[], t_graph *g, int *AtomI,
+static int mk_grey(egCol egc[], t_graph *g, int *AtomI,
int npbcdim, matrix box, rvec x[], int *nerror)
{
int m, j, ng, ai, aj, g0;
/* Make all the neighbours of this black node grey
* and set their periodicity
*/
- ng = mk_grey(log, nnodes, g->egc, g, &fG, npbcdim, box, x, &nerror);
+ ng = mk_grey(g->egc, g, &fG, npbcdim, box, x, &nerror);
/* ng is the number of white nodes made grey */
nG += ng;
nW -= ng;
* The cat routines below are old code from src/kernel/topcat.c
*/
-static void blockcat(t_block *dest, t_block *src, int copies,
- int dnum, int snum)
+static void blockcat(t_block *dest, t_block *src, int copies)
{
int i, j, l, nra, size;
srcnr = molt->atoms.nr;
destnr = natoms;
- blockcat(&top->cgs, &molt->cgs, molb->nmol, destnr, srcnr);
+ blockcat(&top->cgs, &molt->cgs, molb->nmol);
blockacat(&top->excls, &molt->excls, molb->nmol, destnr, srcnr);
#endif
}
-int gmx_setup(int *argc, char **argv, int *nnodes)
+int gmx_setup(int gmx_unused *argc, char gmx_unused **argv, int *nnodes)
{
#ifndef GMX_MPI
gmx_call("gmx_setup");
#endif
}
-void gmx_setup_nodecomm(FILE *fplog, t_commrec *cr)
+void gmx_setup_nodecomm(FILE gmx_unused *fplog, t_commrec *cr)
{
gmx_nodecomm_t *nc;
int n, rank, hostnum, ng, ni;
#endif
}
-void gmx_abort(int noderank, int nnodes, int errorno)
+void gmx_abort(int gmx_unused noderank, int gmx_unused nnodes, int gmx_unused errorno)
{
#ifndef GMX_MPI
gmx_call("gmx_abort");
t_dih *dd;
gmx_rmpbc_t gpbc = NULL;
- gpbc = gmx_rmpbc_init(xr->idef, xr->ePBC, xr->natoms, xr->box);
+ gpbc = gmx_rmpbc_init(xr->idef, xr->ePBC, xr->natoms);
gmx_rmpbc(gpbc, xr->natoms, xr->box, xr->x);
gmx_rmpbc_done(gpbc);
gmx_bool new_data(t_xrama *xr)
{
- if (!read_next_x(xr->oenv, xr->traj, &xr->t, xr->natoms, xr->x, xr->box))
+ if (!read_next_x(xr->oenv, xr->traj, &xr->t, xr->x, xr->box))
{
return FALSE;
}
}
}
-void _inc_nrnb(t_nrnb *nrnb, int enr, int inc, char *file, int line)
+void _inc_nrnb(t_nrnb *nrnb, int enr, int inc, char gmx_unused *file, int gmx_unused line)
{
nrnb->n[enr] += inc;
#ifdef DEBUG_NRNB
}
}
-void print_perf(FILE *out, double nodetime, double realtime, int nprocs,
+void print_perf(FILE *out, double nodetime, double realtime,
gmx_large_int_t nsteps, real delta_t,
- double nbfs, double mflop,
- int omp_nth_pp)
+ double nbfs, double mflop)
{
real runtime;
real orires(int nfa, const t_iatom forceatoms[], const t_iparams ip[],
const rvec x[], rvec f[], rvec fshift[],
const t_pbc *pbc, const t_graph *g,
- real lambda, real *dvdlambda,
- const t_mdatoms *md, t_fcdata *fcd,
- int *global_atom_index)
+ real gmx_unused lambda, real gmx_unused *dvdlambda,
+ const t_mdatoms gmx_unused *md, t_fcdata *fcd,
+ int gmx_unused *global_atom_index)
{
atom_id ai, aj;
int fa, d, i, type, ex, power, ki = CENTRAL;
gmx_rng_destroy(rng);
}
-real calc_cm(FILE *log, int natoms, real mass[], rvec x[], rvec v[],
+real calc_cm(int natoms, real mass[], rvec x[], rvec v[],
rvec xcm, rvec vcm, rvec acm, matrix L)
{
rvec dx, a0;
return tm;
}
-void stop_cm(FILE *log, int natoms, real mass[], rvec x[], rvec v[])
+void stop_cm(FILE gmx_unused *log, int natoms, real mass[], rvec x[], rvec v[])
{
rvec xcm, vcm, acm;
tensor L;
#ifdef DEBUG
fprintf(log, "stopping center of mass motion...\n");
#endif
- (void)calc_cm(log, natoms, mass, x, v, xcm, vcm, acm, L);
+ (void)calc_cm(natoms, mass, x, v, xcm, vcm, acm, L);
/* Subtract center of mass velocity */
for (i = 0; (i < natoms); i++)
t_inpfile *read_inpfile(const char *fn, int *ninp,
- char **cppopts,
warninp_t wi)
{
FILE *in;
return gr->gr;
}
-gmx_rmpbc_t gmx_rmpbc_init(t_idef *idef, int ePBC, int natoms,
- matrix box)
+gmx_rmpbc_t gmx_rmpbc_init(t_idef *idef, int ePBC, int natoms)
{
gmx_rmpbc_t gpbc;
index_atp[i] = create_indexed_atom_type (red[i], isize[i]);
}
- sf_table = compute_scattering_factor_table (gmx_sf, (structure_factor_t *)sf, &nsftable);
+ sf_table = compute_scattering_factor_table (gmx_sf, (structure_factor_t *)sf);
/* This is the main loop over frames */
}
-extern real **compute_scattering_factor_table (gmx_structurefactors_t *gsf, structure_factor_t *sft, int *nsftable)
+extern real **compute_scattering_factor_table (gmx_structurefactors_t *gsf, structure_factor_t *sft)
{
/*
* this function build up a table of scattering factors for every atom
#endif
-void set_shift_consts(FILE *log, real r1, real rc, rvec box, t_forcerec *fr)
+void set_shift_consts(real r1, real rc, rvec box)
{
#ifdef GMX_THREAD_MPI
/* at the very least we shouldn't allow multiple threads to set these
return p;
}
-void save_free(const char *name, const char *file, int line, void *ptr)
+void save_free(const char gmx_unused *name, const char gmx_unused *file, int gmx_unused line, void gmx_unused *ptr)
{
#ifdef DEBUG
log_action(0, name, file, line, 0, 0, ptr);
return bor;
}
-static void split_blocks(FILE *fp, t_inputrec *ir, int nnodes,
+static void split_blocks(FILE *fp, int nnodes,
t_block *cgs, t_blocka *sblock, real capacity[],
int *multinr_cgs)
{
}
}
-static int mk_grey(int nnodes, egCol egc[], t_graph *g, int *AtomI,
+static int mk_grey(egCol egc[], t_graph *g, int *AtomI,
int maxsid, t_sid sid[])
{
int j, ng, ai, aj, g0;
/* Make all the neighbours of this black node grey
* and set their block number
*/
- ng = mk_grey(nnodes, egc, g, &fG, maxsid, sid);
+ ng = mk_grey(egc, g, &fG, maxsid, sid);
/* ng is the number of white nodes made grey */
nG += ng;
nW -= ng;
}
}
-static int merge_sid(int i0, int at_start, int at_end, int nsid, t_sid sid[],
+static int merge_sid(int at_start, int at_end, int nsid, t_sid sid[],
t_blocka *sblock)
{
int i, j, k, n, isid, ndel;
* part of the shake block too. There may be cases where blocks overlap
* and they will have to be merged.
*/
- nsid = merge_sid(i0, at_start, at_end, nsid, sid, sblock);
+ nsid = merge_sid(at_start, at_end, nsid, sid, sblock);
/* Now sort the shake blocks again... */
/*qsort(sid,natoms,(size_t)sizeof(sid[0]),sid_comp);*/
#endif
}
- split_blocks(fp, ir, nnodes, &top->cgs, &sblock, capacity, multinr_cgs);
+ split_blocks(fp, nnodes, &top->cgs, &sblock, capacity, multinr_cgs);
homeind = home_index(nnodes, &top->cgs, multinr_cgs);
}
}
-int check_times2(real t, real t0, real tp, real tpp, gmx_bool bDouble)
+int check_times2(real t, real t0, gmx_bool bDouble)
{
int r;
int check_times(real t)
{
- return check_times2(t, t, t, t, FALSE);
+ return check_times2(t, t, FALSE);
}
symtab->symbuf = NULL;
}
-void close_symtab(t_symtab *symtab)
+void close_symtab(t_symtab gmx_unused *symtab)
{
}
}
-static void do_rotgrp(t_fileio *fio, t_rotgrp *rotg, gmx_bool bRead, int file_version)
+static void do_rotgrp(t_fileio *fio, t_rotgrp *rotg, gmx_bool bRead)
{
int i;
gmx_fio_do_real(fio, rotg->PotAngle_step);
}
-static void do_rot(t_fileio *fio, t_rot *rot, gmx_bool bRead, int file_version)
+static void do_rot(t_fileio *fio, t_rot *rot, gmx_bool bRead)
{
int g;
}
for (g = 0; g < rot->ngrp; g++)
{
- do_rotgrp(fio, &rot->grp[g], bRead, file_version);
+ do_rotgrp(fio, &rot->grp[g], bRead);
}
}
{
snew(ir->rot, 1);
}
- do_rot(fio, ir->rot, bRead, file_version);
+ do_rot(fio, ir->rot, bRead);
}
}
else
}
-static void do_harm(t_fileio *fio, t_iparams *iparams, gmx_bool bRead)
+static void do_harm(t_fileio *fio, t_iparams *iparams)
{
gmx_fio_do_real(fio, iparams->harmonic.rA);
gmx_fio_do_real(fio, iparams->harmonic.krA);
case F_G96BONDS:
case F_HARMONIC:
case F_IDIHS:
- do_harm(fio, iparams, bRead);
+ do_harm(fio, iparams);
if ((ftype == F_ANGRES || ftype == F_ANGRESZ) && bRead)
{
/* Correct incorrect storage of parameters */
}
static void do_atomtypes(t_fileio *fio, t_atomtypes *atomtypes, gmx_bool bRead,
- t_symtab *symtab, int file_version)
+ int file_version)
{
int i, j;
do_blocka(fio, &molt->excls, bRead, file_version);
}
-static void do_molblock(t_fileio *fio, gmx_molblock_t *molb, gmx_bool bRead,
- int file_version)
+static void do_molblock(t_fileio *fio, gmx_molblock_t *molb, gmx_bool bRead)
{
int i;
{
for (mb = 0; mb < mtop->nmolblock; mb++)
{
- do_molblock(fio, &mtop->molblock[mb], bRead, file_version);
+ do_molblock(fio, &mtop->molblock[mb], bRead);
}
gmx_fio_do_int(fio, mtop->natoms);
}
mtop->molblock[0].nposres_xB = 0;
}
- do_atomtypes (fio, &(mtop->atomtypes), bRead, &(mtop->symtab), file_version);
+ do_atomtypes (fio, &(mtop->atomtypes), bRead, file_version);
if (bRead && debug)
{
pr_atomtypes(debug, 0, "atomtypes", &mtop->atomtypes, TRUE);
if ((fver <= tpx_incompatible_version) ||
((fver > tpx_version) && !TopOnlyOK) ||
- (fgen > tpx_generation) ||
+ (fgen > tpx_generation) ||
tpx_version == 80) /*80 was used by both 5.0-dev and 4.6-dev*/
{
gmx_fatal(FARGS, "reading tpx file (%s) version %d with version %d program",
}
}
-static gmx_bool do_htrn(t_fileio *fio, gmx_bool bRead, t_trnheader *sh,
+static gmx_bool do_htrn(t_fileio *fio, t_trnheader *sh,
rvec *box, rvec *x, rvec *v, rvec *f)
{
matrix pv;
gmx_file("symbol table in trn file");
}
}
- bOK = do_htrn(fio, bRead, sh, box, x, v, f);
+ bOK = do_htrn(fio, sh, box, x, v, f);
sfree(sh);
gmx_bool fread_htrn(t_fileio *fio, t_trnheader *trn, rvec *box, rvec *x, rvec *v,
rvec *f)
{
- return do_htrn(fio, TRUE, trn, box, x, v, f);
+ return do_htrn(fio, trn, box, x, v, f);
}
t_fileio *open_trn(const char *fn, const char *mode)
break;
default:
#ifdef GMX_USE_PLUGINS
- bRet = read_next_vmd_frame(dummy, fr);
+ bRet = read_next_vmd_frame(fr);
#else
gmx_fatal(FARGS, "DEATH HORROR in read_next_frame ftp=%s,status=%s",
ftp2ext(gmx_fio_getftp(status->fio)),
bSkip = FALSE;
if (!bMissingData)
{
- ct = check_times2(fr->time, fr->t0, fr->tpf, fr->tppf, fr->bDouble);
+ ct = check_times2(fr->time, fr->t0, fr->bDouble);
if (ct == 0 || ((fr->flags & TRX_DONT_SKIP) && ct < 0))
{
printcount(status, oenv, fr->time, FALSE);
"GROMACS will now assume it to be a trajectory and will try to open it using the VMD plug-ins.\n"
"This will only work in case the VMD plugins are found and it is a trajectory format supported by VMD.\n", fn);
gmx_fio_fp_close(fio); /*only close the file without removing FIO entry*/
- if (!read_first_vmd_frame(&dummy, fn, fr, flags))
+ if (!read_first_vmd_frame(fn, fr))
{
gmx_fatal(FARGS, "Not supported in read_first_frame: %s", fn);
}
}
gmx_bool read_next_x(const output_env_t oenv, t_trxstatus *status, real *t,
- int natoms, rvec x[], matrix box)
+ rvec x[], matrix box)
{
gmx_bool bRet;
PR("kB", pg->kB);
}
-static void pr_simtempvals(FILE *fp, int indent, t_simtemp *simtemp, int n_lambda, gmx_bool bMDPformat)
+static void pr_simtempvals(FILE *fp, int indent, t_simtemp *simtemp, int n_lambda)
{
PR("simtemp_low", simtemp->simtemp_low);
PR("simtemp_high", simtemp->simtemp_high);
pr_rvec(fp, indent, "simulated tempering temperatures", simtemp->temperatures, n_lambda, TRUE);
}
-static void pr_expandedvals(FILE *fp, int indent, t_expanded *expand, int n_lambda, gmx_bool bMDPformat)
+static void pr_expandedvals(FILE *fp, int indent, t_expanded *expand, int n_lambda)
{
PI("nstexpanded", expand->nstexpanded);
PS("bSimTemp", EBOOL(ir->bSimTemp));
if (ir->bSimTemp)
{
- pr_simtempvals(fp, indent, ir->simtempvals, ir->fepvals->n_lambda, bMDPformat);
+ pr_simtempvals(fp, indent, ir->simtempvals, ir->fepvals->n_lambda);
}
PS("free-energy", EFEPTYPE(ir->efep));
if (ir->efep != efepNO || ir->bSimTemp)
}
if (ir->bExpanded)
{
- pr_expandedvals(fp, indent, ir->expandedvals, ir->fepvals->n_lambda, bMDPformat);
+ pr_expandedvals(fp, indent, ir->expandedvals, ir->fepvals->n_lambda);
}
PI("nwall", ir->nwall);
}
}
-static void pr_grps(FILE *fp, int indent, const char *title, t_grps grps[],
- char **grpname[], gmx_bool bShowNumbers)
+static void pr_grps(FILE *fp, const char *title, t_grps grps[], char **grpname[])
{
int i, j;
}
}
-static void pr_groups(FILE *fp, int indent, const char *title,
+static void pr_groups(FILE *fp, int indent,
gmx_groups_t *groups,
gmx_bool bShowNumbers)
{
int grpnr[egcNR];
int nat_max, i, g;
- pr_grps(fp, indent, "grp", groups->grps, groups->grpname, bShowNumbers);
+ pr_grps(fp, "grp", groups->grps, groups->grpname);
pr_strings(fp, indent, "grpname", groups->grpname, groups->ngrpname, bShowNumbers);
(void) pr_indent(fp, indent);
static void pr_molblock(FILE *fp, int indent, const char *title,
gmx_molblock_t *molb, int n,
- gmx_moltype_t *molt,
- gmx_bool bShowNumbers)
+ gmx_moltype_t *molt)
{
indent = pr_title_n(fp, indent, title, n);
(void) pr_indent(fp, indent);
pr_int(fp, indent, "#molblock", mtop->nmolblock);
for (mb = 0; mb < mtop->nmolblock; mb++)
{
- pr_molblock(fp, indent, "molblock", &mtop->molblock[mb], mb,
- mtop->moltype, bShowNumbers);
+ pr_molblock(fp, indent, "molblock", &mtop->molblock[mb], mb, mtop->moltype);
}
pr_ffparams(fp, indent, "ffparams", &(mtop->ffparams), bShowNumbers);
pr_atomtypes(fp, indent, "atomtypes", &(mtop->atomtypes), bShowNumbers);
pr_moltype(fp, indent, "moltype", &mtop->moltype[mt], mt,
&mtop->ffparams, bShowNumbers);
}
- pr_groups(fp, indent, "groups", &mtop->groups, bShowNumbers);
+ pr_groups(fp, indent, &mtop->groups, bShowNumbers);
}
}
}
/*return: 1: success, 0: last frame, -1: error*/
-gmx_bool read_next_vmd_frame(int status, t_trxframe *fr)
+gmx_bool read_next_vmd_frame(t_trxframe *fr)
{
int rc, i;
rvec vec, angle;
}
-int read_first_vmd_frame(int *status, const char *fn, t_trxframe *fr, int flags)
+int read_first_vmd_frame(const char *fn, t_trxframe *fr)
{
molfile_timestep_metadata_t *metadata = NULL;
gmx_bool bV;
};
-int read_first_vmd_frame(int *status, const char *fn, struct trxframe *fr, int flags);
-gmx_bool read_next_vmd_frame(int status, struct trxframe *fr);
+int read_first_vmd_frame(const char *fn, struct trxframe *fr);
+gmx_bool read_next_vmd_frame(struct trxframe *fr);
#ifdef __cplusplus
}
#endif
}
-int xdr_gmx_large_int(XDR *xdrs, gmx_large_int_t *i, const char *warn)
+int xdr_gmx_large_int(XDR *xdrs, gmx_large_int_t *i)
{
/* This routine stores values compatible with xdr_int64_t */
#define XTC_MAGIC 1995
-static int xdr_r2f(XDR *xdrs, real *r, gmx_bool bRead)
+static int xdr_r2f(XDR *xdrs, real *r, gmx_bool gmx_unused bRead)
{
#ifdef GMX_DOUBLE
float f;
t_lambda *fep = ir->fepvals;
t_expanded *expand = ir->expandedvals;
- inp = read_inpfile(mdparin, &ninp, NULL, wi);
+ inp = read_inpfile(mdparin, &ninp, wi);
snew(dumstr[0], STRLEN);
snew(dumstr[1], STRLEN);
/* Ewald related stuff */
void
-init_ewald_tab(ewald_tab_t *et, const t_commrec *cr, const t_inputrec *ir,
+init_ewald_tab(ewald_tab_t *et, const t_inputrec *ir,
FILE *fp);
/* initialize the ewald table (as found in the t_forcerec) */
/* Do an Ewald calculation for the long range electrostatics. */
real
-ewald_LRcorrection(FILE *fp,
- int start, int end,
+ewald_LRcorrection(int start, int end,
t_commrec *cr, int thread, t_forcerec *fr,
real *chargeA, real *chargeB,
gmx_bool calc_excl_corr,
* of potentials and forces.
*/
void
-set_shift_consts(FILE *log, real r1, real rc, rvec box,
- t_forcerec *fr);
+set_shift_consts(real r1, real rc, rvec box);
#ifdef __cplusplus
}
gmx_set_thread_affinity(FILE *fplog,
const t_commrec *cr,
gmx_hw_opt_t *hw_opt,
- int nthreads_pme,
- const gmx_hw_info_t *hwinfo,
- const t_inputrec *inputrec);
+ const gmx_hw_info_t *hwinfo);
/* Check the process affinity mask and if it is found to be non-zero,
* will honor it and disable mdrun internal affinity setting.
#endif
FUNC_QUALIFIER
-int do_quick_memtest(int dev_id) FUNC_TERM_INT
+int do_quick_memtest(int gmx_unused dev_id) FUNC_TERM_INT
FUNC_QUALIFIER
-int do_full_memtest(int dev_id) FUNC_TERM_INT
+int do_full_memtest(int gmx_unused dev_id) FUNC_TERM_INT
FUNC_QUALIFIER
-int do_timed_memtest(int dev_id, int time_limit) FUNC_TERM_INT
+int do_timed_memtest(int gmx_unused dev_id, int gmx_unused time_limit) FUNC_TERM_INT
FUNC_QUALIFIER
-int detect_cuda_gpus(gmx_gpu_info_t *gpu_info, char *err_str) FUNC_TERM_INT
+int detect_cuda_gpus(gmx_gpu_info_t gmx_unused *gpu_info, char gmx_unused *err_str) FUNC_TERM_INT
FUNC_QUALIFIER
-void pick_compatible_gpus(gmx_gpu_info_t *gpu_info) FUNC_TERM_VOID
+void pick_compatible_gpus(gmx_gpu_info_t gmx_unused *gpu_info) FUNC_TERM_VOID
FUNC_QUALIFIER
-gmx_bool check_select_cuda_gpus(int *checkres, gmx_gpu_info_t *gpu_info,
- const int *requested_devs, int count) FUNC_TERM_INT
+gmx_bool check_select_cuda_gpus(int gmx_unused *checkres, gmx_gpu_info_t gmx_unused *gpu_info,
+ const int gmx_unused *requested_devs, int gmx_unused count) FUNC_TERM_INT
FUNC_QUALIFIER
-void free_gpu_info(const gmx_gpu_info_t *gpu_info) FUNC_TERM_VOID
+void free_gpu_info(const gmx_gpu_info_t gmx_unused *gpu_info) FUNC_TERM_VOID
FUNC_QUALIFIER
-gmx_bool init_gpu(int mygpu, char *result_str, const gmx_gpu_info_t *gpu_info) FUNC_TERM_INT
+gmx_bool init_gpu(int gmx_unused mygpu, char gmx_unused *result_str, const gmx_gpu_info_t gmx_unused *gpu_info) FUNC_TERM_INT
FUNC_QUALIFIER
-gmx_bool free_gpu(char *result_str) FUNC_TERM_INT
+gmx_bool free_gpu(char gmx_unused *result_str) FUNC_TERM_INT
/*! \brief Returns the device ID of the GPU currently in use.*/
FUNC_QUALIFIER
int get_current_gpu_device_id(void) FUNC_TERM_INT
FUNC_QUALIFIER
-int get_gpu_device_id(const gmx_gpu_info_t *gpu_info, int index) FUNC_TERM_INT
+int get_gpu_device_id(const gmx_gpu_info_t gmx_unused *gpu_info, int gmx_unused index) FUNC_TERM_INT
FUNC_QUALIFIER
-void get_gpu_device_info_string(char *s, const gmx_gpu_info_t *gpu_info, int index) FUNC_TERM_VOID
+void get_gpu_device_info_string(char gmx_unused *s, const gmx_gpu_info_t gmx_unused *gpu_info, int gmx_unused index) FUNC_TERM_VOID
#ifdef __cplusplus
}
* When out!=NULL also prints the full count table.
*/
-void print_perf(FILE *out, double nodetime, double realtime, int nprocs,
+void print_perf(FILE *out, double nodetime, double realtime,
gmx_large_int_t nsteps, real delta_t,
- double nbfs, double mflop,
- int omp_nth_pp);
+ double nbfs, double mflop);
/* Prints the performance, nbfs and mflop come from print_flop */
void pr_load(FILE *log, t_commrec *cr, t_nrnb nrnb[]);
gmx_mtop_t *mtop, rvec v[]);
/* Generate velocites according to a maxwellian distribution */
-real calc_cm(FILE *log, int natoms, real mass[], rvec x[], rvec v[],
+real calc_cm(int natoms, real mass[], rvec x[], rvec v[],
rvec xcm, rvec vcm, rvec acm, matrix L);
/* Calculate the c.o.m. position, velocity, acceleration and the
* moment of Inertia. Returns the total mass.
t_inpfile *read_inpfile(const char *fn, int *ninp,
- char **cppopts,
warninp_t wi);
/* Create & populate a t_inpfile struct from values in file fn.
fn = the file name
typedef struct gmx_rmpbc *gmx_rmpbc_t;
-gmx_rmpbc_t gmx_rmpbc_init(t_idef *idef, int ePBC, int natoms,
- matrix box);
+gmx_rmpbc_t gmx_rmpbc_init(t_idef *idef, int ePBC, int natoms);
void gmx_rmpbc_done(gmx_rmpbc_t gpbc);
t_complex *** rc_tensor_allocation(int x, int y, int z);
-real **compute_scattering_factor_table (gmx_structurefactors_t *gsf, structure_factor_t * sft, int *nsftable);
+real **compute_scattering_factor_table (gmx_structurefactors_t *gsf, structure_factor_t * sft);
#ifdef __cplusplus
}
#define bRmod(a, b, c) bRmod_fd(a, b, c, FALSE)
#endif
-int check_times2(real t, real t0, real tp, real tpp, gmx_bool bDouble);
+int check_times2(real t, real t0, gmx_bool bDouble);
/* This routine checkes if the read-in time is correct or not;
* returns -1 if t<tbegin or t MOD dt = t0,
* 0 if tbegin <= t <=tend+margin,
* The integer in status should be passed to calls of read_next_x
*/
-gmx_bool read_next_x(const output_env_t oenv, t_trxstatus *status, real *t,
- int natoms, rvec x[], matrix box);
+gmx_bool read_next_x(const output_env_t oenv, t_trxstatus *status, real *t, rvec x[], matrix box);
/* Read coordinates and box from a trajectory file. Return TRUE when all well,
* or FALSE when end of file (or last frame requested by user).
* status is the integer set in read_first_x.
int xdr3drcoord(XDR *xdrs, real *fp, int *size, real *precision);
-int xdr_gmx_large_int(XDR *xdrs, gmx_large_int_t *i, const char *warn);
+int xdr_gmx_large_int(XDR *xdrs, gmx_large_int_t *i);
/* Read or write a gmx_large_int_t value.
* 32bit code reading a 64bit gmx_large_int_t value from xdrs could
* lead to values out of int range.
}
}
-void init_ewald_tab(ewald_tab_t *et, const t_commrec *cr, const t_inputrec *ir,
- FILE *fp)
+void init_ewald_tab(ewald_tab_t *et, const t_inputrec *ir, FILE *fp)
{
int n;
}
*dvdlt = 0;
*Vcorrt =
- ewald_LRcorrection(fplog,
- fr->excl_load[t], fr->excl_load[t+1],
+ ewald_LRcorrection(fr->excl_load[t], fr->excl_load[t+1],
cr, t, fr,
md->chargeA,
md->nChargePerturbed ? md->chargeB : NULL,
}
}
fr->ewaldcoeff = calc_ewaldcoeff(ir->rcoulomb, ir->ewald_rtol);
- init_ewald_tab(&(fr->ewald_table), cr, ir, fp);
+ init_ewald_tab(&(fr->ewald_table), ir, fp);
if (fp)
{
fprintf(fp, "Using a Gaussian width (1/beta) of %g nm for Ewald\n",
if ((fr->eeltype == eelSHIFT && fr->rcoulomb > fr->rcoulomb_switch))
{
- set_shift_consts(fp, fr->rcoulomb_switch, fr->rcoulomb, box_size, fr);
+ set_shift_consts(fr->rcoulomb_switch, fr->rcoulomb, box_size);
}
}
if (fplog)
{
print_perf(fplog, runtime->proctime, runtime->realtime,
- cr->nnodes-cr->npmenodes,
- runtime->nsteps_done, delta_t, nbfs, mflop,
- omp_nth_pp);
+ runtime->nsteps_done, delta_t, nbfs, mflop);
}
if (bWriteStat)
{
print_perf(stderr, runtime->proctime, runtime->realtime,
- cr->nnodes-cr->npmenodes,
- runtime->nsteps_done, delta_t, nbfs, mflop,
- omp_nth_pp);
+ runtime->nsteps_done, delta_t, nbfs, mflop);
}
}
}
double do_tpi(FILE *fplog, t_commrec *cr,
int nfile, const t_filenm fnm[],
- const output_env_t oenv, gmx_bool bVerbose, gmx_bool bCompact,
- int nstglobalcomm,
- gmx_vsite_t *vsite, gmx_constr_t constr,
- int stepout,
+ const output_env_t oenv, gmx_bool bVerbose, gmx_bool gmx_unused bCompact,
+ int gmx_unused nstglobalcomm,
+ gmx_vsite_t gmx_unused *vsite, gmx_constr_t gmx_unused constr,
+ int gmx_unused stepout,
t_inputrec *inputrec,
gmx_mtop_t *top_global, t_fcdata *fcd,
t_state *state,
t_mdatoms *mdatoms,
t_nrnb *nrnb, gmx_wallcycle_t wcycle,
- gmx_edsam_t ed,
+ gmx_edsam_t gmx_unused ed,
t_forcerec *fr,
- int repl_ex_nst, int repl_ex_nex, int repl_ex_seed,
- gmx_membed_t membed,
- real cpt_period, real max_hours,
- const char *deviceOptions,
- unsigned long Flags,
+ int gmx_unused repl_ex_nst, int gmx_unused repl_ex_nex, int gmx_unused repl_ex_seed,
+ gmx_membed_t gmx_unused membed,
+ real gmx_unused cpt_period, real gmx_unused max_hours,
+ const char gmx_unused *deviceOptions,
+ unsigned long gmx_unused Flags,
gmx_runtime_t *runtime)
{
const char *TPI = "Test Particle Insertion";
if (top.hasTopology() && impl_->settings_.hasRmPBC())
{
impl_->gpbc_ = gmx_rmpbc_init(&top.topology()->idef, top.ePBC(),
- impl_->fr->natoms, impl_->fr->box);
+ impl_->fr->natoms);
}
}
wi = init_warning(FALSE, 0);
- inp = read_inpfile(fn, &ninp, NULL, wi);
+ inp = read_inpfile(fn, &ninp, wi);
for (i = 0; (i < eoObsNR); i++)
{
wi = init_warning(TRUE, 0);
- inp = read_inpfile(membed_input, &ninp, NULL, wi);
+ inp = read_inpfile(membed_input, &ninp, wi);
ITYPE ("nxy", *it_xy, 1000);
ITYPE ("nz", *it_z, 0);
RTYPE ("xyinit", *xy_fac, 0.5);
hw_opt, hwinfo->nthreads_hw_avail, TRUE);
/* Set the CPU affinity */
- gmx_set_thread_affinity(fplog, cr, hw_opt, nthreads_pme, hwinfo, inputrec);
+ gmx_set_thread_affinity(fplog, cr, hw_opt, hwinfo);
}
/* Initiate PME if necessary,
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff