void write_sto_conf_mtop(const char *outfile, const char *title,
gmx_mtop_t *mtop,
rvec x[], rvec *v, int ePBC, matrix box)
{
int ftp;
FILE *out;
t_atoms atoms;
ftp = fn2ftp(outfile);
switch (ftp)
{
case efGRO:
out = gmx_fio_fopen(outfile, "w");
write_hconf_mtop(out, title, mtop, 3, x, v, box);
gmx_fio_fclose(out);
break;
default:
/* This is a brute force approach which requires a lot of memory.
* We should implement mtop versions of all writing routines.
*/
atoms = gmx_mtop_global_atoms(mtop);
write_sto_conf(outfile, title, &atoms, x, v, ePBC, box);
done_atom(&atoms);
break;
}
}
t_topology gmx_mtop_t_to_t_topology(gmx_mtop_t *mtop)
{
int mt,mb;
gmx_localtop_t ltop;
t_topology top;
gen_local_top(mtop,NULL,<op);
open_symtab(&top.symtab);
top.name = mtop->name;
top.idef = ltop.idef;
top.atomtypes = ltop.atomtypes;
top.cgs = ltop.cgs;
top.excls = ltop.excls;
top.atoms = gmx_mtop_global_atoms(mtop);
top.mols = mtop->mols;
/* We only need to free the moltype and molblock data,
* all other pointers have been copied to top.
*/
for(mt=0; mt<mtop->nmoltype; mt++)
{
done_moltype(&mtop->moltype[mt]);
}
sfree(mtop->moltype);
for(mb=0; mb<mtop->nmolblock; mb++)
{
done_molblock(&mtop->molblock[mb]);
}
sfree(mtop->molblock);
return top;
}
t_topology gmx_mtop_t_to_t_topology(gmx_mtop_t *mtop)
{
int mt,mb;
gmx_localtop_t ltop;
t_topology top;
gen_local_top(mtop,NULL,FALSE,<op);
top.name = mtop->name;
top.idef = ltop.idef;
top.atomtypes = ltop.atomtypes;
top.cgs = ltop.cgs;
top.excls = ltop.excls;
top.atoms = gmx_mtop_global_atoms(mtop);
top.mols = mtop->mols;
top.symtab = mtop->symtab;
/* We only need to free the moltype and molblock data,
* all other pointers have been copied to top.
*
* Well, except for the group data, but we can't free those, because they
* are used somewhere even after a call to this function.
*/
for(mt=0; mt<mtop->nmoltype; mt++)
{
done_moltype(&mtop->moltype[mt]);
}
sfree(mtop->moltype);
for(mb=0; mb<mtop->nmolblock; mb++)
{
done_molblock(&mtop->molblock[mb]);
}
sfree(mtop->molblock);
return top;
}
int cmain (int argc, char *argv[])
{
const char *desc[] = {
"tpbconv can edit run input files in four ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
"[BB]2.[bb] (OBSOLETE) by creating a run input file",
"for a continuation run when your simulation has crashed due to e.g.",
"a full disk, or by making a continuation run input file.",
"This option is obsolete, since mdrun now writes and reads",
"checkpoint files.",
"[BB]Note[bb] that a frame with coordinates and velocities is needed.",
"When pressure and/or Nose-Hoover temperature coupling is used",
"an energy file can be supplied to get an exact continuation",
"of the original run.[PAR]",
"[BB]3.[bb] by creating a [TT].tpx[tt] file for a subset of your original",
"tpx file, which is useful when you want to remove the solvent from",
"your [TT].tpx[tt] file, or when you want to make e.g. a pure C[GRK]alpha[grk] [TT].tpx[tt] file.",
"Note that you may need to use [TT]-nsteps -1[tt] (or similar) to get",
"this to work.",
"[BB]WARNING: this [TT].tpx[tt] file is not fully functional[bb].[PAR]",
"[BB]4.[bb] by setting the charges of a specified group",
"to zero. This is useful when doing free energy estimates",
"using the LIE (Linear Interaction Energy) method."
};
const char *top_fn, *frame_fn;
t_fileio *fp;
ener_file_t fp_ener = NULL;
t_trnheader head;
int i;
gmx_large_int_t nsteps_req, run_step, frame;
double run_t, state_t;
gmx_bool bOK, bNsteps, bExtend, bUntil, bTime, bTraj;
gmx_bool bFrame, bUse, bSel, bNeedEner, bReadEner, bScanEner, bFepState;
gmx_mtop_t mtop;
t_atoms atoms;
t_inputrec *ir, *irnew = NULL;
t_gromppopts *gopts;
t_state state;
rvec *newx = NULL, *newv = NULL, *tmpx, *tmpv;
matrix newbox;
int gnx;
char *grpname;
atom_id *index = NULL;
int nre;
gmx_enxnm_t *enm = NULL;
t_enxframe *fr_ener = NULL;
char buf[200], buf2[200];
output_env_t oenv;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRN, "-f", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPX, "-o", "tpxout", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options */
static int nsteps_req_int = 0;
static real start_t = -1.0, extend_t = 0.0, until_t = 0.0;
static int init_fep_state = 0;
static gmx_bool bContinuation = TRUE, bZeroQ = FALSE, bVel = TRUE;
static t_pargs pa[] = {
{ "-extend", FALSE, etREAL, {&extend_t},
"Extend runtime by this amount (ps)" },
{ "-until", FALSE, etREAL, {&until_t},
"Extend runtime until this ending time (ps)" },
{ "-nsteps", FALSE, etINT, {&nsteps_req_int},
"Change the number of steps" },
{ "-time", FALSE, etREAL, {&start_t},
"Continue from frame at this time (ps) instead of the last frame" },
{ "-zeroq", FALSE, etBOOL, {&bZeroQ},
"Set the charges of a group (from the index) to zero" },
{ "-vel", FALSE, etBOOL, {&bVel},
"Require velocities from trajectory" },
{ "-cont", FALSE, etBOOL, {&bContinuation},
"For exact continuation, the constraints should not be applied before the first step" },
{ "-init_fep_state", FALSE, etINT, {&init_fep_state},
"fep state to initialize from" },
};
int nerror = 0;
CopyRight(stderr, argv[0]);
/* Parse the command line */
parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv);
/* Convert int to gmx_large_int_t */
nsteps_req = nsteps_req_int;
bNsteps = opt2parg_bSet("-nsteps", asize(pa), pa);
bExtend = opt2parg_bSet("-extend", asize(pa), pa);
bUntil = opt2parg_bSet("-until", asize(pa), pa);
bFepState = opt2parg_bSet("-init_fep_state", asize(pa), pa);
bTime = opt2parg_bSet("-time", asize(pa), pa);
bTraj = (opt2bSet("-f", NFILE, fnm) || bTime);
top_fn = ftp2fn(efTPX, NFILE, fnm);
fprintf(stderr, "Reading toplogy and stuff from %s\n", top_fn);
snew(ir, 1);
read_tpx_state(top_fn, ir, &state, NULL, &mtop);
run_step = ir->init_step;
run_t = ir->init_step*ir->delta_t + ir->init_t;
if (!EI_STATE_VELOCITY(ir->eI))
{
bVel = FALSE;
}
if (bTraj)
{
fprintf(stderr, "\n"
"NOTE: Reading the state from trajectory is an obsolete feature of tpbconv.\n"
" Continuation should be done by loading a checkpoint file with mdrun -cpi\n"
" This guarantees that all state variables are transferred.\n"
" tpbconv is now only useful for increasing nsteps,\n"
" but even that can often be avoided by using mdrun -maxh\n"
"\n");
if (ir->bContinuation != bContinuation)
{
fprintf(stderr, "Modifying ir->bContinuation to %s\n",
bool_names[bContinuation]);
}
ir->bContinuation = bContinuation;
bNeedEner = (ir->epc == epcPARRINELLORAHMAN || ir->etc == etcNOSEHOOVER);
bReadEner = (bNeedEner && ftp2bSet(efEDR, NFILE, fnm));
bScanEner = (bReadEner && !bTime);
if (ir->epc != epcNO || EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "NOTE: The simulation uses pressure coupling and/or stochastic dynamics.\n"
"tpbconv can not provide binary identical continuation.\n"
"If you want that, supply a checkpoint file to mdrun\n\n");
}
if (EI_SD(ir->eI) || ir->eI == eiBD)
{
fprintf(stderr, "\nChanging ld-seed from %d ", ir->ld_seed);
ir->ld_seed = make_seed();
fprintf(stderr, "to %d\n\n", ir->ld_seed);
}
frame_fn = ftp2fn(efTRN, NFILE, fnm);
if (fn2ftp(frame_fn) == efCPT)
{
int sim_part;
fprintf(stderr,
"\nREADING STATE FROM CHECKPOINT %s...\n\n",
frame_fn);
read_checkpoint_state(frame_fn, &sim_part,
&run_step, &run_t, &state);
}
else
{
fprintf(stderr,
"\nREADING COORDS, VELS AND BOX FROM TRAJECTORY %s...\n\n",
frame_fn);
fp = open_trn(frame_fn, "r");
if (bScanEner)
{
fp_ener = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
do_enxnms(fp_ener, &nre, &enm);
snew(fr_ener, 1);
fr_ener->t = -1e-12;
}
/* Now scan until the last set of x and v (step == 0)
* or the ones at step step.
*/
bFrame = TRUE;
frame = 0;
while (bFrame)
{
bFrame = fread_trnheader(fp, &head, &bOK);
if (bOK && frame == 0)
{
if (mtop.natoms != head.natoms)
{
gmx_fatal(FARGS, "Number of atoms in Topology (%d) "
"is not the same as in Trajectory (%d)\n",
mtop.natoms, head.natoms);
}
snew(newx, head.natoms);
snew(newv, head.natoms);
}
bFrame = bFrame && bOK;
if (bFrame)
{
bOK = fread_htrn(fp, &head, newbox, newx, newv, NULL);
}
bFrame = bFrame && bOK;
bUse = FALSE;
if (bFrame &&
(head.x_size) && (head.v_size || !bVel))
{
bUse = TRUE;
if (bScanEner)
{
/* Read until the energy time is >= the trajectory time */
while (fr_ener->t < head.t && do_enx(fp_ener, fr_ener))
{
;
}
bUse = (fr_ener->t == head.t);
}
if (bUse)
{
tmpx = newx;
newx = state.x;
state.x = tmpx;
tmpv = newv;
newv = state.v;
state.v = tmpv;
run_t = head.t;
run_step = head.step;
state.fep_state = head.fep_state;
state.lambda[efptFEP] = head.lambda;
copy_mat(newbox, state.box);
}
}
if (bFrame || !bOK)
{
sprintf(buf, "\r%s %s frame %s%s: step %s%s time %s",
"%s", "%s", "%6", gmx_large_int_fmt, "%6", gmx_large_int_fmt, " %8.3f");
fprintf(stderr, buf,
bUse ? "Read " : "Skipped", ftp2ext(fn2ftp(frame_fn)),
frame, head.step, head.t);
frame++;
if (bTime && (head.t >= start_t))
{
bFrame = FALSE;
}
}
}
if (bScanEner)
{
close_enx(fp_ener);
free_enxframe(fr_ener);
free_enxnms(nre, enm);
}
close_trn(fp);
fprintf(stderr, "\n");
if (!bOK)
{
fprintf(stderr, "%s frame %s (step %s, time %g) is incomplete\n",
ftp2ext(fn2ftp(frame_fn)), gmx_step_str(frame-1, buf2),
gmx_step_str(head.step, buf), head.t);
}
fprintf(stderr, "\nUsing frame of step %s time %g\n",
gmx_step_str(run_step, buf), run_t);
if (bNeedEner)
{
if (bReadEner)
{
get_enx_state(ftp2fn(efEDR, NFILE, fnm), run_t, &mtop.groups, ir, &state);
}
else
{
fprintf(stderr, "\nWARNING: The simulation uses %s temperature and/or %s pressure coupling,\n"
" the continuation will only be exact when an energy file is supplied\n\n",
ETCOUPLTYPE(etcNOSEHOOVER),
EPCOUPLTYPE(epcPARRINELLORAHMAN));
}
}
if (bFepState)
{
ir->fepvals->init_fep_state = init_fep_state;
}
}
}
if (bNsteps)
{
fprintf(stderr, "Setting nsteps to %s\n", gmx_step_str(nsteps_req, buf));
ir->nsteps = nsteps_req;
}
else
{
/* Determine total number of steps remaining */
if (bExtend)
{
ir->nsteps = ir->nsteps - (run_step - ir->init_step) + (gmx_large_int_t)(extend_t/ir->delta_t + 0.5);
printf("Extending remaining runtime of by %g ps (now %s steps)\n",
extend_t, gmx_step_str(ir->nsteps, buf));
}
else if (bUntil)
{
printf("nsteps = %s, run_step = %s, current_t = %g, until = %g\n",
gmx_step_str(ir->nsteps, buf),
gmx_step_str(run_step, buf2),
run_t, until_t);
ir->nsteps = (gmx_large_int_t)((until_t - run_t)/ir->delta_t + 0.5);
printf("Extending remaining runtime until %g ps (now %s steps)\n",
until_t, gmx_step_str(ir->nsteps, buf));
}
else
{
ir->nsteps -= run_step - ir->init_step;
/* Print message */
printf("%s steps (%g ps) remaining from first run.\n",
gmx_step_str(ir->nsteps, buf), ir->nsteps*ir->delta_t);
}
}
if (bNsteps || bZeroQ || (ir->nsteps > 0))
{
ir->init_step = run_step;
if (ftp2bSet(efNDX, NFILE, fnm) ||
!(bNsteps || bExtend || bUntil || bTraj))
{
atoms = gmx_mtop_global_atoms(&mtop);
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1,
&gnx, &index, &grpname);
if (!bZeroQ)
{
bSel = (gnx != state.natoms);
for (i = 0; ((i < gnx) && (!bSel)); i++)
{
bSel = (i != index[i]);
}
}
else
{
bSel = FALSE;
}
if (bSel)
{
fprintf(stderr, "Will write subset %s of original tpx containing %d "
"atoms\n", grpname, gnx);
reduce_topology_x(gnx, index, &mtop, state.x, state.v);
state.natoms = gnx;
}
else if (bZeroQ)
{
zeroq(gnx, index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
{
fprintf(stderr, "Will write full tpx file (no selection)\n");
}
}
state_t = ir->init_t + ir->init_step*ir->delta_t;
sprintf(buf, "Writing statusfile with starting step %s%s and length %s%s steps...\n", "%10", gmx_large_int_fmt, "%10", gmx_large_int_fmt);
fprintf(stderr, buf, ir->init_step, ir->nsteps);
fprintf(stderr, " time %10.3f and length %10.3f ps\n",
state_t, ir->nsteps*ir->delta_t);
write_tpx_state(opt2fn("-o", NFILE, fnm), ir, &state, &mtop);
}
else
{
printf("You've simulated long enough. Not writing tpr file\n");
}
thanx(stderr);
return 0;
}
int gmx_disre(int argc,char *argv[])
{
const char *desc[] = {
"g_disre computes violations of distance restraints.",
"If necessary all protons can be added to a protein molecule ",
"using the protonate program.[PAR]",
"The program always",
"computes the instantaneous violations rather than time-averaged,",
"because this analysis is done from a trajectory file afterwards",
"it does not make sense to use time averaging. However,",
"the time averaged values per restraint are given in the log file.[PAR]",
"An index file may be used to select specific restraints for",
"printing.[PAR]",
"When the optional[TT]-q[tt] flag is given a pdb file coloured by the",
"amount of average violations.[PAR]",
"When the [TT]-c[tt] option is given, an index file will be read",
"containing the frames in your trajectory corresponding to the clusters",
"(defined in another manner) that you want to analyze. For these clusters",
"the program will compute average violations using the third power",
"averaging algorithm and print them in the log file."
};
static int ntop = 0;
static int nlevels = 20;
static real max_dr = 0;
static gmx_bool bThird = TRUE;
t_pargs pa[] = {
{ "-ntop", FALSE, etINT, {&ntop},
"Number of large violations that are stored in the log file every step" },
{ "-maxdr", FALSE, etREAL, {&max_dr},
"Maximum distance violation in matrix output. If less than or equal to 0 the maximum will be determined by the data." },
{ "-nlevels", FALSE, etINT, {&nlevels},
"Number of levels in the matrix output" },
{ "-third", FALSE, etBOOL, {&bThird},
"Use inverse third power averaging or linear for matrix output" }
};
FILE *out=NULL,*aver=NULL,*numv=NULL,*maxxv=NULL,*xvg=NULL;
t_tpxheader header;
t_inputrec ir;
gmx_mtop_t mtop;
rvec *xtop;
gmx_localtop_t *top;
t_atoms *atoms=NULL;
t_forcerec *fr;
t_fcdata fcd;
t_nrnb nrnb;
t_commrec *cr;
t_graph *g;
int ntopatoms,natoms,i,j,kkk;
t_trxstatus *status;
real t;
rvec *x,*f,*xav=NULL;
matrix box;
gmx_bool bPDB;
int isize;
atom_id *index=NULL,*ind_fit=NULL;
char *grpname;
t_cluster_ndx *clust=NULL;
t_dr_result dr,*dr_clust=NULL;
char **leg;
real *vvindex=NULL,*w_rls=NULL;
t_mdatoms *mdatoms;
t_pbc pbc,*pbc_null;
int my_clust;
FILE *fplog;
output_env_t oenv;
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffREAD },
{ efXVG, "-ds", "drsum", ffWRITE },
{ efXVG, "-da", "draver", ffWRITE },
{ efXVG, "-dn", "drnum", ffWRITE },
{ efXVG, "-dm", "drmax", ffWRITE },
{ efXVG, "-dr", "restr", ffWRITE },
{ efLOG, "-l", "disres", ffWRITE },
{ efNDX, NULL, "viol", ffOPTRD },
{ efPDB, "-q", "viol", ffOPTWR },
{ efNDX, "-c", "clust", ffOPTRD },
{ efXPM, "-x", "matrix", ffOPTWR }
};
#define NFILE asize(fnm)
cr = init_par(&argc,&argv);
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE,fnm,asize(pa),pa,asize(desc),desc,0,NULL,&oenv);
gmx_log_open(ftp2fn(efLOG,NFILE,fnm),cr,FALSE,0,&fplog);
if (ntop)
init5(ntop);
read_tpxheader(ftp2fn(efTPX,NFILE,fnm),&header,FALSE,NULL,NULL);
snew(xtop,header.natoms);
read_tpx(ftp2fn(efTPX,NFILE,fnm),&ir,box,&ntopatoms,xtop,NULL,NULL,&mtop);
bPDB = opt2bSet("-q",NFILE,fnm);
if (bPDB) {
snew(xav,ntopatoms);
snew(ind_fit,ntopatoms);
snew(w_rls,ntopatoms);
for(kkk=0; (kkk<ntopatoms); kkk++) {
w_rls[kkk] = 1;
ind_fit[kkk] = kkk;
}
snew(atoms,1);
*atoms = gmx_mtop_global_atoms(&mtop);
if (atoms->pdbinfo == NULL) {
snew(atoms->pdbinfo,atoms->nr);
}
}
top = gmx_mtop_generate_local_top(&mtop,&ir);
g = NULL;
pbc_null = NULL;
if (ir.ePBC != epbcNONE) {
if (ir.bPeriodicMols)
pbc_null = &pbc;
else
g = mk_graph(fplog,&top->idef,0,mtop.natoms,FALSE,FALSE);
}
if (ftp2bSet(efNDX,NFILE,fnm)) {
rd_index(ftp2fn(efNDX,NFILE,fnm),1,&isize,&index,&grpname);
xvg=xvgropen(opt2fn("-dr",NFILE,fnm),"Inidividual Restraints","Time (ps)",
"nm",oenv);
snew(vvindex,isize);
snew(leg,isize);
for(i=0; (i<isize); i++) {
index[i]++;
snew(leg[i],12);
sprintf(leg[i],"index %d",index[i]);
}
xvgr_legend(xvg,isize,(const char**)leg,oenv);
}
else
isize=0;
ir.dr_tau=0.0;
init_disres(fplog,&mtop,&ir,NULL,FALSE,&fcd,NULL);
natoms=read_first_x(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
snew(f,5*natoms);
init_dr_res(&dr,fcd.disres.nres);
if (opt2bSet("-c",NFILE,fnm)) {
clust = cluster_index(fplog,opt2fn("-c",NFILE,fnm));
snew(dr_clust,clust->clust->nr+1);
for(i=0; (i<=clust->clust->nr); i++)
init_dr_res(&dr_clust[i],fcd.disres.nres);
}
else {
out =xvgropen(opt2fn("-ds",NFILE,fnm),
"Sum of Violations","Time (ps)","nm",oenv);
aver=xvgropen(opt2fn("-da",NFILE,fnm),
"Average Violation","Time (ps)","nm",oenv);
numv=xvgropen(opt2fn("-dn",NFILE,fnm),
"# Violations","Time (ps)","#",oenv);
maxxv=xvgropen(opt2fn("-dm",NFILE,fnm),
"Largest Violation","Time (ps)","nm",oenv);
}
mdatoms = init_mdatoms(fplog,&mtop,ir.efep!=efepNO);
atoms2md(&mtop,&ir,0,NULL,0,mtop.natoms,mdatoms);
update_mdatoms(mdatoms,ir.init_lambda);
fr = mk_forcerec();
fprintf(fplog,"Made forcerec\n");
init_forcerec(fplog,oenv,fr,NULL,&ir,&mtop,cr,box,FALSE,NULL,NULL,NULL,
FALSE,-1);
init_nrnb(&nrnb);
if (ir.ePBC != epbcNONE)
gpbc = gmx_rmpbc_init(&top->idef,ir.ePBC,natoms,box);
j=0;
do {
if (ir.ePBC != epbcNONE) {
if (ir.bPeriodicMols)
set_pbc(&pbc,ir.ePBC,box);
else
gmx_rmpbc(gpbc,natoms,box,x);
}
if (clust) {
if (j > clust->maxframe)
gmx_fatal(FARGS,"There are more frames in the trajectory than in the cluster index file. t = %8f\n",t);
my_clust = clust->inv_clust[j];
range_check(my_clust,0,clust->clust->nr);
check_viol(fplog,cr,&(top->idef.il[F_DISRES]),
top->idef.iparams,top->idef.functype,
x,f,fr,pbc_null,g,dr_clust,my_clust,isize,index,vvindex,&fcd);
}
else
check_viol(fplog,cr,&(top->idef.il[F_DISRES]),
top->idef.iparams,top->idef.functype,
x,f,fr,pbc_null,g,&dr,0,isize,index,vvindex,&fcd);
if (bPDB) {
reset_x(atoms->nr,ind_fit,atoms->nr,NULL,x,w_rls);
do_fit(atoms->nr,w_rls,x,x);
if (j == 0) {
/* Store the first frame of the trajectory as 'characteristic'
* for colouring with violations.
*/
for(kkk=0; (kkk<atoms->nr); kkk++)
copy_rvec(x[kkk],xav[kkk]);
}
}
if (!clust) {
if (isize > 0) {
fprintf(xvg,"%10g",t);
for(i=0; (i<isize); i++)
fprintf(xvg," %10g",vvindex[i]);
fprintf(xvg,"\n");
}
fprintf(out, "%10g %10g\n",t,dr.sumv);
fprintf(aver, "%10g %10g\n",t,dr.averv);
fprintf(maxxv,"%10g %10g\n",t,dr.maxv);
fprintf(numv, "%10g %10d\n",t,dr.nv);
}
j++;
} while (read_next_x(oenv,status,&t,natoms,x,box));
close_trj(status);
if (ir.ePBC != epbcNONE)
gmx_rmpbc_done(gpbc);
if (clust) {
dump_clust_stats(fplog,fcd.disres.nres,&(top->idef.il[F_DISRES]),
top->idef.iparams,clust->clust,dr_clust,
clust->grpname,isize,index);
}
else {
dump_stats(fplog,j,fcd.disres.nres,&(top->idef.il[F_DISRES]),
top->idef.iparams,&dr,isize,index,
bPDB ? atoms : NULL);
if (bPDB) {
write_sto_conf(opt2fn("-q",NFILE,fnm),
"Coloured by average violation in Angstrom",
atoms,xav,NULL,ir.ePBC,box);
}
dump_disre_matrix(opt2fn_null("-x",NFILE,fnm),&dr,fcd.disres.nres,
j,&top->idef,&mtop,max_dr,nlevels,bThird);
ffclose(out);
ffclose(aver);
ffclose(numv);
ffclose(maxxv);
if (isize > 0) {
ffclose(xvg);
do_view(oenv,opt2fn("-dr",NFILE,fnm),"-nxy");
}
do_view(oenv,opt2fn("-dn",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn("-da",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn("-ds",NFILE,fnm),"-nxy");
do_view(oenv,opt2fn("-dm",NFILE,fnm),"-nxy");
}
thanx(stderr);
if (gmx_parallel_env_initialized())
gmx_finalize();
gmx_log_close(fplog);
return 0;
}
int gmx_genion(int argc, char *argv[])
{
const char *desc[] = {
"[TT]genion[tt] replaces solvent molecules by monoatomic ions at",
"the position of the first atoms with the most favorable electrostatic",
"potential or at random. The potential is calculated on all atoms, using",
"normal GROMACS particle-based methods (in contrast to other methods",
"based on solving the Poisson-Boltzmann equation).",
"The potential is recalculated after every ion insertion.",
"If specified in the run input file, a reaction field, shift function",
"or user function can be used. For the user function a table file",
"can be specified with the option [TT]-table[tt].",
"The group of solvent molecules should be continuous and all molecules",
"should have the same number of atoms.",
"The user should add the ion molecules to the topology file or use",
"the [TT]-p[tt] option to automatically modify the topology.[PAR]",
"The ion molecule type, residue and atom names in all force fields",
"are the capitalized element names without sign. This molecule name",
"should be given with [TT]-pname[tt] or [TT]-nname[tt], and the",
"[TT][molecules][tt] section of your topology updated accordingly,",
"either by hand or with [TT]-p[tt]. Do not use an atom name instead!",
"[PAR]Ions which can have multiple charge states get the multiplicity",
"added, without sign, for the uncommon states only.[PAR]",
"With the option [TT]-pot[tt] the potential can be written as B-factors",
"in a [TT].pdb[tt] file (for visualisation using e.g. Rasmol).",
"The unit of the potential is 1000 kJ/(mol e), the scaling be changed",
"with the [TT]-scale[tt] option.[PAR]",
"For larger ions, e.g. sulfate we recommended using [TT]genbox[tt]."
};
const char *bugs[] = {
"Calculation of the potential is not reliable, therefore the [TT]-random[tt] option is now turned on by default.",
"If you specify a salt concentration existing ions are not taken into account. In effect you therefore specify the amount of salt to be added."
};
static int p_num = 0, n_num = 0, p_q = 1, n_q = -1;
static const char *p_name = "NA", *n_name = "CL";
static real rmin = 0.6, scale = 0.001, conc = 0;
static int seed = 1993;
static gmx_bool bRandom = TRUE, bNeutral = FALSE;
static t_pargs pa[] = {
{ "-np", FALSE, etINT, {&p_num}, "Number of positive ions" },
{ "-pname", FALSE, etSTR, {&p_name}, "Name of the positive ion" },
{ "-pq", FALSE, etINT, {&p_q}, "Charge of the positive ion" },
{ "-nn", FALSE, etINT, {&n_num}, "Number of negative ions" },
{ "-nname", FALSE, etSTR, {&n_name}, "Name of the negative ion" },
{ "-nq", FALSE, etINT, {&n_q}, "Charge of the negative ion" },
{ "-rmin", FALSE, etREAL, {&rmin}, "Minimum distance between ions" },
{ "-random", FALSE, etBOOL, {&bRandom}, "Use random placement of ions instead of based on potential. The rmin option should still work" },
{ "-seed", FALSE, etINT, {&seed}, "Seed for random number generator" },
{ "-scale", FALSE, etREAL, {&scale}, "Scaling factor for the potential for [TT]-pot[tt]" },
{ "-conc", FALSE, etREAL, {&conc},
"Specify salt concentration (mol/liter). This will add sufficient ions to reach up to the specified concentration as computed from the volume of the cell in the input [TT].tpr[tt] file. Overrides the [TT]-np[tt] and [TT]-nn[tt] options." },
{ "-neutral", FALSE, etBOOL, {&bNeutral}, "This option will add enough ions to neutralize the system. These ions are added on top of those specified with [TT]-np[tt]/[TT]-nn[tt] or [TT]-conc[tt]. "}
};
gmx_mtop_t *mtop;
gmx_localtop_t *top;
t_inputrec inputrec;
t_commrec *cr;
t_mdatoms *mdatoms;
gmx_enerdata_t enerd;
t_graph *graph;
t_forcerec *fr;
rvec *x, *v;
real *pot, vol, qtot;
matrix box;
t_atoms atoms;
t_pbc pbc;
int *repl;
atom_id *index;
char *grpname;
gmx_bool *bSet, bPDB;
int i, nw, nwa, nsa, nsalt, iqtot;
FILE *fplog;
output_env_t oenv;
t_filenm fnm[] = {
{ efTPX, NULL, NULL, ffREAD },
{ efXVG, "-table", "table", ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTO, "-o", NULL, ffWRITE },
{ efLOG, "-g", "genion", ffWRITE },
{ efPDB, "-pot", "pot", ffOPTWR },
{ efTOP, "-p", "topol", ffOPTRW }
};
#define NFILE asize(fnm)
parse_common_args(&argc, argv, PCA_BE_NICE, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bPDB = ftp2bSet(efPDB, NFILE, fnm);
if (bRandom && bPDB)
{
fprintf(stderr, "Not computing potential with random option!\n");
bPDB = FALSE;
}
/* Check input for something sensible */
if ((p_num < 0) || (n_num < 0))
{
gmx_fatal(FARGS, "Negative number of ions to add?");
}
snew(mtop, 1);
snew(top, 1);
fplog = init_calcpot(ftp2fn(efLOG, NFILE, fnm), ftp2fn(efTPX, NFILE, fnm),
opt2fn("-table", NFILE, fnm), mtop, top, &inputrec, &cr,
&graph, &mdatoms, &fr, &enerd, &pot, box, &x, oenv);
atoms = gmx_mtop_global_atoms(mtop);
qtot = 0;
for (i = 0; (i < atoms.nr); i++)
{
qtot += atoms.atom[i].q;
}
iqtot = gmx_nint(qtot);
if (conc > 0)
{
/* Compute number of ions to be added */
vol = det(box);
nsalt = gmx_nint(conc*vol*AVOGADRO/1e24);
p_num = abs(nsalt*n_q);
n_num = abs(nsalt*p_q);
}
if (bNeutral)
{
int qdelta = p_num*p_q + n_num*n_q + iqtot;
/* Check if the system is neutralizable
* is (qdelta == p_q*p_num + n_q*n_num) solvable for p_num and n_num? */
int gcd = greatest_common_divisor(n_q, p_q);
if ((qdelta % gcd) != 0)
{
gmx_fatal(FARGS, "Can't neutralize this system using -nq %d and"
" -pq %d.\n", n_q, p_q);
}
while (qdelta != 0)
{
while (qdelta < 0)
{
p_num++;
qdelta += p_q;
}
while (qdelta > 0)
{
n_num++;
qdelta += n_q;
}
}
}
if ((p_num == 0) && (n_num == 0))
{
if (!bPDB)
{
fprintf(stderr, "No ions to add and no potential to calculate.\n");
exit(0);
}
nw = 0;
nsa = 0; /* to keep gcc happy */
}
else
{
printf("Will try to add %d %s ions and %d %s ions.\n",
p_num, p_name, n_num, n_name);
printf("Select a continuous group of solvent molecules\n");
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1, &nwa, &index, &grpname);
for (i = 1; i < nwa; i++)
{
if (index[i] != index[i-1]+1)
{
gmx_fatal(FARGS, "The solvent group %s is not continuous: "
"index[%d]=%d, index[%d]=%d",
grpname, i, index[i-1]+1, i+1, index[i]+1);
}
}
nsa = 1;
while ((nsa < nwa) &&
(atoms.atom[index[nsa]].resind ==
atoms.atom[index[nsa-1]].resind))
{
nsa++;
}
if (nwa % nsa)
{
gmx_fatal(FARGS, "Your solvent group size (%d) is not a multiple of %d",
nwa, nsa);
}
nw = nwa/nsa;
fprintf(stderr, "Number of (%d-atomic) solvent molecules: %d\n", nsa, nw);
if (p_num+n_num > nw)
{
gmx_fatal(FARGS, "Not enough solvent for adding ions");
}
}
if (opt2bSet("-p", NFILE, fnm))
{
update_topol(opt2fn("-p", NFILE, fnm), p_num, n_num, p_name, n_name, grpname);
}
snew(bSet, nw);
snew(repl, nw);
snew(v, atoms.nr);
snew(atoms.pdbinfo, atoms.nr);
set_pbc(&pbc, inputrec.ePBC, box);
/* Now loop over the ions that have to be placed */
do
{
if (!bRandom)
{
calc_pot(fplog, cr, mtop, &inputrec, top, x, fr, &enerd, mdatoms, pot, box, graph);
if (bPDB || debug)
{
char buf[STRLEN];
if (debug)
{
sprintf(buf, "%d_%s", p_num+n_num, ftp2fn(efPDB, NFILE, fnm));
}
else
{
strcpy(buf, ftp2fn(efPDB, NFILE, fnm));
}
for (i = 0; (i < atoms.nr); i++)
{
atoms.pdbinfo[i].bfac = pot[i]*scale;
}
write_sto_conf(buf, "Potential calculated by genion",
&atoms, x, v, inputrec.ePBC, box);
bPDB = FALSE;
}
}
if ((p_num > 0) && (p_num >= n_num))
{
insert_ion(nsa, &nw, bSet, repl, index, pot, x, &pbc,
1, p_q, p_name, mdatoms, rmin, bRandom, &seed);
p_num--;
}
else if (n_num > 0)
{
insert_ion(nsa, &nw, bSet, repl, index, pot, x, &pbc,
-1, n_q, n_name, mdatoms, rmin, bRandom, &seed);
n_num--;
}
}
while (p_num+n_num > 0);
fprintf(stderr, "\n");
if (nw)
{
sort_ions(nsa, nw, repl, index, &atoms, x, p_name, n_name);
}
sfree(atoms.pdbinfo);
atoms.pdbinfo = NULL;
write_sto_conf(ftp2fn(efSTO, NFILE, fnm), *mtop->name, &atoms, x, NULL,
inputrec.ePBC, box);
thanx(stderr);
gmx_log_close(fplog);
return 0;
}
void init_membed(FILE *fplog, gmx_membed_t *membed, int nfile, const t_filenm fnm[], gmx_mtop_t *mtop, t_inputrec *inputrec, t_state *state, t_commrec *cr,real *cpt)
{
char *ins;
int i,rm_bonded_at,fr_id,fr_i=0,tmp_id,warn=0;
int ng,j,max_lip_rm,ins_grp_id,ins_nat,mem_nat,ntype,lip_rm,tpr_version;
real prot_area;
rvec *r_ins=NULL;
t_block *ins_at,*rest_at;
pos_ins_t *pos_ins;
mem_t *mem_p;
rm_t *rm_p;
gmx_groups_t *groups;
gmx_bool bExcl=FALSE;
t_atoms atoms;
t_pbc *pbc;
char **piecename=NULL;
/* input variables */
const char *membed_input;
real xy_fac = 0.5;
real xy_max = 1.0;
real z_fac = 1.0;
real z_max = 1.0;
int it_xy = 1000;
int it_z = 0;
real probe_rad = 0.22;
int low_up_rm = 0;
int maxwarn=0;
int pieces=1;
gmx_bool bALLOW_ASYMMETRY=FALSE;
snew(ins_at,1);
snew(pos_ins,1);
if(MASTER(cr))
{
/* get input data out membed file */
membed_input = opt2fn("-membed",nfile,fnm);
get_input(membed_input,&xy_fac,&xy_max,&z_fac,&z_max,&it_xy,&it_z,&probe_rad,&low_up_rm,&maxwarn,&pieces,&bALLOW_ASYMMETRY);
tpr_version = get_tpr_version(ftp2fn(efTPX,nfile,fnm));
if (tpr_version<58)
gmx_fatal(FARGS,"Version of *.tpr file to old (%d). Rerun grompp with gromacs VERSION 4.0.3 or newer.\n",tpr_version);
if( !EI_DYNAMICS(inputrec->eI) )
gmx_input("Change integrator to a dynamics integrator in mdp file (e.g. md or sd).");
if(PAR(cr))
gmx_input("Sorry, parallel g_membed is not yet fully functional.");
#ifdef GMX_OPENMM
gmx_input("Sorry, g_membed does not work with openmm.");
#endif
if(*cpt>=0)
{
fprintf(stderr,"\nSetting -cpt to -1, because embedding cannot be restarted from cpt-files.\n");
*cpt=-1;
}
groups=&(mtop->groups);
atoms=gmx_mtop_global_atoms(mtop);
snew(mem_p,1);
fprintf(stderr,"\nSelect a group to embed in the membrane:\n");
get_index(&atoms,opt2fn_null("-mn",nfile,fnm),1,&(ins_at->nr),&(ins_at->index),&ins);
ins_grp_id = search_string(ins,groups->ngrpname,(groups->grpname));
fprintf(stderr,"\nSelect a group to embed %s into (e.g. the membrane):\n",ins);
get_index(&atoms,opt2fn_null("-mn",nfile,fnm),1,&(mem_p->mem_at.nr),&(mem_p->mem_at.index),&(mem_p->name));
pos_ins->pieces=pieces;
snew(pos_ins->nidx,pieces);
snew(pos_ins->subindex,pieces);
snew(piecename,pieces);
if (pieces>1)
{
fprintf(stderr,"\nSelect pieces to embed:\n");
get_index(&atoms,opt2fn_null("-mn",nfile,fnm),pieces,pos_ins->nidx,pos_ins->subindex,piecename);
}
else
{
/*use whole embedded group*/
snew(pos_ins->nidx,1);
snew(pos_ins->subindex,1);
pos_ins->nidx[0]=ins_at->nr;
pos_ins->subindex[0]=ins_at->index;
}
if(probe_rad<0.2199999)
{
warn++;
fprintf(stderr,"\nWarning %d:\nA probe radius (-rad) smaller than 0.2 can result in overlap between waters "
"and the group to embed, which will result in Lincs errors etc.\nIf you are sure, you can increase maxwarn.\n\n",warn);
}
if(xy_fac<0.09999999)
{
warn++;
fprintf(stderr,"\nWarning %d:\nThe initial size of %s is probably too smal.\n"
"If you are sure, you can increase maxwarn.\n\n",warn,ins);
}
if(it_xy<1000)
{
warn++;
fprintf(stderr,"\nWarning %d;\nThe number of steps used to grow the xy-coordinates of %s (%d) is probably too small.\n"
"Increase -nxy or, if you are sure, you can increase maxwarn.\n\n",warn,ins,it_xy);
}
if( (it_z<100) && ( z_fac<0.99999999 || z_fac>1.0000001) )
{
warn++;
fprintf(stderr,"\nWarning %d;\nThe number of steps used to grow the z-coordinate of %s (%d) is probably too small.\n"
"Increase -nz or, if you are sure, you can increase maxwarn.\n\n",warn,ins,it_z);
}
if(it_xy+it_z>inputrec->nsteps)
{
warn++;
fprintf(stderr,"\nWarning %d:\nThe number of growth steps (-nxy + -nz) is larger than the number of steps in the tpr.\n"
"If you are sure, you can increase maxwarn.\n\n",warn);
}
fr_id=-1;
if( inputrec->opts.ngfrz==1)
gmx_fatal(FARGS,"You did not specify \"%s\" as a freezegroup.",ins);
for(i=0;i<inputrec->opts.ngfrz;i++)
{
tmp_id = mtop->groups.grps[egcFREEZE].nm_ind[i];
if(ins_grp_id==tmp_id)
{
fr_id=tmp_id;
fr_i=i;
}
}
if (fr_id == -1 )
gmx_fatal(FARGS,"\"%s\" not as freezegroup defined in the mdp-file.",ins);
for(i=0;i<DIM;i++)
if( inputrec->opts.nFreeze[fr_i][i] != 1)
gmx_fatal(FARGS,"freeze dimensions for %s are not Y Y Y\n",ins);
ng = groups->grps[egcENER].nr;
if (ng == 1)
gmx_input("No energy groups defined. This is necessary for energy exclusion in the freeze group");
for(i=0;i<ng;i++)
{
for(j=0;j<ng;j++)
{
if (inputrec->opts.egp_flags[ng*i+j] == EGP_EXCL)
{
bExcl = TRUE;
if ( (groups->grps[egcENER].nm_ind[i] != ins_grp_id) || (groups->grps[egcENER].nm_ind[j] != ins_grp_id) )
gmx_fatal(FARGS,"Energy exclusions \"%s\" and \"%s\" do not match the group to embed \"%s\"",
*groups->grpname[groups->grps[egcENER].nm_ind[i]],
*groups->grpname[groups->grps[egcENER].nm_ind[j]],ins);
}
}
}
if (!bExcl)
gmx_input("No energy exclusion groups defined. This is necessary for energy exclusion in the freeze group");
/* Guess the area the protein will occupy in the membrane plane Calculate area per lipid*/
snew(rest_at,1);
ins_nat = init_ins_at(ins_at,rest_at,state,pos_ins,groups,ins_grp_id,xy_max);
/* Check moleculetypes in insertion group */
check_types(ins_at,rest_at,mtop);
mem_nat = init_mem_at(mem_p,mtop,state->x,state->box,pos_ins);
prot_area = est_prot_area(pos_ins,state->x,ins_at,mem_p);
if ( (prot_area>7.5) && ( (state->box[XX][XX]*state->box[YY][YY]-state->box[XX][YY]*state->box[YY][XX])<50) )
{
warn++;
fprintf(stderr,"\nWarning %d:\nThe xy-area is very small compared to the area of the protein.\n"
"This might cause pressure problems during the growth phase. Just try with\n"
"current setup (-maxwarn + 1), but if pressure problems occur, lower the\n"
"compressibility in the mdp-file or use no pressure coupling at all.\n\n",warn);
}
if(warn>maxwarn)
gmx_fatal(FARGS,"Too many warnings.\n");
printf("The estimated area of the protein in the membrane is %.3f nm^2\n",prot_area);
printf("\nThere are %d lipids in the membrane part that overlaps the protein.\nThe area per lipid is %.4f nm^2.\n",mem_p->nmol,mem_p->lip_area);
/* Maximum number of lipids to be removed*/
max_lip_rm=(int)(2*prot_area/mem_p->lip_area);
printf("Maximum number of lipids that will be removed is %d.\n",max_lip_rm);
printf("\nWill resize the protein by a factor of %.3f in the xy plane and %.3f in the z direction.\n"
"This resizing will be done with respect to the geometrical center of all protein atoms\n"
"that span the membrane region, i.e. z between %.3f and %.3f\n\n",xy_fac,z_fac,mem_p->zmin,mem_p->zmax);
/* resize the protein by xy and by z if necessary*/
snew(r_ins,ins_at->nr);
init_resize(ins_at,r_ins,pos_ins,mem_p,state->x,bALLOW_ASYMMETRY);
membed->fac[0]=membed->fac[1]=xy_fac;
membed->fac[2]=z_fac;
membed->xy_step =(xy_max-xy_fac)/(double)(it_xy);
membed->z_step =(z_max-z_fac)/(double)(it_z-1);
resize(r_ins,state->x,pos_ins,membed->fac);
/* remove overlapping lipids and water from the membrane box*/
/*mark molecules to be removed*/
snew(pbc,1);
set_pbc(pbc,inputrec->ePBC,state->box);
snew(rm_p,1);
lip_rm = gen_rm_list(rm_p,ins_at,rest_at,pbc,mtop,state->x, r_ins, mem_p,pos_ins,probe_rad,low_up_rm,bALLOW_ASYMMETRY);
lip_rm -= low_up_rm;
if(fplog)
for(i=0;i<rm_p->nr;i++)
fprintf(fplog,"rm mol %d\n",rm_p->mol[i]);
for(i=0;i<mtop->nmolblock;i++)
{
ntype=0;
for(j=0;j<rm_p->nr;j++)
if(rm_p->block[j]==i)
ntype++;
printf("Will remove %d %s molecules\n",ntype,*(mtop->moltype[mtop->molblock[i].type].name));
}
if(lip_rm>max_lip_rm)
{
warn++;
fprintf(stderr,"\nWarning %d:\nTrying to remove a larger lipid area than the estimated protein area\n"
"Try making the -xyinit resize factor smaller.\n\n",warn);
}
/*remove all lipids and waters overlapping and update all important structures*/
rm_group(inputrec,groups,mtop,rm_p,state,ins_at,pos_ins);
rm_bonded_at = rm_bonded(ins_at,mtop);
if (rm_bonded_at != ins_at->nr)
{
fprintf(stderr,"Warning: The number of atoms for which the bonded interactions are removed is %d, "
"while %d atoms are embedded. Make sure that the atoms to be embedded are not in the same"
"molecule type as atoms that are not to be embedded.\n",rm_bonded_at,ins_at->nr);
}
if(warn>maxwarn)
gmx_fatal(FARGS,"Too many warnings.\nIf you are sure these warnings are harmless, you can increase -maxwarn");
if (ftp2bSet(efTOP,nfile,fnm))
top_update(opt2fn("-mp",nfile,fnm),ins,rm_p,mtop);
sfree(pbc);
sfree(rest_at);
if (pieces>1) { sfree(piecename); }
membed->it_xy=it_xy;
membed->it_z=it_z;
membed->pos_ins=pos_ins;
membed->r_ins=r_ins;
}
}
void read_stx_conf(const char *infile, char *title, t_atoms *atoms,
rvec x[], rvec *v, int *ePBC, matrix box)
{
FILE *in;
char buf[256];
gmx_mtop_t *mtop;
t_topology top;
t_trxframe fr;
int i, ftp, natoms;
real d;
char g96_line[STRLEN+1];
if (atoms->nr == 0)
{
fprintf(stderr, "Warning: Number of atoms in %s is 0\n", infile);
}
else if (atoms->atom == NULL)
{
gmx_mem("Uninitialized array atom");
}
if (ePBC)
{
*ePBC = -1;
}
ftp = fn2ftp(infile);
switch (ftp)
{
case efGRO:
read_whole_conf(infile, title, atoms, x, v, box);
break;
case efG96:
fr.title = NULL;
fr.natoms = atoms->nr;
fr.atoms = atoms;
fr.x = x;
fr.v = v;
fr.f = NULL;
in = gmx_fio_fopen(infile, "r");
read_g96_conf(in, infile, &fr, g96_line);
gmx_fio_fclose(in);
copy_mat(fr.box, box);
strncpy(title, fr.title, STRLEN);
break;
case efPDB:
case efBRK:
case efENT:
read_pdb_conf(infile, title, atoms, x, ePBC, box, TRUE, NULL);
break;
case efESP:
read_espresso_conf(infile, atoms, x, v, box);
break;
case efTPR:
case efTPB:
case efTPA:
snew(mtop, 1);
i = read_tpx(infile, NULL, box, &natoms, x, v, NULL, mtop);
if (ePBC)
{
*ePBC = i;
}
strcpy(title, *(mtop->name));
/* Free possibly allocated memory */
done_atom(atoms);
*atoms = gmx_mtop_global_atoms(mtop);
top = gmx_mtop_t_to_t_topology(mtop);
tpx_make_chain_identifiers(atoms, &top.mols);
sfree(mtop);
/* The strings in the symtab are still in use in the returned t_atoms
* structure, so we should not free them. But there is no place to put the
* symbols; the only choice is to leak the memory...
* So we clear the symbol table before freeing the topology structure. */
free_symtab(&top.symtab);
done_top(&top);
break;
default:
gmx_incons("Not supported in read_stx_conf");
}
}
void read_stx_conf(char *infile, char *title,t_atoms *atoms,
rvec x[],rvec *v,int *ePBC,matrix box)
{
FILE *in;
char buf[256];
gmx_mtop_t *mtop;
t_topology top;
t_trxframe fr;
int i,ftp,natoms,i1;
real d,r1,r2;
if (atoms->nr == 0)
fprintf(stderr,"Warning: Number of atoms in %s is 0\n",infile);
else if (atoms->atom == NULL)
gmx_mem("Uninitialized array atom");
if (ePBC)
*ePBC = -1;
ftp=fn2ftp(infile);
switch (ftp) {
case efGRO:
read_whole_conf(infile, title, atoms, x, v, box);
break;
case efG96:
fr.title = title;
fr.natoms = atoms->nr;
fr.atoms = atoms;
fr.x = x;
fr.v = v;
fr.f = NULL;
in = gmx_fio_fopen(infile,"r");
read_g96_conf(in, infile, &fr);
gmx_fio_fclose(in);
copy_mat(fr.box,box);
break;
case efPDB:
case efBRK:
case efENT:
read_pdb_conf(infile, title, atoms, x, ePBC, box, TRUE, NULL);
break;
case efESP:
read_espresso_conf(infile,atoms,x,v,box);
break;
case efTPR:
case efTPB:
case efTPA:
snew(mtop,1);
i = read_tpx(infile,&i1,&r1,&r2,NULL,box,&natoms,x,v,NULL,mtop);
if (ePBC)
*ePBC = i;
strcpy(title,*(mtop->name));
/* Free possibly allocated memory */
done_atom(atoms);
*atoms = gmx_mtop_global_atoms(mtop);
top = gmx_mtop_t_to_t_topology(mtop);
tpx_make_chain_identifiers(atoms,&top.mols);
sfree(mtop);
done_top(&top);
break;
default:
gmx_incons("Not supported in read_stx_conf");
}
}
int gmx_convert_tpr(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] can edit run input files in three ways.[PAR]",
"[BB]1.[bb] by modifying the number of steps in a run input file",
"with options [TT]-extend[tt], [TT]-until[tt] or [TT]-nsteps[tt]",
"(nsteps=-1 means unlimited number of steps)[PAR]",
"[BB]2.[bb] by creating a [REF].tpx[ref] file for a subset of your original",
"tpx file, which is useful when you want to remove the solvent from",
"your [REF].tpx[ref] file, or when you want to make e.g. a pure C[GRK]alpha[grk] [REF].tpx[ref] file.",
"Note that you may need to use [TT]-nsteps -1[tt] (or similar) to get",
"this to work.",
"[BB]WARNING: this [REF].tpx[ref] file is not fully functional[bb].[PAR]",
"[BB]3.[bb] by setting the charges of a specified group",
"to zero. This is useful when doing free energy estimates",
"using the LIE (Linear Interaction Energy) method."
};
const char *top_fn;
int i;
gmx_int64_t nsteps_req, run_step;
double run_t, state_t;
gmx_bool bSel;
gmx_bool bNsteps, bExtend, bUntil;
gmx_mtop_t mtop;
t_atoms atoms;
t_inputrec *ir;
t_state state;
int gnx;
char *grpname;
int *index = NULL;
char buf[200], buf2[200];
gmx_output_env_t *oenv;
t_filenm fnm[] = {
{ efTPR, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTPR, "-o", "tprout", ffWRITE }
};
#define NFILE asize(fnm)
/* Command line options */
static int nsteps_req_int = 0;
static real extend_t = 0.0, until_t = 0.0;
static gmx_bool bZeroQ = FALSE;
static t_pargs pa[] = {
{ "-extend", FALSE, etREAL, {&extend_t},
"Extend runtime by this amount (ps)" },
{ "-until", FALSE, etREAL, {&until_t},
"Extend runtime until this ending time (ps)" },
{ "-nsteps", FALSE, etINT, {&nsteps_req_int},
"Change the number of steps" },
{ "-zeroq", FALSE, etBOOL, {&bZeroQ},
"Set the charges of a group (from the index) to zero" }
};
/* Parse the command line */
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
/* Convert int to gmx_int64_t */
nsteps_req = nsteps_req_int;
bNsteps = opt2parg_bSet("-nsteps", asize(pa), pa);
bExtend = opt2parg_bSet("-extend", asize(pa), pa);
bUntil = opt2parg_bSet("-until", asize(pa), pa);
top_fn = ftp2fn(efTPR, NFILE, fnm);
fprintf(stderr, "Reading toplogy and stuff from %s\n", top_fn);
gmx::MDModules mdModules;
ir = mdModules.inputrec();
read_tpx_state(top_fn, ir, &state, &mtop);
run_step = ir->init_step;
run_t = ir->init_step*ir->delta_t + ir->init_t;
if (bNsteps)
{
fprintf(stderr, "Setting nsteps to %s\n", gmx_step_str(nsteps_req, buf));
ir->nsteps = nsteps_req;
}
else
{
/* Determine total number of steps remaining */
if (bExtend)
{
ir->nsteps = ir->nsteps - (run_step - ir->init_step) + (gmx_int64_t)(extend_t/ir->delta_t + 0.5);
printf("Extending remaining runtime of by %g ps (now %s steps)\n",
extend_t, gmx_step_str(ir->nsteps, buf));
}
else if (bUntil)
{
printf("nsteps = %s, run_step = %s, current_t = %g, until = %g\n",
gmx_step_str(ir->nsteps, buf),
gmx_step_str(run_step, buf2),
run_t, until_t);
ir->nsteps = (gmx_int64_t)((until_t - run_t)/ir->delta_t + 0.5);
printf("Extending remaining runtime until %g ps (now %s steps)\n",
until_t, gmx_step_str(ir->nsteps, buf));
}
else
{
ir->nsteps -= run_step - ir->init_step;
/* Print message */
printf("%s steps (%g ps) remaining from first run.\n",
gmx_step_str(ir->nsteps, buf), ir->nsteps*ir->delta_t);
}
}
if (bNsteps || bZeroQ || (ir->nsteps > 0))
{
ir->init_step = run_step;
if (ftp2bSet(efNDX, NFILE, fnm) ||
!(bNsteps || bExtend || bUntil))
{
atoms = gmx_mtop_global_atoms(&mtop);
get_index(&atoms, ftp2fn_null(efNDX, NFILE, fnm), 1,
&gnx, &index, &grpname);
if (!bZeroQ)
{
bSel = (gnx != state.natoms);
for (i = 0; ((i < gnx) && (!bSel)); i++)
{
bSel = (i != index[i]);
}
}
else
{
bSel = FALSE;
}
if (bSel)
{
fprintf(stderr, "Will write subset %s of original tpx containing %d "
"atoms\n", grpname, gnx);
reduce_topology_x(gnx, index, &mtop, as_rvec_array(state.x.data()), as_rvec_array(state.v.data()));
state.natoms = gnx;
}
else if (bZeroQ)
{
zeroq(index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
{
fprintf(stderr, "Will write full tpx file (no selection)\n");
}
}
state_t = ir->init_t + ir->init_step*ir->delta_t;
sprintf(buf, "Writing statusfile with starting step %s%s and length %s%s steps...\n", "%10", GMX_PRId64, "%10", GMX_PRId64);
fprintf(stderr, buf, ir->init_step, ir->nsteps);
fprintf(stderr, " time %10.3f and length %10.3f ps\n",
state_t, ir->nsteps*ir->delta_t);
write_tpx_state(opt2fn("-o", NFILE, fnm), ir, &state, &mtop);
}
else
{
printf("You've simulated long enough. Not writing tpr file\n");
}
return 0;
}
