void visualize_images(const char *fn, int ePBC, matrix box)
{
t_atoms atoms;
rvec *img;
char *c, *ala;
int nat, i;
nat = NTRICIMG + 1;
init_t_atoms(&atoms, nat, FALSE);
atoms.nr = nat;
snew(img, nat);
/* FIXME: Constness should not be cast away */
c = (char *) "C";
ala = (char *) "ALA";
for (i = 0; i < nat; i++)
{
atoms.atomname[i] = &c;
atoms.atom[i].resind = i;
atoms.resinfo[i].name = &ala;
atoms.resinfo[i].nr = i + 1;
atoms.resinfo[i].chainid = 'A' + i / NCUCVERT;
}
calc_triclinic_images(box, img + 1);
write_sto_conf(fn, "Images", &atoms, img, NULL, ePBC, box);
done_atom(&atoms);
sfree(img);
}
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;
}
}
void write_bfactors(t_filenm *fnm, int nfile, atom_id *index, atom_id *a, int nslices, int ngrps, real **order, t_topology *top, real **distvals, gmx_output_env_t *oenv)
{
/*function to write order parameters as B factors in PDB file using
first frame of trajectory*/
t_trxstatus *status;
t_trxframe fr, frout;
t_atoms useatoms;
int i, j, ctr, nout;
ngrps -= 2; /*we don't have an order parameter for the first or
last atom in each chain*/
nout = nslices*ngrps;
read_first_frame(oenv, &status, ftp2fn(efTRX, nfile, fnm), &fr, TRX_NEED_X);
close_trj(status);
frout = fr;
frout.natoms = nout;
frout.bF = FALSE;
frout.bV = FALSE;
frout.x = 0;
snew(frout.x, nout);
init_t_atoms(&useatoms, nout, TRUE);
useatoms.nr = nout;
/*initialize PDBinfo*/
for (i = 0; i < useatoms.nr; ++i)
{
useatoms.pdbinfo[i].type = 0;
useatoms.pdbinfo[i].occup = 0.0;
useatoms.pdbinfo[i].bfac = 0.0;
useatoms.pdbinfo[i].bAnisotropic = FALSE;
}
for (j = 0, ctr = 0; j < nslices; j++)
{
for (i = 0; i < ngrps; i++, ctr++)
{
/*iterate along each chain*/
useatoms.pdbinfo[ctr].bfac = order[j][i+1];
if (distvals)
{
useatoms.pdbinfo[ctr].occup = distvals[j][i+1];
}
copy_rvec(fr.x[a[index[i+1]+j]], frout.x[ctr]);
useatoms.atomname[ctr] = top->atoms.atomname[a[index[i+1]+j]];
useatoms.atom[ctr] = top->atoms.atom[a[index[i+1]+j]];
useatoms.nres = std::max(useatoms.nres, useatoms.atom[ctr].resind+1);
useatoms.resinfo[useatoms.atom[ctr].resind] = top->atoms.resinfo[useatoms.atom[ctr].resind]; /*copy resinfo*/
}
}
write_sto_conf(opt2fn("-ob", nfile, fnm), "Order parameters", &useatoms, frout.x, NULL, frout.ePBC, frout.box);
sfree(frout.x);
done_atom(&useatoms);
}
void done_mi(t_molinfo *mi)
{
int i;
done_atom (&(mi->atoms));
done_block(&(mi->cgs));
done_block(&(mi->mols));
for(i=0; (i<F_NRE); i++)
done_bt(&(mi->plist[i]));
}
void done_moltype(gmx_moltype_t *molt)
{
done_atom(&molt->atoms);
done_block(&molt->cgs);
done_blocka(&molt->excls);
for (int f = 0; f < F_NRE; f++)
{
sfree(molt->ilist[f].iatoms);
molt->ilist[f].nalloc = 0;
}
}
void done_top(t_topology *top)
{
int i;
done_atom (&(top->atoms));
/* For GB */
done_atomtypes(&(top->atomtypes));
done_symtab(&(top->symtab));
done_block(&(top->cgs));
done_block(&(top->mols));
done_blocka(&(top->excls));
}
void done_top(t_topology *top)
{
sfree(top->idef.functype);
sfree(top->idef.iparams);
for (int f = 0; f < F_NRE; ++f)
{
sfree(top->idef.il[f].iatoms);
top->idef.il[f].iatoms = NULL;
top->idef.il[f].nalloc = 0;
}
done_atom(&(top->atoms));
/* For GB */
done_atomtypes(&(top->atomtypes));
done_symtab(&(top->symtab));
done_block(&(top->cgs));
done_block(&(top->mols));
done_blocka(&(top->excls));
}
void add_conf(t_atoms *atoms, rvec **x, rvec **v, real **r, gmx_bool bSrenew,
int ePBC, matrix box, gmx_bool bInsert,
t_atoms *atoms_solvt, rvec *x_solvt, rvec *v_solvt, real *r_solvt,
gmx_bool bVerbose, real rshell, int max_sol, const output_env_t oenv)
{
t_nblist *nlist;
t_atoms *atoms_all;
real max_vdw, *r_prot, *r_all, n2, r2, ib1, ib2;
int natoms_prot, natoms_solvt;
int i, j, jj, m, j0, j1, jjj, jnres, jnr, inr, iprot, is1, is2;
int prev, resnr, nresadd, d, k, ncells, maxincell;
int dx0, dx1, dy0, dy1, dz0, dz1;
int ntest, nremove, nkeep;
rvec dx, xi, xj, xpp, *x_all, *v_all;
gmx_bool *remove, *keep;
int bSolSol;
natoms_prot = atoms->nr;
natoms_solvt = atoms_solvt->nr;
if (natoms_solvt <= 0)
{
fprintf(stderr, "WARNING: Nothing to add\n");
return;
}
if (ePBC == epbcSCREW)
{
gmx_fatal(FARGS, "Sorry, %s pbc is not yet supported", epbc_names[ePBC]);
}
if (bVerbose)
{
fprintf(stderr, "Calculating Overlap...\n");
}
/* Set margin around box edges to largest solvent dimension.
* The maximum distance between atoms in a solvent molecule should
* be calculated. At the moment a fudge factor of 3 is used.
*/
r_prot = *r;
box_margin = 3*find_max_real(natoms_solvt, r_solvt);
max_vdw = max(3*find_max_real(natoms_prot, r_prot), box_margin);
fprintf(stderr, "box_margin = %g\n", box_margin);
snew(remove, natoms_solvt);
nremove = 0;
if (!bInsert)
{
for (i = 0; i < atoms_solvt->nr; i++)
{
if (outside_box_plus_margin(x_solvt[i], box) )
{
i = mark_res(i, remove, atoms_solvt->nr, atoms_solvt->atom, &nremove);
}
}
fprintf(stderr, "Removed %d atoms that were outside the box\n", nremove);
}
/* Define grid stuff for genbox */
/* Largest VDW radius */
snew(r_all, natoms_prot+natoms_solvt);
for (i = j = 0; i < natoms_prot; i++, j++)
{
r_all[j] = r_prot[i];
}
for (i = 0; i < natoms_solvt; i++, j++)
{
r_all[j] = r_solvt[i];
}
/* Combine arrays */
combine_atoms(atoms, atoms_solvt, *x, v ? *v : NULL, x_solvt, v_solvt,
&atoms_all, &x_all, &v_all);
/* Do neighboursearching step */
do_nsgrid(stdout, bVerbose, box, x_all, atoms_all, max_vdw, oenv);
/* check solvent with solute */
nlist = &(fr->nblists[0].nlist_sr[eNL_VDW]);
fprintf(stderr, "nri = %d, nrj = %d\n", nlist->nri, nlist->nrj);
for (bSolSol = 0; (bSolSol <= (bInsert ? 0 : 1)); bSolSol++)
{
ntest = nremove = 0;
fprintf(stderr, "Checking %s-Solvent overlap:",
bSolSol ? "Solvent" : "Protein");
for (i = 0; (i < nlist->nri && nremove < natoms_solvt); i++)
{
inr = nlist->iinr[i];
j0 = nlist->jindex[i];
j1 = nlist->jindex[i+1];
rvec_add(x_all[inr], fr->shift_vec[nlist->shift[i]], xi);
for (j = j0; (j < j1 && nremove < natoms_solvt); j++)
{
jnr = nlist->jjnr[j];
copy_rvec(x_all[jnr], xj);
/* Check solvent-protein and solvent-solvent */
is1 = inr-natoms_prot;
is2 = jnr-natoms_prot;
/* Check if at least one of the atoms is a solvent that is not yet
* listed for removal, and if both are solvent, that they are not in the
* same residue.
*/
if ((!bSolSol &&
bXor((is1 >= 0), (is2 >= 0)) && /* One atom is protein */
((is1 < 0) || ((is1 >= 0) && !remove[is1])) &&
((is2 < 0) || ((is2 >= 0) && !remove[is2]))) ||
(bSolSol &&
(is1 >= 0) && (!remove[is1]) && /* is1 is solvent */
(is2 >= 0) && (!remove[is2]) && /* is2 is solvent */
(bInsert || /* when inserting also check inside the box */
(outside_box_minus_margin2(x_solvt[is1], box) && /* is1 on edge */
outside_box_minus_margin2(x_solvt[is2], box)) /* is2 on edge */
) &&
(atoms_solvt->atom[is1].resind != /* Not the same residue */
atoms_solvt->atom[is2].resind)))
{
ntest++;
rvec_sub(xi, xj, dx);
n2 = norm2(dx);
r2 = sqr(r_all[inr]+r_all[jnr]);
if (n2 < r2)
{
if (bInsert)
{
nremove = natoms_solvt;
for (k = 0; k < nremove; k++)
{
remove[k] = TRUE;
}
}
/* Need only remove one of the solvents... */
if (is2 >= 0)
{
(void) mark_res(is2, remove, natoms_solvt, atoms_solvt->atom,
&nremove);
}
else if (is1 >= 0)
{
(void) mark_res(is1, remove, natoms_solvt, atoms_solvt->atom,
&nremove);
}
else
{
fprintf(stderr, "Neither atom is solvent%d %d\n", is1, is2);
}
}
}
}
}
if (!bInsert)
{
fprintf(stderr, " tested %d pairs, removed %d atoms.\n", ntest, nremove);
}
}
if (debug)
{
for (i = 0; i < natoms_solvt; i++)
{
fprintf(debug, "remove[%5d] = %s\n", i, bool_names[remove[i]]);
}
}
/* Search again, now with another cut-off */
if (rshell > 0)
{
do_nsgrid(stdout, bVerbose, box, x_all, atoms_all, rshell, oenv);
nlist = &(fr->nblists[0].nlist_sr[eNL_VDW]);
fprintf(stderr, "nri = %d, nrj = %d\n", nlist->nri, nlist->nrj);
nkeep = 0;
snew(keep, natoms_solvt);
for (i = 0; i < nlist->nri; i++)
{
inr = nlist->iinr[i];
j0 = nlist->jindex[i];
j1 = nlist->jindex[i+1];
for (j = j0; j < j1; j++)
{
jnr = nlist->jjnr[j];
/* Check solvent-protein and solvent-solvent */
is1 = inr-natoms_prot;
is2 = jnr-natoms_prot;
/* Check if at least one of the atoms is a solvent that is not yet
* listed for removal, and if both are solvent, that they are not in the
* same residue.
*/
if (is1 >= 0 && is2 < 0)
{
mark_res(is1, keep, natoms_solvt, atoms_solvt->atom, &nkeep);
}
else if (is1 < 0 && is2 >= 0)
{
mark_res(is2, keep, natoms_solvt, atoms_solvt->atom, &nkeep);
}
}
}
fprintf(stderr, "Keeping %d solvent atoms after proximity check\n",
nkeep);
for (i = 0; i < natoms_solvt; i++)
{
remove[i] = remove[i] || !keep[i];
}
sfree(keep);
}
/* count how many atoms and residues will be added and make space */
if (bInsert)
{
j = atoms_solvt->nr;
jnres = atoms_solvt->nres;
}
else
{
j = 0;
jnres = 0;
for (i = 0; ((i < atoms_solvt->nr) &&
((max_sol == 0) || (jnres < max_sol))); i++)
{
if (!remove[i])
{
j++;
if ((i == 0) ||
(atoms_solvt->atom[i].resind != atoms_solvt->atom[i-1].resind))
{
jnres++;
}
}
}
}
if (debug)
{
fprintf(debug, "Will add %d atoms in %d residues\n", j, jnres);
}
if (!bInsert)
{
/* Flag the remaing solvent atoms to be removed */
jjj = atoms_solvt->atom[i-1].resind;
for (; (i < atoms_solvt->nr); i++)
{
if (atoms_solvt->atom[i].resind > jjj)
{
remove[i] = TRUE;
}
else
{
j++;
}
}
}
if (bSrenew)
{
srenew(atoms->resinfo, atoms->nres+jnres);
srenew(atoms->atomname, atoms->nr+j);
srenew(atoms->atom, atoms->nr+j);
srenew(*x, atoms->nr+j);
if (v)
{
srenew(*v, atoms->nr+j);
}
srenew(*r, atoms->nr+j);
}
/* add the selected atoms_solvt to atoms */
if (atoms->nr > 0)
{
resnr = atoms->resinfo[atoms->atom[atoms->nr-1].resind].nr;
}
else
{
resnr = 0;
}
prev = -1;
nresadd = 0;
for (i = 0; i < atoms_solvt->nr; i++)
{
if (!remove[i])
{
if (prev == -1 ||
atoms_solvt->atom[i].resind != atoms_solvt->atom[prev].resind)
{
nresadd++;
atoms->nres++;
resnr++;
atoms->resinfo[atoms->nres-1] =
atoms_solvt->resinfo[atoms_solvt->atom[i].resind];
atoms->resinfo[atoms->nres-1].nr = resnr;
/* calculate shift of the solvent molecule using the first atom */
copy_rvec(x_solvt[i], dx);
put_atoms_in_box(ePBC, box, 1, &dx);
rvec_dec(dx, x_solvt[i]);
}
atoms->atom[atoms->nr] = atoms_solvt->atom[i];
atoms->atomname[atoms->nr] = atoms_solvt->atomname[i];
rvec_add(x_solvt[i], dx, (*x)[atoms->nr]);
if (v)
{
copy_rvec(v_solvt[i], (*v)[atoms->nr]);
}
(*r)[atoms->nr] = r_solvt[i];
atoms->atom[atoms->nr].resind = atoms->nres-1;
atoms->nr++;
prev = i;
}
}
if (bSrenew)
{
srenew(atoms->resinfo, atoms->nres+nresadd);
}
if (bVerbose)
{
fprintf(stderr, "Added %d molecules\n", nresadd);
}
sfree(remove);
done_atom(atoms_all);
sfree(x_all);
sfree(v_all);
}
int gmx_insert_molecules(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] inserts [TT]-nmol[tt] copies of the system specified in",
"the [TT]-ci[tt] input file. The insertions take place either into",
"vacant space in the solute conformation given with [TT]-f[tt], or",
"into an empty box given by [TT]-box[tt]. Specifying both [TT]-f[tt]",
"and [TT]-box[tt] behaves like [TT]-f[tt], but places a new box",
"around the solute before insertions. Any velocities present are",
"discarded.[PAR]",
"By default, the insertion positions are random (with initial seed",
"specified by [TT]-seed[tt]). The program iterates until [TT]-nmol[tt]",
"molecules have been inserted in the box. Molecules are not inserted",
"where the distance between any existing atom and any atom of the",
"inserted molecule is less than the sum based on the van der Waals",
"radii of both atoms. A database ([TT]vdwradii.dat[tt]) of van der",
"Waals radii is read by the program, and the resulting radii scaled",
"by [TT]-scale[tt]. If radii are not found in the database, those"
"atoms are assigned the (pre-scaled) distance [TT]-radius[tt].[PAR]",
"A total of [TT]-nmol[tt] * [TT]-try[tt] insertion attempts are made",
"before giving up. Increase [TT]-try[tt] if you have several small",
"holes to fill. Option [TT]-rot[tt] specifies whether the insertion",
"molecules are randomly oriented before insertion attempts.[PAR]",
"Alternatively, the molecules can be inserted only at positions defined in",
"positions.dat ([TT]-ip[tt]). That file should have 3 columns (x,y,z),",
"that give the displacements compared to the input molecule position",
"([TT]-ci[tt]). Hence, if that file should contain the absolute",
"positions, the molecule must be centered on (0,0,0) before using",
"[THISMODULE] (e.g. from [gmx-editconf] [TT]-center[tt]).",
"Comments in that file starting with # are ignored. Option [TT]-dr[tt]",
"defines the maximally allowed displacements during insertial trials.",
"[TT]-try[tt] and [TT]-rot[tt] work as in the default mode (see above).",
"[PAR]",
};
/* parameter data */
real *exclusionDistances = NULL;
real *exclusionDistances_insrt = NULL;
/* protein configuration data */
char *title = NULL;
t_atoms *atoms, *atoms_insrt;
rvec *x = NULL, *x_insrt = NULL;
int ePBC = -1;
matrix box;
t_filenm fnm[] = {
{ efSTX, "-f", "protein", ffOPTRD },
{ efSTX, "-ci", "insert", ffREAD},
{ efDAT, "-ip", "positions", ffOPTRD},
{ efSTO, NULL, NULL, ffWRITE},
};
#define NFILE asize(fnm)
static int nmol_ins = 0, nmol_try = 10, seed = 1997;
static real defaultDistance = 0.105, scaleFactor = 0.57;
static rvec new_box = {0.0, 0.0, 0.0}, deltaR = {0.0, 0.0, 0.0};
output_env_t oenv;
const char *enum_rot_string[] = {NULL, "xyz", "z", "none", NULL};
t_pargs pa[] = {
{ "-box", FALSE, etRVEC, {new_box},
"Box size (in nm)" },
{ "-nmol", FALSE, etINT, {&nmol_ins},
"Number of extra molecules to insert" },
{ "-try", FALSE, etINT, {&nmol_try},
"Try inserting [TT]-nmol[tt] times [TT]-try[tt] times" },
{ "-seed", FALSE, etINT, {&seed},
"Random generator seed"},
{ "-radius", FALSE, etREAL, {&defaultDistance},
"Default van der Waals distance"},
{ "-scale", FALSE, etREAL, {&scaleFactor},
"Scale factor to multiply Van der Waals radii from the database in share/gromacs/top/vdwradii.dat. The default value of 0.57 yields density close to 1000 g/l for proteins in water." },
{ "-dr", FALSE, etRVEC, {deltaR},
"Allowed displacement in x/y/z from positions in [TT]-ip[tt] file" },
{ "-rot", FALSE, etENUM, {enum_rot_string},
"rotate inserted molecules randomly" }
};
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
const bool bProt = opt2bSet("-f", NFILE, fnm);
const bool bBox = opt2parg_bSet("-box", asize(pa), pa);
const char *const posfn = opt2fn_null("-ip", NFILE, fnm);
const int enum_rot = nenum(enum_rot_string);
/* check input */
if (nmol_ins <= 0 && !opt2bSet("-ip", NFILE, fnm))
{
gmx_fatal(FARGS, "Either -nmol must be larger than 0, "
"or positions must be given with -ip");
}
if (!bProt && !bBox)
{
gmx_fatal(FARGS, "When no solute (-f) is specified, "
"a box size (-box) must be specified");
}
gmx_atomprop_t aps = gmx_atomprop_init();
snew(atoms, 1);
init_t_atoms(atoms, 0, FALSE);
if (bProt)
{
/* Generate a solute configuration */
const char *conf_prot = opt2fn("-f", NFILE, fnm);
title = readConformation(conf_prot, atoms, &x, NULL,
&ePBC, box);
exclusionDistances = makeExclusionDistances(atoms, aps, defaultDistance, scaleFactor);
if (atoms->nr == 0)
{
fprintf(stderr, "Note: no atoms in %s\n", conf_prot);
sfree(title);
title = NULL;
}
}
if (bBox)
{
ePBC = epbcXYZ;
clear_mat(box);
box[XX][XX] = new_box[XX];
box[YY][YY] = new_box[YY];
box[ZZ][ZZ] = new_box[ZZ];
}
if (det(box) == 0)
{
gmx_fatal(FARGS, "Undefined solute box.\nCreate one with gmx editconf "
"or give explicit -box command line option");
}
snew(atoms_insrt, 1);
init_t_atoms(atoms_insrt, 0, FALSE);
{
int ePBC_dummy;
matrix box_dummy;
const char *conf_insrt = opt2fn("-ci", NFILE, fnm);
char *title_ins
= readConformation(conf_insrt, atoms_insrt, &x_insrt, NULL,
&ePBC_dummy, box_dummy);
if (atoms_insrt->nr == 0)
{
gmx_fatal(FARGS, "No molecule in %s, please check your input", conf_insrt);
}
if (title == NULL)
{
title = title_ins;
}
else
{
sfree(title_ins);
}
if (posfn == NULL)
{
center_molecule(atoms_insrt->nr, x_insrt);
}
exclusionDistances_insrt = makeExclusionDistances(atoms_insrt, aps, defaultDistance, scaleFactor);
}
gmx_atomprop_destroy(aps);
/* add nmol_ins molecules of atoms_ins
in random orientation at random place */
insert_mols(nmol_ins, nmol_try, seed,
atoms, &x, &exclusionDistances,
atoms_insrt, x_insrt, exclusionDistances_insrt,
ePBC, box, posfn, deltaR, enum_rot);
/* write new configuration to file confout */
const char *confout = ftp2fn(efSTO, NFILE, fnm);
fprintf(stderr, "Writing generated configuration to %s\n", confout);
write_sto_conf(confout, title, atoms, x, NULL, ePBC, box);
/* print size of generated configuration */
fprintf(stderr, "\nOutput configuration contains %d atoms in %d residues\n",
atoms->nr, atoms->nres);
sfree(exclusionDistances);
sfree(exclusionDistances_insrt);
sfree(x);
done_atom(atoms);
done_atom(atoms_insrt);
sfree(atoms);
sfree(atoms_insrt);
sfree(title);
return 0;
}
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_solvate(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] can do one of 2 things:[PAR]",
"1) Generate a box of solvent. Specify [TT]-cs[tt] and [TT]-box[tt].",
"Or specify [TT]-cs[tt] and [TT]-cp[tt] with a structure file with",
"a box, but without atoms.[PAR]",
"2) Solvate a solute configuration, e.g. a protein, in a bath of solvent ",
"molecules. Specify [TT]-cp[tt] (solute) and [TT]-cs[tt] (solvent). ",
"The box specified in the solute coordinate file ([TT]-cp[tt]) is used,",
"unless [TT]-box[tt] is set.",
"If you want the solute to be centered in the box,",
"the program [gmx-editconf] has sophisticated options",
"to change the box dimensions and center the solute.",
"Solvent molecules are removed from the box where the ",
"distance between any atom of the solute molecule(s) and any atom of ",
"the solvent molecule is less than the sum of the scaled van der Waals",
"radii of both atoms. A database ([TT]vdwradii.dat[tt]) of van der",
"Waals radii is read by the program, and the resulting radii scaled",
"by [TT]-scale[tt]. If radii are not found in the database, those"
"atoms are assigned the (pre-scaled) distance [TT]-radius[tt].[PAR]",
"The default solvent is Simple Point Charge water (SPC), with coordinates ",
"from [TT]$GMXLIB/spc216.gro[tt]. These coordinates can also be used",
"for other 3-site water models, since a short equibilibration will remove",
"the small differences between the models.",
"Other solvents are also supported, as well as mixed solvents. The",
"only restriction to solvent types is that a solvent molecule consists",
"of exactly one residue. The residue information in the coordinate",
"files is used, and should therefore be more or less consistent.",
"In practice this means that two subsequent solvent molecules in the ",
"solvent coordinate file should have different residue number.",
"The box of solute is built by stacking the coordinates read from",
"the coordinate file. This means that these coordinates should be ",
"equlibrated in periodic boundary conditions to ensure a good",
"alignment of molecules on the stacking interfaces.",
"The [TT]-maxsol[tt] option simply adds only the first [TT]-maxsol[tt]",
"solvent molecules and leaves out the rest that would have fitted",
"into the box. This can create a void that can cause problems later.",
"Choose your volume wisely.[PAR]",
"The program can optionally rotate the solute molecule to align the",
"longest molecule axis along a box edge. This way the amount of solvent",
"molecules necessary is reduced.",
"It should be kept in mind that this only works for",
"short simulations, as e.g. an alpha-helical peptide in solution can ",
"rotate over 90 degrees, within 500 ps. In general it is therefore ",
"better to make a more or less cubic box.[PAR]",
"Setting [TT]-shell[tt] larger than zero will place a layer of water of",
"the specified thickness (nm) around the solute. Hint: it is a good",
"idea to put the protein in the center of a box first (using [gmx-editconf]).",
"[PAR]",
"Finally, [THISMODULE] will optionally remove lines from your topology file in ",
"which a number of solvent molecules is already added, and adds a ",
"line with the total number of solvent molecules in your coordinate file."
};
const char *bugs[] = {
"Molecules must be whole in the initial configurations.",
};
/* parameter data */
gmx_bool bProt, bBox;
const char *conf_prot, *confout;
real *exclusionDistances = NULL;
gmx_atomprop_t aps;
/* protein configuration data */
char *title = NULL;
t_atoms *atoms;
rvec *x = NULL, *v = NULL;
int ePBC = -1;
matrix box;
/* other data types */
int atoms_added, residues_added;
t_filenm fnm[] = {
{ efSTX, "-cp", "protein", ffOPTRD },
{ efSTX, "-cs", "spc216", ffLIBRD},
{ efSTO, NULL, NULL, ffWRITE},
{ efTOP, NULL, NULL, ffOPTRW},
};
#define NFILE asize(fnm)
static real defaultDistance = 0.105, r_shell = 0, scaleFactor = 0.57;
static rvec new_box = {0.0, 0.0, 0.0};
static gmx_bool bReadV = FALSE;
static int max_sol = 0;
output_env_t oenv;
t_pargs pa[] = {
{ "-box", FALSE, etRVEC, {new_box},
"Box size (in nm)" },
{ "-radius", FALSE, etREAL, {&defaultDistance},
"Default van der Waals distance"},
{ "-scale", FALSE, etREAL, {&scaleFactor},
"Scale factor to multiply Van der Waals radii from the database in share/gromacs/top/vdwradii.dat. The default value of 0.57 yields density close to 1000 g/l for proteins in water." },
{ "-shell", FALSE, etREAL, {&r_shell},
"Thickness of optional water layer around solute" },
{ "-maxsol", FALSE, etINT, {&max_sol},
"Maximum number of solvent molecules to add if they fit in the box. If zero (default) this is ignored" },
{ "-vel", FALSE, etBOOL, {&bReadV},
"Keep velocities from input solute and solvent" },
};
if (!parse_common_args(&argc, argv, PCA_BE_NICE, NFILE, fnm, asize(pa), pa,
asize(desc), desc, asize(bugs), bugs, &oenv))
{
return 0;
}
const char *solventFileName = opt2fn("-cs", NFILE, fnm);
bProt = opt2bSet("-cp", NFILE, fnm);
bBox = opt2parg_bSet("-box", asize(pa), pa);
/* check input */
if (!bProt && !bBox)
{
gmx_fatal(FARGS, "When no solute (-cp) is specified, "
"a box size (-box) must be specified");
}
aps = gmx_atomprop_init();
snew(atoms, 1);
init_t_atoms(atoms, 0, FALSE);
if (bProt)
{
/* Generate a solute configuration */
conf_prot = opt2fn("-cp", NFILE, fnm);
title = readConformation(conf_prot, atoms, &x,
bReadV ? &v : NULL, &ePBC, box);
exclusionDistances = makeExclusionDistances(atoms, aps, defaultDistance, scaleFactor);
if (bReadV && !v)
{
fprintf(stderr, "Note: no velocities found\n");
}
if (atoms->nr == 0)
{
fprintf(stderr, "Note: no atoms in %s\n", conf_prot);
bProt = FALSE;
}
}
if (bBox)
{
ePBC = epbcXYZ;
clear_mat(box);
box[XX][XX] = new_box[XX];
box[YY][YY] = new_box[YY];
box[ZZ][ZZ] = new_box[ZZ];
}
if (det(box) == 0)
{
gmx_fatal(FARGS, "Undefined solute box.\nCreate one with gmx editconf "
"or give explicit -box command line option");
}
add_solv(solventFileName, atoms, &x, v ? &v : NULL, &exclusionDistances, ePBC, box,
aps, defaultDistance, scaleFactor, &atoms_added, &residues_added, r_shell, max_sol,
oenv);
/* write new configuration 1 to file confout */
confout = ftp2fn(efSTO, NFILE, fnm);
fprintf(stderr, "Writing generated configuration to %s\n", confout);
if (bProt)
{
write_sto_conf(confout, title, atoms, x, v, ePBC, box);
/* print box sizes and box type to stderr */
fprintf(stderr, "%s\n", title);
}
else
{
write_sto_conf(confout, "Generated by gmx solvate", atoms, x, v, ePBC, box);
}
/* print size of generated configuration */
fprintf(stderr, "\nOutput configuration contains %d atoms in %d residues\n",
atoms->nr, atoms->nres);
update_top(atoms, box, NFILE, fnm, aps);
gmx_atomprop_destroy(aps);
sfree(exclusionDistances);
sfree(x);
sfree(v);
done_atom(atoms);
sfree(atoms);
return 0;
}
static void add_solv(const char *fn, t_atoms *atoms, rvec **x, rvec **v, real **exclusionDistances,
int ePBC, matrix box,
gmx_atomprop_t aps,
real defaultDistance, real scaleFactor, int *atoms_added,
int *residues_added, real rshell, int max_sol,
const output_env_t oenv)
{
int i, nmol;
ivec n_box;
char filename[STRLEN];
char title_solvt[STRLEN];
t_atoms *atoms_solvt;
rvec *x_solvt, *v_solvt = NULL;
real *exclusionDistances_solvt;
int ePBC_solvt;
matrix box_solvt;
int onr, onres;
char *lfn;
lfn = gmxlibfn(fn);
strncpy(filename, lfn, STRLEN);
sfree(lfn);
{
int natoms;
get_stx_coordnum(filename, &natoms);
if (0 == natoms)
{
gmx_fatal(FARGS, "No solvent in %s, please check your input\n", filename);
}
snew(atoms_solvt, 1);
init_t_atoms(atoms_solvt, natoms, FALSE);
}
snew(x_solvt, atoms_solvt->nr);
if (v)
{
snew(v_solvt, atoms_solvt->nr);
}
snew(exclusionDistances_solvt, atoms_solvt->nr);
snew(atoms_solvt->resinfo, atoms_solvt->nr);
snew(atoms_solvt->atomname, atoms_solvt->nr);
snew(atoms_solvt->atom, atoms_solvt->nr);
atoms_solvt->pdbinfo = NULL;
fprintf(stderr, "Reading solvent configuration%s\n",
v_solvt ? " and velocities" : "");
read_stx_conf(filename, title_solvt, atoms_solvt, x_solvt, v_solvt,
&ePBC_solvt, box_solvt);
fprintf(stderr, "\"%s\"\n", title_solvt);
fprintf(stderr, "solvent configuration contains %d atoms in %d residues\n",
atoms_solvt->nr, atoms_solvt->nres);
fprintf(stderr, "\n");
/* apply pbc for solvent configuration for whole molecules */
rm_res_pbc(atoms_solvt, x_solvt, box_solvt);
/* initialise distance arrays for solvent configuration */
exclusionDistances_solvt = makeExclusionDistances(atoms_solvt, aps, defaultDistance, scaleFactor);
/* calculate the box multiplication factors n_box[0...DIM] */
nmol = 1;
for (i = 0; (i < DIM); i++)
{
n_box[i] = 1;
while (n_box[i]*box_solvt[i][i] < box[i][i])
{
n_box[i]++;
}
nmol *= n_box[i];
}
fprintf(stderr, "Will generate new solvent configuration of %dx%dx%d boxes\n",
n_box[XX], n_box[YY], n_box[ZZ]);
/* realloc atoms_solvt for the new solvent configuration */
srenew(atoms_solvt->resinfo, atoms_solvt->nres*nmol);
srenew(atoms_solvt->atomname, atoms_solvt->nr*nmol);
srenew(atoms_solvt->atom, atoms_solvt->nr*nmol);
srenew(x_solvt, atoms_solvt->nr*nmol);
if (v_solvt)
{
srenew(v_solvt, atoms_solvt->nr*nmol);
}
srenew(exclusionDistances_solvt, atoms_solvt->nr*nmol);
/* generate a new solvent configuration */
make_new_conformation(atoms_solvt, x_solvt, v_solvt, exclusionDistances_solvt, box_solvt, n_box);
#ifdef DEBUG
print_stat(x_solvt, atoms_solvt->nr, box_solvt);
#endif
#ifdef DEBUG
print_stat(x_solvt, atoms_solvt->nr, box_solvt);
#endif
/* Sort the solvent mixture, not the protein... */
sort_molecule(&atoms_solvt, x_solvt, v_solvt, exclusionDistances_solvt);
/* add the two configurations */
onr = atoms->nr;
onres = atoms->nres;
add_conf(atoms, x, v, exclusionDistances, TRUE, ePBC, box, FALSE,
atoms_solvt, x_solvt, v_solvt, exclusionDistances_solvt, TRUE, rshell, max_sol, oenv);
*atoms_added = atoms->nr-onr;
*residues_added = atoms->nres-onres;
sfree(x_solvt);
sfree(exclusionDistances_solvt);
done_atom(atoms_solvt);
sfree(atoms_solvt);
fprintf(stderr, "Generated solvent containing %d atoms in %d residues\n",
*atoms_added, *residues_added);
}
