static void par_fn(char *base, int ftp, const t_commrec *cr,
gmx_bool bAppendSimId, gmx_bool bAppendNodeId,
char buf[], int bufsize)
{
if ((size_t)bufsize < (strlen(base)+10))
{
gmx_mem("Character buffer too small!");
}
/* Copy to buf, and strip extension */
strcpy(buf, base);
buf[strlen(base) - strlen(ftp2ext(fn2ftp(base))) - 1] = '\0';
if (bAppendSimId)
{
sprintf(buf+strlen(buf), "%d", cr->ms->sim);
}
if (bAppendNodeId)
{
strcat(buf, "_rank");
sprintf(buf+strlen(buf), "%d", cr->nodeid);
}
strcat(buf, ".");
/* Add extension again */
strcat(buf, (ftp == efTPX) ? "tpr" : (ftp == efEDR) ? "edr" : ftp2ext(ftp));
if (debug)
{
fprintf(debug, "rank %d par_fn '%s'\n", cr->nodeid, buf);
if (fn2ftp(buf) == efLOG)
{
fprintf(debug, "log\n");
}
}
}
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;
}
}
static void par_fn(char *base,int ftp,const t_commrec *cr,
bool bUnderScore,
char buf[],int bufsize)
{
int n;
if(bufsize<(strlen(base)+4))
gmx_mem("Character buffer too small!");
/* Copy to buf, and strip extension */
strcpy(buf,base);
buf[strlen(base) - strlen(ftp2ext(fn2ftp(base))) - 1] = '\0';
/* Add node info */
if (bUnderScore)
strcat(buf,"_");
if (MULTISIM(cr) && !bUnderScore) {
sprintf(buf+strlen(buf),"%d",cr->ms->sim);
} else if (PAR(cr)) {
sprintf(buf+strlen(buf),"%d",cr->nodeid);
}
strcat(buf,".");
/* Add extension again */
strcat(buf,(ftp == efTPX) ? "tpr" : (ftp == efEDR) ? "edr" : ftp2ext(ftp));
}
void write_sto_conf_indexed(const char *outfile, const char *title,
t_atoms *atoms,
rvec x[], rvec *v, int ePBC, matrix box,
atom_id nindex, atom_id index[])
{
FILE *out;
int ftp;
t_trxframe fr;
ftp = fn2ftp(outfile);
switch (ftp)
{
case efGRO:
out = gmx_fio_fopen(outfile, "w");
write_hconf_indexed_p(out, title, atoms, nindex, index, 3, x, v, box);
gmx_fio_fclose(out);
break;
case efG96:
clear_trxframe(&fr, TRUE);
fr.bTitle = TRUE;
fr.title = title;
fr.natoms = atoms->nr;
fr.bAtoms = TRUE;
fr.atoms = atoms;
fr.bX = TRUE;
fr.x = x;
if (v)
{
fr.bV = TRUE;
fr.v = v;
}
fr.bBox = TRUE;
copy_mat(box, fr.box);
out = gmx_fio_fopen(outfile, "w");
write_g96_conf(out, &fr, nindex, index);
gmx_fio_fclose(out);
break;
case efPDB:
case efBRK:
case efENT:
case efPQR:
out = gmx_fio_fopen(outfile, "w");
write_pdbfile_indexed(out, title, atoms, x, ePBC, box, ' ', -1, nindex, index, NULL, TRUE);
gmx_fio_fclose(out);
break;
case efESP:
out = gmx_fio_fopen(outfile, "w");
write_espresso_conf_indexed(out, title, atoms, nindex, index, x, v, box);
gmx_fio_fclose(out);
break;
case efTPR:
case efTPB:
case efTPA:
gmx_fatal(FARGS, "Sorry, can not write a topology to %s", outfile);
break;
default:
gmx_incons("Not supported in write_sto_conf_indexed");
}
}
t_trxstatus *
trjtools_gmx_prepare_tng_writing(const char *filename,
char filemode,
t_trxstatus *in,
const char *infile,
const int natoms,
const gmx_mtop_t *mtop,
gmx::ArrayRef<const int> index,
const char *index_group_name)
{
if (filemode != 'w' && filemode != 'a')
{
gmx_incons("Sorry, can only prepare for TNG output.");
}
t_trxstatus *out;
snew(out, 1);
status_init(out);
if (in != nullptr)
{
gmx_prepare_tng_writing(filename,
filemode,
&in->tng,
&out->tng,
natoms,
mtop,
index,
index_group_name);
}
else if ((infile) && (efTNG == fn2ftp(infile)))
{
gmx_tng_trajectory_t tng_in;
gmx_tng_open(infile, 'r', &tng_in);
gmx_prepare_tng_writing(filename,
filemode,
&tng_in,
&out->tng,
natoms,
mtop,
index,
index_group_name);
}
else
{
// we start from a file that is not a tng file or have been unable to load the
// input file, so we need to populate the fields independently of it
gmx_prepare_tng_writing(filename,
filemode,
nullptr,
&out->tng,
natoms,
mtop,
index,
index_group_name);
}
return out;
}
void do_view(const output_env_t oenv, const char *fn, const char *opts)
{
char buf[STRLEN], env[STRLEN];
const char *cmd;
int ftp, n;
if (output_env_get_view(oenv) && fn)
{
if (getenv("DISPLAY") == NULL)
{
fprintf(stderr, "Can not view %s, no DISPLAY environment variable.\n", fn);
}
else
{
ftp = fn2ftp(fn);
sprintf(env, "GMX_VIEW_%s", ftp2ext(ftp));
upstring(env);
switch (ftp)
{
case efXVG:
if (!(cmd = getenv(env)) )
{
if (getenv("GMX_USE_XMGR") )
{
cmd = "xmgr";
}
else
{
cmd = "xmgrace";
}
}
break;
default:
if ( (n = can_view(ftp)) )
{
if (!(cmd = getenv(env)) )
{
cmd = view_program[n];
}
}
else
{
fprintf(stderr, "Don't know how to view file %s", fn);
return;
}
}
if (strlen(cmd) )
{
sprintf(buf, "%s %s %s &", cmd, opts ? opts : "", fn);
fprintf(stderr, "Executing '%s'\n", buf);
if (0 != system(buf) )
{
gmx_fatal(FARGS, "Failed executing command: %s", buf);
}
}
}
}
}
static void read_stx_conf(const char *infile, t_topology *top,
rvec x[], rvec *v, int *ePBC, matrix box)
{
FILE *in;
t_trxframe fr;
int ftp;
char g96_line[STRLEN+1];
if (top->atoms.nr == 0)
{
fprintf(stderr, "Warning: Number of atoms in %s is 0\n", infile);
}
else if (top->atoms.atom == NULL)
{
gmx_mem("Uninitialized array atom");
}
if (ePBC)
{
*ePBC = -1;
}
ftp = fn2ftp(infile);
switch (ftp)
{
case efGRO:
gmx_gro_read_conf(infile, top, x, v, box);
break;
case efG96:
fr.title = NULL;
fr.natoms = top->atoms.nr;
fr.atoms = &top->atoms;
fr.x = x;
fr.v = v;
fr.f = NULL;
in = gmx_fio_fopen(infile, "r");
read_g96_conf(in, infile, &fr, &top->symtab, g96_line);
gmx_fio_fclose(in);
copy_mat(fr.box, box);
top->name = put_symtab(&top->symtab, fr.title);
sfree(const_cast<char *>(fr.title));
break;
case efPDB:
case efBRK:
case efENT:
gmx_pdb_read_conf(infile, top, x, ePBC, box);
break;
case efESP:
gmx_espresso_read_conf(infile, top, x, v, box);
break;
default:
gmx_incons("Not supported in read_stx_conf");
}
}
void list_trx(char *fn,bool bXVG)
{
int ftp;
ftp = fn2ftp(fn);
if (ftp == efXTC)
list_xtc(fn,bXVG);
else if ((ftp == efTRR) || (ftp == efTRJ))
list_trn(fn);
else
fprintf(stderr,"File %s not supported. Try using more %s\n",
fn,fn);
}
void get_stx_coordnum(const char *infile, int *natoms)
{
FILE *in;
int ftp, tpxver, tpxgen;
t_trxframe fr;
char g96_line[STRLEN+1];
ftp = fn2ftp(infile);
range_check(ftp, 0, efNR);
switch (ftp)
{
case efGRO:
get_coordnum(infile, natoms);
break;
case efG96:
in = gmx_fio_fopen(infile, "r");
fr.title = NULL;
fr.natoms = -1;
fr.atoms = NULL;
fr.x = NULL;
fr.v = NULL;
fr.f = NULL;
*natoms = read_g96_conf(in, infile, &fr, g96_line);
gmx_fio_fclose(in);
break;
case efPDB:
case efBRK:
case efENT:
in = gmx_fio_fopen(infile, "r");
get_pdb_coordnum(in, natoms);
gmx_fio_fclose(in);
break;
case efESP:
*natoms = get_espresso_coordnum(infile);
break;
case efTPA:
case efTPB:
case efTPR:
{
t_tpxheader tpx;
read_tpxheader(infile, &tpx, TRUE, &tpxver, &tpxgen);
*natoms = tpx.natoms;
break;
}
default:
gmx_fatal(FARGS, "File type %s not supported in get_stx_coordnum",
ftp2ext(ftp));
}
}
void do_view(char *fn, char *opts)
{
#define N_EXT 3
char buf[STRLEN], env[20], ext[N_EXT], *cmd, *defopts=NULL;
int ftp, n;
char *disp;
if (bDoView() && fn) {
#ifdef SPEC_CPU
disp = NULL;
#else
disp = getenv("DISPLAY");
#endif
if (disp == NULL) {
fprintf(stderr,"Can not view %s, no DISPLAY environment variable.\n",fn);
} else {
ftp=fn2ftp(fn);
strncpy(ext, ftp2ext(ftp), N_EXT);
upstring(ext);
sprintf(env, "GMX_VIEW_%s", ext);
if ( (n=can_view(ftp)) ) {
#ifdef SPEC_CPU
cmd = NULL;
#else
cmd = getenv(env);
#endif
if ( ! cmd )
cmd=view_program[n];
} else {
fprintf(stderr,"Don't know how to view file %s",fn);
return;
}
/* Add command line option -nxy for xmgrace */
if (ftp == efXVG && strcmp(cmd,"xmgrace") == 0)
defopts = "-nxy";
if ( strlen(cmd) ) {
sprintf(buf,"%s %s%s%s%s%s &",
cmd,
opts ? opts : "",opts ? " " : "",
defopts ? defopts : "",defopts ? " " : "",
fn);
fprintf(stderr,"Executing '%s'\n",buf);
system(buf);
}
}
}
}
void trjtools_gmx_prepare_tng_writing(const char *filename,
char filemode,
t_trxstatus *in,
t_trxstatus **out,
const char *infile,
const int natoms,
const gmx_mtop_t *mtop,
const int *index,
const char *index_group_name)
{
if (filemode != 'w' && filemode != 'a')
{
gmx_incons("Sorry, can only prepare for TNG output.");
}
if (*out == nullptr)
{
snew((*out), 1);
}
status_init(*out);
if (in != nullptr)
{
gmx_prepare_tng_writing(filename,
filemode,
&in->tng,
&(*out)->tng,
natoms,
mtop,
index,
index_group_name);
}
else if (efTNG == fn2ftp(infile))
{
tng_trajectory_t tng_in;
gmx_tng_open(infile, 'r', &tng_in);
gmx_prepare_tng_writing(filename,
filemode,
&tng_in,
&(*out)->tng,
natoms,
mtop,
index,
index_group_name);
}
}
void do_view(const output_env_t oenv,const char *fn, const char *opts)
{
char buf[STRLEN], env[STRLEN];
const char *cmd;
int ftp, n;
if (output_env_get_view(oenv) && fn) {
if (getenv("DISPLAY") == NULL) {
fprintf(stderr,"Can not view %s, no DISPLAY environment variable.\n",fn);
} else {
ftp=fn2ftp(fn);
sprintf(env, "GMX_VIEW_%s", ftp2ext(ftp));
upstring(env);
switch(ftp) {
case efXVG:
if ( ! (cmd=getenv(env)) ) {
if ( getenv("XMGR") )
cmd="xmgr";
else
cmd="xmgrace";
}
break;
default:
if ( (n=can_view(ftp)) ) {
if ( ! (cmd=getenv(env)) )
cmd=view_program[n];
} else {
fprintf(stderr,"Don't know how to view file %s",fn);
return;
}
}
if ( strlen(cmd) ) {
sprintf(buf,"%s %s %s &",cmd,opts ? opts : "",fn);
fprintf(stderr,"Executing '%s'\n",buf);
#ifdef GMX_NO_SYSTEM
printf("Warning-- No calls to system(3) supported on this platform.");
printf("Warning-- Skipping execution of 'system(\"%s\")'.", buf);
#else
if( 0 != system(buf) )
{
gmx_fatal(FARGS,"Failed executing command: %s",buf);
}
#endif
}
}
}
}
void list_trx(const char *fn)
{
switch (fn2ftp(fn))
{
case efXTC:
list_xtc(fn);
break;
case efTRR:
list_trn(fn);
break;
case efTNG:
list_tng(fn);
break;
default:
fprintf(stderr, "File %s is of an unsupported type. Try using the command\n 'less %s'\n",
fn, fn);
}
}
static void get_stx_coordnum(const char *infile, int *natoms)
{
FILE *in;
int ftp;
t_trxframe fr;
char g96_line[STRLEN+1];
ftp = fn2ftp(infile);
range_check(ftp, 0, efNR);
switch (ftp)
{
case efGRO:
get_coordnum(infile, natoms);
break;
case efG96:
{
in = gmx_fio_fopen(infile, "r");
fr.title = NULL;
fr.natoms = -1;
fr.atoms = NULL;
fr.x = NULL;
fr.v = NULL;
fr.f = NULL;
*natoms = read_g96_conf(in, infile, &fr, NULL, g96_line);
sfree(const_cast<char *>(fr.title));
gmx_fio_fclose(in);
break;
}
case efPDB:
case efBRK:
case efENT:
in = gmx_fio_fopen(infile, "r");
get_pdb_coordnum(in, natoms);
gmx_fio_fclose(in);
break;
case efESP:
*natoms = get_espresso_coordnum(infile);
break;
default:
gmx_fatal(FARGS, "File type %s not supported in get_stx_coordnum",
ftp2ext(ftp));
}
}
void list_trx(const char *fn, gmx_bool bXVG)
{
int ftp;
ftp = fn2ftp(fn);
if (ftp == efXTC)
{
list_xtc(fn, bXVG);
}
else if ((ftp == efTRR) || (ftp == efTRJ))
{
list_trn(fn);
}
else
{
fprintf(stderr, "File %s is of an unsupported type. Try using the command\n 'less %s'\n",
fn, fn);
}
}
bool read_first_frame(const gmx_output_env_t *oenv, t_trxstatus **status,
const char *fn, t_trxframe *fr, int flags)
{
t_fileio *fio = nullptr;
gmx_bool bFirst, bOK;
int ftp = fn2ftp(fn);
clear_trxframe(fr, TRUE);
bFirst = TRUE;
snew((*status), 1);
status_init( *status );
initcount(*status);
(*status)->flags = flags;
if (efTNG == ftp)
{
/* Special treatment for TNG files */
gmx_tng_open(fn, 'r', &(*status)->tng);
}
else
{
fio = (*status)->fio = gmx_fio_open(fn, "r");
}
switch (ftp)
{
case efTRR:
break;
case efCPT:
read_checkpoint_trxframe(fio, fr);
bFirst = FALSE;
break;
case efG96:
{
/* Can not rewind a compressed file, so open it twice */
if (!(*status)->persistent_line)
{
/* allocate the persistent line */
snew((*status)->persistent_line, STRLEN+1);
}
t_symtab *symtab = nullptr;
read_g96_conf(gmx_fio_getfp(fio), fn, nullptr, fr, symtab, (*status)->persistent_line);
gmx_fio_close(fio);
clear_trxframe(fr, FALSE);
if (flags & (TRX_READ_X | TRX_NEED_X))
{
snew(fr->x, fr->natoms);
}
if (flags & (TRX_READ_V | TRX_NEED_V))
{
snew(fr->v, fr->natoms);
}
(*status)->fio = gmx_fio_open(fn, "r");
break;
}
case efXTC:
if (read_first_xtc(fio, &fr->natoms, &fr->step, &fr->time, fr->box, &fr->x,
&fr->prec, &bOK) == 0)
{
GMX_RELEASE_ASSERT(!bOK, "Inconsistent results - OK status from read_first_xtc, but 0 atom coords read");
fr->not_ok = DATA_NOT_OK;
}
if (fr->not_ok)
{
fr->natoms = 0;
printincomp(*status, fr);
}
else
{
fr->bPrec = (fr->prec > 0);
fr->bStep = TRUE;
fr->bTime = TRUE;
fr->bX = TRUE;
fr->bBox = TRUE;
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efTNG:
fr->step = -1;
if (!gmx_read_next_tng_frame((*status)->tng, fr, nullptr, 0))
{
fr->not_ok = DATA_NOT_OK;
fr->natoms = 0;
printincomp(*status, fr);
}
else
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efPDB:
pdb_first_x(*status, gmx_fio_getfp(fio), fr);
if (fr->natoms)
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
case efGRO:
if (gro_first_x_or_v(gmx_fio_getfp(fio), fr))
{
printcount(*status, oenv, fr->time, FALSE);
}
bFirst = FALSE;
break;
default:
#if GMX_USE_PLUGINS
fprintf(stderr, "The file format of %s is not a known trajectory format to GROMACS.\n"
"Please make sure that the file is a trajectory!\n"
"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(fn, &(*status)->vmdplugin, fr))
{
gmx_fatal(FARGS, "Not supported in read_first_frame: %s", fn);
}
#else
gmx_fatal(FARGS, "Not supported in read_first_frame: %s. Please make sure that the file is a trajectory.\n"
"GROMACS is not compiled with plug-in support. Thus it cannot read non-GROMACS trajectory formats using the VMD plug-ins.\n"
"Please compile with plug-in support if you want to read non-GROMACS trajectory formats.\n", fn);
#endif
break;
}
(*status)->tf = fr->time;
/* Return FALSE if we read a frame that's past the set ending time. */
if (!bFirst && (!(flags & TRX_DONT_SKIP) && check_times(fr->time) > 0))
{
(*status)->t0 = fr->time;
return FALSE;
}
if (bFirst ||
(!(flags & TRX_DONT_SKIP) && check_times(fr->time) < 0))
{
/* Read a frame when no frame was read or the first was skipped */
if (!read_next_frame(oenv, *status, fr))
{
return FALSE;
}
}
(*status)->t0 = fr->time;
/* We need the number of atoms for random-access XTC searching, even when
* we don't have access to the actual frame data.
*/
(*status)->natoms = fr->natoms;
return (fr->natoms > 0);
}
gmx_mdoutf_t init_mdoutf(FILE *fplog, int nfile, const t_filenm fnm[],
int mdrun_flags, const t_commrec *cr,
const t_inputrec *ir, gmx_mtop_t *top_global,
const gmx_output_env_t *oenv, gmx_wallcycle_t wcycle)
{
gmx_mdoutf_t of;
char filemode[3];
gmx_bool bAppendFiles, bCiteTng = FALSE;
int i;
snew(of, 1);
of->fp_trn = NULL;
of->fp_ene = NULL;
of->fp_xtc = NULL;
of->tng = NULL;
of->tng_low_prec = NULL;
of->fp_dhdl = NULL;
of->fp_field = NULL;
of->eIntegrator = ir->eI;
of->bExpanded = ir->bExpanded;
of->elamstats = ir->expandedvals->elamstats;
of->simulation_part = ir->simulation_part;
of->x_compression_precision = static_cast<int>(ir->x_compression_precision);
of->wcycle = wcycle;
if (MASTER(cr))
{
bAppendFiles = (mdrun_flags & MD_APPENDFILES);
of->bKeepAndNumCPT = (mdrun_flags & MD_KEEPANDNUMCPT);
sprintf(filemode, bAppendFiles ? "a+" : "w+");
if ((EI_DYNAMICS(ir->eI) || EI_ENERGY_MINIMIZATION(ir->eI))
#ifndef GMX_FAHCORE
&&
!(EI_DYNAMICS(ir->eI) &&
ir->nstxout == 0 &&
ir->nstvout == 0 &&
ir->nstfout == 0)
#endif
)
{
const char *filename;
filename = ftp2fn(efTRN, nfile, fnm);
switch (fn2ftp(filename))
{
case efTRR:
case efTRN:
of->fp_trn = gmx_trr_open(filename, filemode);
break;
case efTNG:
gmx_tng_open(filename, filemode[0], &of->tng);
if (filemode[0] == 'w')
{
gmx_tng_prepare_md_writing(of->tng, top_global, ir);
}
bCiteTng = TRUE;
break;
default:
gmx_incons("Invalid full precision file format");
}
}
if (EI_DYNAMICS(ir->eI) &&
ir->nstxout_compressed > 0)
{
const char *filename;
filename = ftp2fn(efCOMPRESSED, nfile, fnm);
switch (fn2ftp(filename))
{
case efXTC:
of->fp_xtc = open_xtc(filename, filemode);
break;
case efTNG:
gmx_tng_open(filename, filemode[0], &of->tng_low_prec);
if (filemode[0] == 'w')
{
gmx_tng_prepare_low_prec_writing(of->tng_low_prec, top_global, ir);
}
bCiteTng = TRUE;
break;
default:
gmx_incons("Invalid reduced precision file format");
}
}
if (EI_DYNAMICS(ir->eI) || EI_ENERGY_MINIMIZATION(ir->eI))
{
of->fp_ene = open_enx(ftp2fn(efEDR, nfile, fnm), filemode);
}
of->fn_cpt = opt2fn("-cpo", nfile, fnm);
if ((ir->efep != efepNO || ir->bSimTemp) && ir->fepvals->nstdhdl > 0 &&
(ir->fepvals->separate_dhdl_file == esepdhdlfileYES ) &&
EI_DYNAMICS(ir->eI))
{
if (bAppendFiles)
{
of->fp_dhdl = gmx_fio_fopen(opt2fn("-dhdl", nfile, fnm), filemode);
}
else
{
of->fp_dhdl = open_dhdl(opt2fn("-dhdl", nfile, fnm), ir, oenv);
}
}
if (opt2bSet("-field", nfile, fnm) &&
(ir->ex[XX].n || ir->ex[YY].n || ir->ex[ZZ].n))
{
if (bAppendFiles)
{
of->fp_field = gmx_fio_fopen(opt2fn("-field", nfile, fnm),
filemode);
}
else
{
of->fp_field = xvgropen(opt2fn("-field", nfile, fnm),
"Applied electric field", "Time (ps)",
"E (V/nm)", oenv);
}
}
/* Set up atom counts so they can be passed to actual
trajectory-writing routines later. Also, XTC writing needs
to know what (and how many) atoms might be in the XTC
groups, and how to look up later which ones they are. */
of->natoms_global = top_global->natoms;
of->groups = &top_global->groups;
of->natoms_x_compressed = 0;
for (i = 0; (i < top_global->natoms); i++)
{
if (ggrpnr(of->groups, egcCompressedX, i) == 0)
{
of->natoms_x_compressed++;
}
}
}
if (bCiteTng)
{
please_cite(fplog, "Lundborg2014");
}
return of;
}
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_confrms(int argc, char *argv[])
{
const char *desc[] = {
"[TT]g_confrms[tt] computes the root mean square deviation (RMSD) of two",
"structures after least-squares fitting the second structure on the first one.",
"The two structures do NOT need to have the same number of atoms,",
"only the two index groups used for the fit need to be identical.",
"With [TT]-name[tt] only matching atom names from the selected groups",
"will be used for the fit and RMSD calculation. This can be useful ",
"when comparing mutants of a protein.",
"[PAR]",
"The superimposed structures are written to file. In a [TT].pdb[tt] file",
"the two structures will be written as separate models",
"(use [TT]rasmol -nmrpdb[tt]). Also in a [TT].pdb[tt] file, B-factors",
"calculated from the atomic MSD values can be written with [TT]-bfac[tt].",
};
static gmx_bool bOne = FALSE, bRmpbc = FALSE, bMW = TRUE, bName = FALSE,
bBfac = FALSE, bFit = TRUE, bLabel = FALSE;
t_pargs pa[] = {
{ "-one", FALSE, etBOOL, {&bOne}, "Only write the fitted structure to file" },
{ "-mw", FALSE, etBOOL, {&bMW}, "Mass-weighted fitting and RMSD" },
{ "-pbc", FALSE, etBOOL, {&bRmpbc}, "Try to make molecules whole again" },
{ "-fit", FALSE, etBOOL, {&bFit},
"Do least squares superposition of the target structure to the reference" },
{ "-name", FALSE, etBOOL, {&bName},
"Only compare matching atom names" },
{ "-label", FALSE, etBOOL, {&bLabel},
"Added chain labels A for first and B for second structure"},
{ "-bfac", FALSE, etBOOL, {&bBfac},
"Output B-factors from atomic MSD values" }
};
t_filenm fnm[] = {
{ efTPS, "-f1", "conf1.gro", ffREAD },
{ efSTX, "-f2", "conf2", ffREAD },
{ efSTO, "-o", "fit.pdb", ffWRITE },
{ efNDX, "-n1", "fit1.ndx", ffOPTRD },
{ efNDX, "-n2", "fit2.ndx", ffOPTRD },
{ efNDX, "-no", "match.ndx", ffOPTWR }
};
#define NFILE asize(fnm)
/* the two structure files */
const char *conf1file, *conf2file, *matchndxfile, *outfile;
FILE *fp;
char title1[STRLEN], title2[STRLEN], *name1, *name2;
t_topology *top1, *top2;
int ePBC1, ePBC2;
t_atoms *atoms1, *atoms2;
int warn = 0;
atom_id at;
real *w_rls, mass, totmass;
rvec *x1, *v1, *x2, *v2, *fit_x;
matrix box1, box2;
output_env_t oenv;
/* counters */
int i, j, m;
/* center of mass calculation */
real tmas1, tmas2;
rvec xcm1, xcm2;
/* variables for fit */
char *groupnames1, *groupnames2;
int isize1, isize2;
atom_id *index1, *index2;
real rms, msd, minmsd, maxmsd;
real *msds;
parse_common_args(&argc, argv, PCA_BE_NICE | PCA_CAN_VIEW,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv);
matchndxfile = opt2fn_null("-no", NFILE, fnm);
conf1file = ftp2fn(efTPS, NFILE, fnm);
conf2file = ftp2fn(efSTX, NFILE, fnm);
/* reading reference structure from first structure file */
fprintf(stderr, "\nReading first structure file\n");
snew(top1, 1);
read_tps_conf(conf1file, title1, top1, &ePBC1, &x1, &v1, box1, TRUE);
atoms1 = &(top1->atoms);
fprintf(stderr, "%s\nContaining %d atoms in %d residues\n",
title1, atoms1->nr, atoms1->nres);
if (bRmpbc)
{
rm_gropbc(atoms1, x1, box1);
}
fprintf(stderr, "Select group from first structure\n");
get_index(atoms1, opt2fn_null("-n1", NFILE, fnm),
1, &isize1, &index1, &groupnames1);
printf("\n");
if (bFit && (isize1 < 3))
{
gmx_fatal(FARGS, "Need >= 3 points to fit!\n");
}
/* reading second structure file */
fprintf(stderr, "\nReading second structure file\n");
snew(top2, 1);
read_tps_conf(conf2file, title2, top2, &ePBC2, &x2, &v2, box2, TRUE);
atoms2 = &(top2->atoms);
fprintf(stderr, "%s\nContaining %d atoms in %d residues\n",
title2, atoms2->nr, atoms2->nres);
if (bRmpbc)
{
rm_gropbc(atoms2, x2, box2);
}
fprintf(stderr, "Select group from second structure\n");
get_index(atoms2, opt2fn_null("-n2", NFILE, fnm),
1, &isize2, &index2, &groupnames2);
if (bName)
{
find_matching_names(&isize1, index1, atoms1, &isize2, index2, atoms2);
if (matchndxfile)
{
fp = ffopen(matchndxfile, "w");
fprintf(fp, "; Matching atoms between %s from %s and %s from %s\n",
groupnames1, conf1file, groupnames2, conf2file);
fprintf(fp, "[ Match_%s_%s ]\n", conf1file, groupnames1);
for (i = 0; i < isize1; i++)
{
fprintf(fp, "%4u%s", index1[i]+1, (i%15 == 14 || i == isize1-1) ? "\n" : " ");
}
fprintf(fp, "[ Match_%s_%s ]\n", conf2file, groupnames2);
for (i = 0; i < isize2; i++)
{
fprintf(fp, "%4u%s", index2[i]+1, (i%15 == 14 || i == isize2-1) ? "\n" : " ");
}
}
}
/* check isizes, must be equal */
if (isize2 != isize1)
{
gmx_fatal(FARGS, "You selected groups with differen number of atoms.\n");
}
for (i = 0; i < isize1; i++)
{
name1 = *atoms1->atomname[index1[i]];
name2 = *atoms2->atomname[index2[i]];
if (strcmp(name1, name2))
{
if (warn < 20)
{
fprintf(stderr,
"Warning: atomnames at index %d don't match: %u %s, %u %s\n",
i+1, index1[i]+1, name1, index2[i]+1, name2);
}
warn++;
}
if (!bMW)
{
atoms1->atom[index1[i]].m = 1;
atoms2->atom[index2[i]].m = 1;
}
}
if (warn)
{
fprintf(stderr, "%d atomname%s did not match\n", warn, (warn == 1) ? "" : "s");
}
if (bFit)
{
/* calculate and remove center of mass of structures */
calc_rm_cm(isize1, index1, atoms1, x1, xcm1);
calc_rm_cm(isize2, index2, atoms2, x2, xcm2);
snew(w_rls, atoms2->nr);
snew(fit_x, atoms2->nr);
for (at = 0; (at < isize1); at++)
{
w_rls[index2[at]] = atoms1->atom[index1[at]].m;
copy_rvec(x1[index1[at]], fit_x[index2[at]]);
}
/* do the least squares fit to the reference structure */
do_fit(atoms2->nr, w_rls, fit_x, x2);
sfree(fit_x);
sfree(w_rls);
w_rls = NULL;
}
else
{
clear_rvec(xcm1);
clear_rvec(xcm2);
w_rls = NULL;
}
/* calculate the rms deviation */
rms = 0;
totmass = 0;
maxmsd = -1e18;
minmsd = 1e18;
snew(msds, isize1);
for (at = 0; at < isize1; at++)
{
mass = atoms1->atom[index1[at]].m;
for (m = 0; m < DIM; m++)
{
msd = sqr(x1[index1[at]][m] - x2[index2[at]][m]);
rms += msd*mass;
msds[at] += msd;
}
maxmsd = max(maxmsd, msds[at]);
minmsd = min(minmsd, msds[at]);
totmass += mass;
}
rms = sqrt(rms/totmass);
printf("Root mean square deviation after lsq fit = %g nm\n", rms);
if (bBfac)
{
printf("Atomic MSD's range from %g to %g nm^2\n", minmsd, maxmsd);
}
if (bFit)
{
/* reset coordinates of reference and fitted structure */
for (i = 0; i < atoms1->nr; i++)
{
for (m = 0; m < DIM; m++)
{
x1[i][m] += xcm1[m];
}
}
for (i = 0; i < atoms2->nr; i++)
{
for (m = 0; m < DIM; m++)
{
x2[i][m] += xcm1[m];
}
}
}
outfile = ftp2fn(efSTO, NFILE, fnm);
switch (fn2ftp(outfile))
{
case efPDB:
case efBRK:
case efENT:
if (bBfac || bLabel)
{
srenew(atoms1->pdbinfo, atoms1->nr);
srenew(atoms1->atom, atoms1->nr); /* Why renew atom? */
/* Avoid segfaults when writing the pdb-file */
for (i = 0; i < atoms1->nr; i++)
{
atoms1->pdbinfo[i].type = eptAtom;
atoms1->pdbinfo[i].occup = 1.00;
atoms1->pdbinfo[i].bAnisotropic = FALSE;
if (bBfac)
{
atoms1->pdbinfo[i].bfac = 0;
}
if (bLabel)
{
atoms1->resinfo[atoms1->atom[i].resind].chainid = 'A';
}
}
for (i = 0; i < isize1; i++)
{
/* atoms1->pdbinfo[index1[i]].type = eptAtom; */
/* atoms1->pdbinfo[index1[i]].bAnisotropic = FALSE; */
if (bBfac)
{
atoms1->pdbinfo[index1[i]].bfac = (800*M_PI*M_PI/3.0)*msds[i];
}
/* if (bLabel) */
/* atoms1->resinfo[atoms1->atom[index1[i]].resind].chain = 'A'; */
}
srenew(atoms2->pdbinfo, atoms2->nr);
srenew(atoms2->atom, atoms2->nr); /* Why renew atom? */
for (i = 0; i < atoms2->nr; i++)
{
atoms2->pdbinfo[i].type = eptAtom;
atoms2->pdbinfo[i].occup = 1.00;
atoms2->pdbinfo[i].bAnisotropic = FALSE;
if (bBfac)
{
atoms2->pdbinfo[i].bfac = 0;
}
if (bLabel)
{
atoms2->resinfo[atoms1->atom[i].resind].chainid = 'B';
}
}
for (i = 0; i < isize2; i++)
{
/* atoms2->pdbinfo[index2[i]].type = eptAtom; */
/* atoms2->pdbinfo[index2[i]].bAnisotropic = FALSE; */
if (bBfac)
{
atoms2->pdbinfo[index2[i]].bfac = (800*M_PI*M_PI/3.0)*msds[i];
}
/* if (bLabel) */
/* atoms2->resinfo[atoms2->atom[index2[i]].resind].chain = 'B'; */
}
}
fp = ffopen(outfile, "w");
if (!bOne)
{
write_pdbfile(fp, title1, atoms1, x1, ePBC1, box1, ' ', 1, NULL, TRUE);
}
write_pdbfile(fp, title2, atoms2, x2, ePBC2, box2, ' ', bOne ? -1 : 2, NULL, TRUE);
ffclose(fp);
break;
case efGRO:
if (bBfac)
{
fprintf(stderr, "WARNING: cannot write B-factor values to gro file\n");
}
fp = ffopen(outfile, "w");
if (!bOne)
{
write_hconf_p(fp, title1, atoms1, 3, x1, v1, box1);
}
write_hconf_p(fp, title2, atoms2, 3, x2, v2, box2);
ffclose(fp);
break;
default:
if (bBfac)
{
fprintf(stderr, "WARNING: cannot write B-factor values to %s file\n",
ftp2ext(fn2ftp(outfile)));
}
if (!bOne)
{
fprintf(stderr,
"WARNING: cannot write the reference structure to %s file\n",
ftp2ext(fn2ftp(outfile)));
}
write_sto_conf(outfile, title2, atoms2, x2, v2, ePBC2, box2);
break;
}
view_all(oenv, NFILE, fnm);
thanx(stderr);
return 0;
}
void init_multisystem(t_commrec *cr, int nsim, char **multidirs,
int nfile, const t_filenm fnm[], gmx_bool bParFn)
{
gmx_multisim_t *ms;
int nnodes, nnodpersim, sim, i, ftp;
char buf[256];
#ifdef GMX_MPI
MPI_Group mpi_group_world;
int *rank;
#endif
#ifndef GMX_MPI
if (nsim > 1)
{
gmx_fatal(FARGS, "This binary is compiled without MPI support, can not do multiple simulations.");
}
#endif
nnodes = cr->nnodes;
if (nnodes % nsim != 0)
{
gmx_fatal(FARGS, "The number of ranks (%d) is not a multiple of the number of simulations (%d)", nnodes, nsim);
}
nnodpersim = nnodes/nsim;
sim = cr->nodeid/nnodpersim;
if (debug)
{
fprintf(debug, "We have %d simulations, %d ranks per simulation, local simulation is %d\n", nsim, nnodpersim, sim);
}
snew(ms, 1);
cr->ms = ms;
ms->nsim = nsim;
ms->sim = sim;
#ifdef GMX_MPI
/* Create a communicator for the master nodes */
snew(rank, ms->nsim);
for (i = 0; i < ms->nsim; i++)
{
rank[i] = i*nnodpersim;
}
MPI_Comm_group(MPI_COMM_WORLD, &mpi_group_world);
MPI_Group_incl(mpi_group_world, nsim, rank, &ms->mpi_group_masters);
sfree(rank);
MPI_Comm_create(MPI_COMM_WORLD, ms->mpi_group_masters,
&ms->mpi_comm_masters);
#if !defined(MPI_IN_PLACE_EXISTS)
/* initialize the MPI_IN_PLACE replacement buffers */
snew(ms->mpb, 1);
ms->mpb->ibuf = NULL;
ms->mpb->libuf = NULL;
ms->mpb->fbuf = NULL;
ms->mpb->dbuf = NULL;
ms->mpb->ibuf_alloc = 0;
ms->mpb->libuf_alloc = 0;
ms->mpb->fbuf_alloc = 0;
ms->mpb->dbuf_alloc = 0;
#endif
#endif
/* Reduce the intra-simulation communication */
cr->sim_nodeid = cr->nodeid % nnodpersim;
cr->nnodes = nnodpersim;
#ifdef GMX_MPI
MPI_Comm_split(MPI_COMM_WORLD, sim, cr->sim_nodeid, &cr->mpi_comm_mysim);
cr->mpi_comm_mygroup = cr->mpi_comm_mysim;
cr->nodeid = cr->sim_nodeid;
#endif
if (debug)
{
fprintf(debug, "This is simulation %d", cr->ms->sim);
if (PAR(cr))
{
fprintf(debug, ", local number of ranks %d, local rank ID %d",
cr->nnodes, cr->sim_nodeid);
}
fprintf(debug, "\n\n");
}
if (multidirs)
{
if (debug)
{
fprintf(debug, "Changing to directory %s\n", multidirs[cr->ms->sim]);
}
gmx_chdir(multidirs[cr->ms->sim]);
}
else if (bParFn)
{
/* Patch output and tpx, cpt and rerun input file names */
for (i = 0; (i < nfile); i++)
{
/* Because of possible multiple extensions per type we must look
* at the actual file name
*/
if (is_output(&fnm[i]) ||
fnm[i].ftp == efTPX || fnm[i].ftp == efCPT ||
strcmp(fnm[i].opt, "-rerun") == 0)
{
ftp = fn2ftp(fnm[i].fns[0]);
par_fn(fnm[i].fns[0], ftp, cr, TRUE, FALSE, buf, 255);
sfree(fnm[i].fns[0]);
fnm[i].fns[0] = gmx_strdup(buf);
}
}
}
}
static void set_grpfnm(t_filenm *fnm, const char *name, const char *deffnm)
{
char buf[256], buf2[256];
int i, type;
gmx_bool bValidExt;
int nopts;
const int *ftps;
nopts = deffile[fnm->ftp].ntps;
ftps = deffile[fnm->ftp].tps;
if ((nopts == 0) || (ftps == NULL))
{
gmx_fatal(FARGS, "nopts == 0 || ftps == NULL");
}
bValidExt = FALSE;
if (name && deffnm == NULL)
{
strcpy(buf, name);
/* First check whether we have a valid filename already */
type = fn2ftp(name);
if ((fnm->flag & ffREAD) && (fnm->ftp == efTRX))
{
/*if file exist don't add an extension for trajectory reading*/
bValidExt = gmx_fexist(name);
}
for (i = 0; (i < nopts) && !bValidExt; i++)
{
if (type == ftps[i])
{
bValidExt = TRUE;
}
}
}
else if (deffnm != NULL)
{
strcpy(buf, deffnm);
}
else
{
/* No name given, set the default name */
strcpy(buf, ftp2defnm(fnm->ftp));
}
if (!bValidExt && (fnm->flag & ffREAD))
{
/* for input-files only: search for filenames in the directory */
for (i = 0; (i < nopts) && !bValidExt; i++)
{
type = ftps[i];
strcpy(buf2, buf);
set_extension(buf2, type);
if (gmx_fexist(buf2))
{
bValidExt = TRUE;
strcpy(buf, buf2);
}
}
}
if (!bValidExt)
{
/* Use the first extension type */
set_extension(buf, ftps[0]);
}
add_filenm(fnm, buf);
}
/*****************************************************************
*
* EXPORTED SECTION
*
*****************************************************************/
t_fileio *gmx_fio_open(const char *fn, const char *mode)
{
t_fileio *fio = NULL;
int i;
char newmode[5];
gmx_bool bRead, bReadWrite;
int xdrid;
if (fn2ftp(fn) == efTPA)
{
strcpy(newmode, mode);
}
else
{
/* sanitize the mode string */
if (strncmp(mode, "r+", 2) == 0)
{
strcpy(newmode, "r+");
}
else if (mode[0] == 'r')
{
strcpy(newmode, "r");
}
else if (strncmp(mode, "w+", 2) == 0)
{
strcpy(newmode, "w+");
}
else if (mode[0] == 'w')
{
strcpy(newmode, "w");
}
else if (strncmp(mode, "a+", 2) == 0)
{
strcpy(newmode, "a+");
}
else if (mode[0] == 'a')
{
strcpy(newmode, "a");
}
else
{
gmx_fatal(FARGS, "DEATH HORROR in gmx_fio_open, mode is '%s'", mode);
}
}
/* Check if it should be opened as a binary file */
if (strncmp(ftp2ftype(fn2ftp(fn)), "ASCII", 5))
{
/* Not ascii, add b to file mode */
if ((strchr(newmode, 'b') == NULL) && (strchr(newmode, 'B') == NULL))
{
strcat(newmode, "b");
}
}
snew(fio, 1);
#ifdef GMX_THREAD_MPI
tMPI_Lock_init(&(fio->mtx));
#endif
bRead = (newmode[0] == 'r' && newmode[1] != '+');
bReadWrite = (newmode[1] == '+');
fio->fp = NULL;
fio->xdr = NULL;
if (fn)
{
fio->iFTP = fn2ftp(fn);
fio->fn = strdup(fn);
fio->bStdio = FALSE;
/* If this file type is in the list of XDR files, open it like that */
if (in_ftpset(fio->iFTP, asize(ftpXDR), ftpXDR))
{
/* First check whether we have to make a backup,
* only for writing, not for read or append.
*/
if (newmode[0] == 'w')
{
#ifndef GMX_FAHCORE
/* only make backups for normal gromacs */
make_backup(fn);
#endif
}
else
{
/* Check whether file exists */
if (!gmx_fexist(fn))
{
gmx_open(fn);
}
}
/* Open the file */
fio->fp = ffopen(fn, newmode);
/* determine the XDR direction */
if (newmode[0] == 'w' || newmode[0] == 'a')
{
fio->xdrmode = XDR_ENCODE;
}
else
{
fio->xdrmode = XDR_DECODE;
}
snew(fio->xdr, 1);
xdrstdio_create(fio->xdr, fio->fp, fio->xdrmode);
}
else
{
/* If it is not, open it as a regular file */
fio->fp = ffopen(fn, newmode);
}
/* for appending seek to end of file to make sure ftell gives correct position
* important for checkpointing */
if (newmode[0] == 'a')
{
gmx_fseek(fio->fp, 0, SEEK_END);
}
}
else
{
/* Use stdin/stdout for I/O */
fio->iFTP = efTPA;
fio->fp = bRead ? stdin : stdout;
fio->fn = strdup("STDIO");
fio->bStdio = TRUE;
}
fio->bRead = bRead;
fio->bReadWrite = bReadWrite;
fio->bDouble = (sizeof(real) == sizeof(double));
fio->bDebug = FALSE;
fio->bOpen = TRUE;
fio->bLargerThan_off_t = FALSE;
/* set the reader/writer functions */
gmx_fio_set_iotype(fio);
/* and now insert this file into the list of open files. */
gmx_fio_insert(fio);
return fio;
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"[TT]do_multiprot[tt] ",
"reads a trajectory file and aligns it to a reference structure ",
"each time frame",
"calling the multiprot program. This allows you to use a reference",
"structure whose sequence is different than that of the protein in the ",
"trajectory, since the alignment is based on the geometry, not sequence.",
"The output of [TT]do_multiprot[tt] includes the rmsd and the number of residues",
"on which it was calculated.",
"[PAR]",
"An aligned trajectory file is generated with the [TT]-ox[tt] option.[PAR]",
"With the [TT]-cr[tt] option, the number of hits in the alignment is given",
"per residue. This number can be between 0 and the number of frames, and",
"indicates the structural conservation of this residue.[PAR]",
"If you do not have the [TT]multiprot[tt] program, get it. [TT]do_multiprot[tt] assumes",
"that the [TT]multiprot[tt] executable is [TT]/usr/local/bin/multiprot[tt]. If this is ",
"not the case, then you should set an environment variable [BB]MULTIPROT[bb]",
"pointing to the [TT]multiprot[tt] executable, e.g.: [PAR]",
"[TT]setenv MULTIPROT /usr/MultiProtInstall/multiprot.Linux[tt][PAR]",
"Note that at the current implementation only binary alignment (your",
"molecule to a reference) is supported. In addition, note that the ",
"by default [TT]multiprot[tt] aligns the two proteins on their C-alpha carbons.",
"and that this depends on the [TT]multiprot[tt] parameters which are not dealt ",
"with here. Thus, the C-alpha carbons is expected to give the same "
"results as choosing the whole protein and will be slightly faster.[PAR]",
"For information about [TT]multiprot[tt], see:",
"http://bioinfo3d.cs.tau.ac.il/MultiProt/.[PAR]"
};
static bool bVerbose;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" }
};
const char *bugs[] = {
"The program is very slow, since multiprot is run externally"
};
t_trxstatus *status;
t_trxstatus *trxout=NULL;
FILE *tapein,*fo,*frc,*tmpf,*out=NULL,*fres=NULL;
const char *fnRef;
const char *fn="2_sol.res";
t_topology top;
int ePBC;
t_atoms *atoms,ratoms,useatoms;
t_trxframe fr;
t_pdbinfo p;
int nres,nres2,nr0;
real t;
int i,j,natoms,nratoms,nframe=0,model_nr=-1;
int cur_res,prev_res;
int nout;
t_countres *countres=NULL;
matrix box,rbox;
int gnx;
char *grpnm,*ss_str;
atom_id *index;
rvec *xp,*x,*xr;
char pdbfile[32],refpdb[256],title[256],rtitle[256],filemode[5];
char out_title[256];
char multiprot[256],*mptr;
int ftp;
int outftp=-1;
real rmsd;
bool bTrjout,bCountres;
const char *TrjoutFile=NULL;
output_env_t oenv;
static rvec translation={0,0,0},rotangles={0,0,0};
gmx_rmpbc_t gpbc=NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efSTX, "-r", NULL , ffREAD },
{ efXVG, "-o", "rmss", ffWRITE },
{ efXVG, "-rc", "rescount", ffWRITE},
{ efXVG, "-cr", "countres", ffOPTWR},
{ efTRX, "-ox", "aligned", ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT,
NFILE,fnm, asize(pa),pa, asize(desc),desc,
asize(bugs),bugs,&oenv
);
fnRef=opt2fn("-r",NFILE,fnm);
bTrjout = opt2bSet("-ox",NFILE,fnm);
bCountres= opt2bSet("-cr",NFILE,fnm);
if (bTrjout) {
TrjoutFile = opt2fn_null("-ox",NFILE,fnm);
}
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xp,NULL,box,FALSE);
gpbc = gmx_rmpbc_init(&top.idef,ePBC,top.atoms.nr,box);
atoms=&(top.atoms);
ftp=fn2ftp(fnRef);
get_stx_coordnum(fnRef,&nratoms);
init_t_atoms(&ratoms,nratoms,TRUE);
snew(xr,nratoms);
read_stx_conf(fnRef,rtitle,&ratoms,xr,NULL,&ePBC,rbox);
if (bVerbose) {
fprintf(stderr,"Read %d atoms\n",atoms->nr);
fprintf(stderr,"Read %d reference atoms\n",ratoms.nr);
}
if (bCountres) {
snew(countres,ratoms.nres);
j=0;
cur_res=0;
for (i=0;i<ratoms.nr;i++) {
prev_res=cur_res;
cur_res=ratoms.atom[i].resind;
if (cur_res != prev_res) {
countres[j].resnr=cur_res;
countres[j].count=0;
j++;
}
}
}
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&gnx,&index,&grpnm);
nres=0;
nr0=-1;
for(i=0; (i<gnx); i++) {
if (atoms->atom[index[i]].resind != nr0) {
nr0=atoms->atom[index[i]].resind;
nres++;
}
}
fprintf(stderr,"There are %d residues in your selected group\n",nres);
strcpy(pdbfile,"ddXXXXXX");
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
sprintf(pdbfile,"%ctmp%cfilterXXXXXX",DIR_SEPARATOR,DIR_SEPARATOR);
gmx_tmpnam(pdbfile);
if ((tmpf = fopen(pdbfile,"w")) == NULL) {
gmx_fatal(FARGS,"Can not open tmp file %s",pdbfile);
}
}
else {
gmx_ffclose(tmpf);
}
if (ftp != efPDB) {
strcpy(refpdb,"ddXXXXXX");
gmx_tmpnam(refpdb);
strcat(refpdb,".pdb");
write_sto_conf(refpdb,rtitle,&ratoms,xr,NULL,ePBC,rbox);
}
else {
strcpy(refpdb,fnRef);
}
if ((mptr=getenv("MULTIPROT")) == NULL) {
mptr="/usr/local/bin/multiprot";
}
if (!gmx_fexist(mptr)) {
gmx_fatal(FARGS,"MULTIPROT executable (%s) does not exist (use setenv MULTIPROT)",
mptr);
}
sprintf (multiprot,"%s %s %s > /dev/null %s",
mptr, refpdb, pdbfile, "2> /dev/null");
if (bVerbose)
fprintf(stderr,"multiprot cmd='%s'\n",multiprot);
if (!read_first_frame(oenv,&status,ftp2fn(efTRX,NFILE,fnm),&fr,TRX_READ_X))
gmx_fatal(FARGS,"Could not read a frame from %s",ftp2fn(efTRX,NFILE,fnm));
natoms = fr.natoms;
if (bTrjout) {
nout=natoms;
/* open file now */
outftp=fn2ftp(TrjoutFile);
if (bVerbose)
fprintf(stderr,"Will write %s: %s\n",ftp2ext(ftp),ftp2desc(outftp));
strcpy(filemode,"w");
switch (outftp) {
case efXTC:
case efG87:
case efTRR:
case efTRJ:
out=NULL;
trxout = open_trx(TrjoutFile,filemode);
break;
case efGRO:
case efG96:
case efPDB:
/* Make atoms struct for output in GRO or PDB files */
/* get memory for stuff to go in pdb file */
init_t_atoms(&useatoms,nout,FALSE);
sfree(useatoms.resinfo);
useatoms.resinfo=atoms->resinfo;
for(i=0;(i<nout);i++) {
useatoms.atomname[i]=atoms->atomname[i];
useatoms.atom[i]=atoms->atom[i];
useatoms.nres=max(useatoms.nres,useatoms.atom[i].resind+1);
}
useatoms.nr=nout;
out=gmx_ffopen(TrjoutFile,filemode);
break;
}
}
if (natoms > atoms->nr) {
gmx_fatal(FARGS,"\nTrajectory does not match topology!");
}
if (gnx > natoms) {
gmx_fatal(FARGS,"\nTrajectory does not match selected group!");
}
fo = xvgropen(opt2fn("-o",NFILE,fnm),"RMSD","Time (ps)","RMSD (nm)",oenv);
frc = xvgropen(opt2fn("-rc",NFILE,fnm),"Number of Residues in the alignment","Time (ps)","Residues",oenv);
do {
t = output_env_conv_time(oenv,fr.time);
gmx_rmpbc(gpbc,natoms,fr.box,fr.x);
tapein=gmx_ffopen(pdbfile,"w");
write_pdbfile_indexed(tapein,NULL,atoms,fr.x,ePBC,fr.box,' ',-1,gnx,index,NULL,TRUE);
gmx_ffclose(tapein);
system(multiprot);
remove(pdbfile);
process_multiprot_output(fn, &rmsd, &nres2,rotangles,translation,bCountres,countres);
fprintf(fo,"%12.7f",t);
fprintf(fo," %12.7f\n",rmsd);
fprintf(frc,"%12.7f",t);
fprintf(frc,"%12d\n",nres2);
if (bTrjout) {
rotate_conf(natoms,fr.x,NULL,rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<natoms; i++) {
rvec_inc(fr.x[i],translation);
}
switch(outftp) {
case efTRJ:
case efTRR:
case efG87:
case efXTC:
write_trxframe(trxout,&fr,NULL);
break;
case efGRO:
case efG96:
case efPDB:
sprintf(out_title,"Generated by do_multiprot : %s t= %g %s",
title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
switch(outftp) {
case efGRO:
write_hconf_p(out,out_title,&useatoms,prec2ndec(fr.prec),
fr.x,NULL,fr.box);
break;
case efPDB:
fprintf(out,"REMARK GENERATED BY DO_MULTIPROT\n");
sprintf(out_title,"%s t= %g %s",title,output_env_conv_time(oenv,fr.time),output_env_get_time_unit(oenv));
/* if reading from pdb, we want to keep the original
model numbering else we write the output frame
number plus one, because model 0 is not allowed in pdb */
if (ftp==efPDB && fr.step > model_nr) {
model_nr = fr.step;
}
else {
model_nr++;
}
write_pdbfile(out,out_title,&useatoms,fr.x,ePBC,fr.box,' ',model_nr,NULL,TRUE);
break;
case efG96:
fr.title = out_title;
fr.bTitle = (nframe == 0);
fr.bAtoms = FALSE;
fr.bStep = TRUE;
fr.bTime = TRUE;
write_g96_conf(out,&fr,-1,NULL);
}
break;
}
}
nframe++;
} while(read_next_frame(oenv,status,&fr));
if (bCountres) {
fres= xvgropen(opt2fn("-cr",NFILE,fnm),"Number of frames in which the residues are aligned to","Residue","Number",oenv);
for (i=0;i<ratoms.nres;i++) {
fprintf(fres,"%10d %12d\n",countres[i].resnr,countres[i].count);
}
gmx_ffclose(fres);
}
gmx_ffclose(fo);
gmx_ffclose(frc);
fprintf(stderr,"\n");
close_trj(status);
if (trxout != NULL) {
close_trx(trxout);
}
else if (out != NULL) {
gmx_ffclose(out);
}
view_all(oenv,NFILE, fnm);
sfree(xr);
if (bCountres) {
sfree(countres);
}
free_t_atoms(&ratoms,TRUE);
if (bTrjout) {
if (outftp==efPDB || outftp==efGRO || outftp==efG96) {
free_t_atoms(&useatoms,TRUE);
}
}
gmx_thanx(stderr);
return 0;
}
static void project(const char *trajfile,t_topology *top,int ePBC,matrix topbox,
const char *projfile,const char *twodplotfile,
const char *threedplotfile, const char *filterfile,int skip,
const char *extremefile,gmx_bool bExtrAll,real extreme,
int nextr, t_atoms *atoms,int natoms,atom_id *index,
gmx_bool bFit,rvec *xref,int nfit,atom_id *ifit,real *w_rls,
real *sqrtm,rvec *xav,
int *eignr,rvec **eigvec,
int noutvec,int *outvec, gmx_bool bSplit,
const output_env_t oenv)
{
FILE *xvgrout=NULL;
int nat,i,j,d,v,vec,nfr,nframes=0,snew_size,frame;
t_trxstatus *out=NULL;
t_trxstatus *status;
int noutvec_extr,imin,imax;
real *pmin,*pmax;
atom_id *all_at;
matrix box;
rvec *xread,*x;
real t,inp,**inprod=NULL,min=0,max=0;
char str[STRLEN],str2[STRLEN],**ylabel,*c;
real fact;
gmx_rmpbc_t gpbc=NULL;
snew(x,natoms);
if (bExtrAll)
noutvec_extr=noutvec;
else
noutvec_extr=1;
if (trajfile) {
snew(inprod,noutvec+1);
if (filterfile) {
fprintf(stderr,"Writing a filtered trajectory to %s using eigenvectors\n",
filterfile);
for(i=0; i<noutvec; i++)
fprintf(stderr,"%d ",outvec[i]+1);
fprintf(stderr,"\n");
out=open_trx(filterfile,"w");
}
snew_size=0;
nfr=0;
nframes=0;
nat=read_first_x(oenv,&status,trajfile,&t,&xread,box);
if (nat>atoms->nr)
gmx_fatal(FARGS,"the number of atoms in your trajectory (%d) is larger than the number of atoms in your structure file (%d)",nat,atoms->nr);
snew(all_at,nat);
if (top)
gpbc = gmx_rmpbc_init(&top->idef,ePBC,nat,box);
for(i=0; i<nat; i++)
all_at[i]=i;
do {
if (nfr % skip == 0) {
if (top)
gmx_rmpbc(gpbc,nat,box,xread);
if (nframes>=snew_size) {
snew_size+=100;
for(i=0; i<noutvec+1; i++)
srenew(inprod[i],snew_size);
}
inprod[noutvec][nframes]=t;
/* calculate x: a fitted struture of the selected atoms */
if (bFit) {
reset_x(nfit,ifit,nat,NULL,xread,w_rls);
do_fit(nat,w_rls,xref,xread);
}
for (i=0; i<natoms; i++)
copy_rvec(xread[index[i]],x[i]);
for(v=0; v<noutvec; v++) {
vec=outvec[v];
/* calculate (mass-weighted) projection */
inp=0;
for (i=0; i<natoms; i++) {
inp+=(eigvec[vec][i][0]*(x[i][0]-xav[i][0])+
eigvec[vec][i][1]*(x[i][1]-xav[i][1])+
eigvec[vec][i][2]*(x[i][2]-xav[i][2]))*sqrtm[i];
}
inprod[v][nframes]=inp;
}
if (filterfile) {
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++) {
/* misuse xread for output */
xread[index[i]][d] = xav[i][d];
for(v=0; v<noutvec; v++)
xread[index[i]][d] +=
inprod[v][nframes]*eigvec[outvec[v]][i][d]/sqrtm[i];
}
write_trx(out,natoms,index,atoms,0,t,box,xread,NULL,NULL);
}
nframes++;
}
nfr++;
} while (read_next_x(oenv,status,&t,nat,xread,box));
close_trx(status);
sfree(x);
if (filterfile)
close_trx(out);
}
else
snew(xread,atoms->nr);
if (top)
gmx_rmpbc_done(gpbc);
if (projfile) {
snew(ylabel,noutvec);
for(v=0; v<noutvec; v++) {
sprintf(str,"vec %d",eignr[outvec[v]]+1);
ylabel[v]=strdup(str);
}
sprintf(str,"projection on eigenvectors (%s)",proj_unit);
write_xvgr_graphs(projfile, noutvec, 1, str, NULL, output_env_get_xvgr_tlabel(oenv),
(const char **)ylabel,
nframes, inprod[noutvec], inprod, NULL,
output_env_get_time_factor(oenv), FALSE, bSplit,oenv);
}
if (twodplotfile) {
sprintf(str,"projection on eigenvector %d (%s)",
eignr[outvec[0]]+1,proj_unit);
sprintf(str2,"projection on eigenvector %d (%s)",
eignr[outvec[noutvec-1]]+1,proj_unit);
xvgrout=xvgropen(twodplotfile,"2D projection of trajectory",str,str2,
oenv);
for(i=0; i<nframes; i++) {
if ( bSplit && i>0 && abs(inprod[noutvec][i])<1e-5 )
fprintf(xvgrout,"&\n");
fprintf(xvgrout,"%10.5f %10.5f\n",inprod[0][i],inprod[noutvec-1][i]);
}
ffclose(xvgrout);
}
if (threedplotfile) {
t_atoms atoms;
rvec *x;
real *b=NULL;
matrix box;
char *resnm,*atnm, pdbform[STRLEN];
gmx_bool bPDB, b4D;
FILE *out;
if (noutvec < 3)
gmx_fatal(FARGS,"You have selected less than 3 eigenvectors");
/* initialize */
bPDB = fn2ftp(threedplotfile)==efPDB;
clear_mat(box);
box[XX][XX] = box[YY][YY] = box[ZZ][ZZ] = 1;
b4D = bPDB && (noutvec >= 4);
if (b4D) {
fprintf(stderr, "You have selected four or more eigenvectors:\n"
"fourth eigenvector will be plotted "
"in bfactor field of pdb file\n");
sprintf(str,"4D proj. of traj. on eigenv. %d, %d, %d and %d",
eignr[outvec[0]]+1,eignr[outvec[1]]+1,
eignr[outvec[2]]+1,eignr[outvec[3]]+1);
} else {
sprintf(str,"3D proj. of traj. on eigenv. %d, %d and %d",
eignr[outvec[0]]+1,eignr[outvec[1]]+1,eignr[outvec[2]]+1);
}
init_t_atoms(&atoms,nframes,FALSE);
snew(x,nframes);
snew(b,nframes);
atnm=strdup("C");
resnm=strdup("PRJ");
if(nframes>10000)
fact=10000.0/nframes;
else
fact=1.0;
for(i=0; i<nframes; i++) {
atoms.atomname[i] = &atnm;
atoms.atom[i].resind = i;
atoms.resinfo[i].name = &resnm;
atoms.resinfo[i].nr = ceil(i*fact);
atoms.resinfo[i].ic = ' ';
x[i][XX]=inprod[0][i];
x[i][YY]=inprod[1][i];
x[i][ZZ]=inprod[2][i];
if (b4D)
b[i] =inprod[3][i];
}
if ( ( b4D || bSplit ) && bPDB ) {
strcpy(pdbform,get_pdbformat());
strcat(pdbform,"%8.4f%8.4f\n");
out=ffopen(threedplotfile,"w");
fprintf(out,"HEADER %s\n",str);
if ( b4D )
fprintf(out,"REMARK %s\n","fourth dimension plotted as B-factor");
j=0;
for(i=0; i<atoms.nr; i++) {
if ( j>0 && bSplit && abs(inprod[noutvec][i])<1e-5 ) {
fprintf(out,"TER\n");
j=0;
}
fprintf(out,pdbform,"ATOM",i+1,"C","PRJ",' ',j+1,
PR_VEC(10*x[i]), 1.0, 10*b[i]);
if (j>0)
fprintf(out,"CONECT%5d%5d\n", i, i+1);
j++;
}
fprintf(out,"TER\n");
ffclose(out);
} else
write_sto_conf(threedplotfile,str,&atoms,x,NULL,ePBC,box);
free_t_atoms(&atoms,FALSE);
}
if (extremefile) {
snew(pmin,noutvec_extr);
snew(pmax,noutvec_extr);
if (extreme==0) {
fprintf(stderr,"%11s %17s %17s\n","eigenvector","Minimum","Maximum");
fprintf(stderr,
"%11s %10s %10s %10s %10s\n","","value","frame","value","frame");
imin = 0;
imax = 0;
for(v=0; v<noutvec_extr; v++) {
for(i=0; i<nframes; i++) {
if (inprod[v][i]<inprod[v][imin])
imin = i;
if (inprod[v][i]>inprod[v][imax])
imax = i;
}
pmin[v] = inprod[v][imin];
pmax[v] = inprod[v][imax];
fprintf(stderr,"%7d %10.6f %10d %10.6f %10d\n",
eignr[outvec[v]]+1,
pmin[v],imin,pmax[v],imax);
}
}
else {
pmin[0] = -extreme;
pmax[0] = extreme;
}
/* build format string for filename: */
strcpy(str,extremefile);/* copy filename */
c=strrchr(str,'.'); /* find where extention begins */
strcpy(str2,c); /* get extention */
sprintf(c,"%%d%s",str2); /* append '%s' and extention to filename */
for(v=0; v<noutvec_extr; v++) {
/* make filename using format string */
if (noutvec_extr==1)
strcpy(str2,extremefile);
else
sprintf(str2,str,eignr[outvec[v]]+1);
fprintf(stderr,"Writing %d frames along eigenvector %d to %s\n",
nextr,outvec[v]+1,str2);
out=open_trx(str2,"w");
for(frame=0; frame<nextr; frame++) {
if ((extreme==0) && (nextr<=3))
for(i=0; i<natoms; i++) {
atoms->resinfo[atoms->atom[index[i]].resind].chainid = 'A' + frame;
}
for(i=0; i<natoms; i++)
for(d=0; d<DIM; d++)
xread[index[i]][d] =
(xav[i][d] + (pmin[v]*(nextr-frame-1)+pmax[v]*frame)/(nextr-1)
*eigvec[outvec[v]][i][d]/sqrtm[i]);
write_trx(out,natoms,index,atoms,0,frame,topbox,xread,NULL,NULL);
}
close_trx(out);
}
sfree(pmin);
sfree(pmax);
}
fprintf(stderr,"\n");
}
int gmx_anaeig(int argc,char *argv[])
{
static const char *desc[] = {
"[TT]g_anaeig[tt] analyzes eigenvectors. The eigenvectors can be of a",
"covariance matrix ([TT]g_covar[tt]) or of a Normal Modes analysis",
"([TT]g_nmeig[tt]).[PAR]",
"When a trajectory is projected on eigenvectors, all structures are",
"fitted to the structure in the eigenvector file, if present, otherwise",
"to the structure in the structure file. When no run input file is",
"supplied, periodicity will not be taken into account. Most analyses",
"are performed on eigenvectors [TT]-first[tt] to [TT]-last[tt], but when",
"[TT]-first[tt] is set to -1 you will be prompted for a selection.[PAR]",
"[TT]-comp[tt]: plot the vector components per atom of eigenvectors",
"[TT]-first[tt] to [TT]-last[tt].[PAR]",
"[TT]-rmsf[tt]: plot the RMS fluctuation per atom of eigenvectors",
"[TT]-first[tt] to [TT]-last[tt] (requires [TT]-eig[tt]).[PAR]",
"[TT]-proj[tt]: calculate projections of a trajectory on eigenvectors",
"[TT]-first[tt] to [TT]-last[tt].",
"The projections of a trajectory on the eigenvectors of its",
"covariance matrix are called principal components (pc's).",
"It is often useful to check the cosine content of the pc's,",
"since the pc's of random diffusion are cosines with the number",
"of periods equal to half the pc index.",
"The cosine content of the pc's can be calculated with the program",
"[TT]g_analyze[tt].[PAR]",
"[TT]-2d[tt]: calculate a 2d projection of a trajectory on eigenvectors",
"[TT]-first[tt] and [TT]-last[tt].[PAR]",
"[TT]-3d[tt]: calculate a 3d projection of a trajectory on the first",
"three selected eigenvectors.[PAR]",
"[TT]-filt[tt]: filter the trajectory to show only the motion along",
"eigenvectors [TT]-first[tt] to [TT]-last[tt].[PAR]",
"[TT]-extr[tt]: calculate the two extreme projections along a trajectory",
"on the average structure and interpolate [TT]-nframes[tt] frames",
"between them, or set your own extremes with [TT]-max[tt]. The",
"eigenvector [TT]-first[tt] will be written unless [TT]-first[tt] and",
"[TT]-last[tt] have been set explicitly, in which case all eigenvectors",
"will be written to separate files. Chain identifiers will be added",
"when writing a [TT].pdb[tt] file with two or three structures (you",
"can use [TT]rasmol -nmrpdb[tt] to view such a [TT].pdb[tt] file).[PAR]",
" Overlap calculations between covariance analysis:[BR]",
" [BB]Note:[bb] the analysis should use the same fitting structure[PAR]",
"[TT]-over[tt]: calculate the subspace overlap of the eigenvectors in",
"file [TT]-v2[tt] with eigenvectors [TT]-first[tt] to [TT]-last[tt]",
"in file [TT]-v[tt].[PAR]",
"[TT]-inpr[tt]: calculate a matrix of inner-products between",
"eigenvectors in files [TT]-v[tt] and [TT]-v2[tt]. All eigenvectors",
"of both files will be used unless [TT]-first[tt] and [TT]-last[tt]",
"have been set explicitly.[PAR]",
"When [TT]-v[tt], [TT]-eig[tt], [TT]-v2[tt] and [TT]-eig2[tt] are given,",
"a single number for the overlap between the covariance matrices is",
"generated. The formulas are:[BR]",
" difference = sqrt(tr((sqrt(M1) - sqrt(M2))^2))[BR]",
"normalized overlap = 1 - difference/sqrt(tr(M1) + tr(M2))[BR]",
" shape overlap = 1 - sqrt(tr((sqrt(M1/tr(M1)) - sqrt(M2/tr(M2)))^2))[BR]",
"where M1 and M2 are the two covariance matrices and tr is the trace",
"of a matrix. The numbers are proportional to the overlap of the square",
"root of the fluctuations. The normalized overlap is the most useful",
"number, it is 1 for identical matrices and 0 when the sampled",
"subspaces are orthogonal.[PAR]",
"When the [TT]-entropy[tt] flag is given an entropy estimate will be",
"computed based on the Quasiharmonic approach and based on",
"Schlitter's formula."
};
static int first=1,last=-1,skip=1,nextr=2,nskip=6;
static real max=0.0,temp=298.15;
static gmx_bool bSplit=FALSE,bEntropy=FALSE;
t_pargs pa[] = {
{ "-first", FALSE, etINT, {&first},
"First eigenvector for analysis (-1 is select)" },
{ "-last", FALSE, etINT, {&last},
"Last eigenvector for analysis (-1 is till the last)" },
{ "-skip", FALSE, etINT, {&skip},
"Only analyse every nr-th frame" },
{ "-max", FALSE, etREAL, {&max},
"Maximum for projection of the eigenvector on the average structure, "
"max=0 gives the extremes" },
{ "-nframes", FALSE, etINT, {&nextr},
"Number of frames for the extremes output" },
{ "-split", FALSE, etBOOL, {&bSplit},
"Split eigenvector projections where time is zero" },
{ "-entropy", FALSE, etBOOL, {&bEntropy},
"Compute entropy according to the Quasiharmonic formula or Schlitter's method." },
{ "-temp", FALSE, etREAL, {&temp},
"Temperature for entropy calculations" },
{ "-nevskip", FALSE, etINT, {&nskip},
"Number of eigenvalues to skip when computing the entropy due to the quasi harmonic approximation. When you do a rotational and/or translational fit prior to the covariance analysis, you get 3 or 6 eigenvalues that are very close to zero, and which should not be taken into account when computing the entropy." }
};
#define NPA asize(pa)
FILE *out;
int status,trjout;
t_topology top;
int ePBC=-1;
t_atoms *atoms=NULL;
rvec *xtop,*xref1,*xref2,*xrefp=NULL;
gmx_bool bDMR1,bDMA1,bDMR2,bDMA2;
int nvec1,nvec2,*eignr1=NULL,*eignr2=NULL;
rvec *x,*xread,*xav1,*xav2,**eigvec1=NULL,**eigvec2=NULL;
matrix topbox;
real xid,totmass,*sqrtm,*w_rls,t,lambda;
int natoms,step;
char *grpname;
const char *indexfile;
char title[STRLEN];
int i,j,d;
int nout,*iout,noutvec,*outvec,nfit;
atom_id *index,*ifit;
const char *VecFile,*Vec2File,*topfile;
const char *EigFile,*Eig2File;
const char *CompFile,*RmsfFile,*ProjOnVecFile;
const char *TwoDPlotFile,*ThreeDPlotFile;
const char *FilterFile,*ExtremeFile;
const char *OverlapFile,*InpMatFile;
gmx_bool bFit1,bFit2,bM,bIndex,bTPS,bTop,bVec2,bProj;
gmx_bool bFirstToLast,bFirstLastSet,bTraj,bCompare,bPDB3D;
real *eigval1=NULL,*eigval2=NULL;
int neig1,neig2;
double **xvgdata;
output_env_t oenv;
gmx_rmpbc_t gpbc;
t_filenm fnm[] = {
{ efTRN, "-v", "eigenvec", ffREAD },
{ efTRN, "-v2", "eigenvec2", ffOPTRD },
{ efTRX, "-f", NULL, ffOPTRD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-eig", "eigenval", ffOPTRD },
{ efXVG, "-eig2", "eigenval2", ffOPTRD },
{ efXVG, "-comp", "eigcomp", ffOPTWR },
{ efXVG, "-rmsf", "eigrmsf", ffOPTWR },
{ efXVG, "-proj", "proj", ffOPTWR },
{ efXVG, "-2d", "2dproj", ffOPTWR },
{ efSTO, "-3d", "3dproj.pdb", ffOPTWR },
{ efTRX, "-filt", "filtered", ffOPTWR },
{ efTRX, "-extr", "extreme.pdb", ffOPTWR },
{ efXVG, "-over", "overlap", ffOPTWR },
{ efXPM, "-inpr", "inprod", ffOPTWR }
};
#define NFILE asize(fnm)
parse_common_args(&argc,argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW | PCA_BE_NICE ,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL,&oenv);
indexfile=ftp2fn_null(efNDX,NFILE,fnm);
VecFile = opt2fn("-v",NFILE,fnm);
Vec2File = opt2fn_null("-v2",NFILE,fnm);
topfile = ftp2fn(efTPS,NFILE,fnm);
EigFile = opt2fn_null("-eig",NFILE,fnm);
Eig2File = opt2fn_null("-eig2",NFILE,fnm);
CompFile = opt2fn_null("-comp",NFILE,fnm);
RmsfFile = opt2fn_null("-rmsf",NFILE,fnm);
ProjOnVecFile = opt2fn_null("-proj",NFILE,fnm);
TwoDPlotFile = opt2fn_null("-2d",NFILE,fnm);
ThreeDPlotFile = opt2fn_null("-3d",NFILE,fnm);
FilterFile = opt2fn_null("-filt",NFILE,fnm);
ExtremeFile = opt2fn_null("-extr",NFILE,fnm);
OverlapFile = opt2fn_null("-over",NFILE,fnm);
InpMatFile = ftp2fn_null(efXPM,NFILE,fnm);
bTop = fn2bTPX(topfile);
bProj = ProjOnVecFile || TwoDPlotFile || ThreeDPlotFile
|| FilterFile || ExtremeFile;
bFirstLastSet =
opt2parg_bSet("-first",NPA,pa) && opt2parg_bSet("-last",NPA,pa);
bFirstToLast = CompFile || RmsfFile || ProjOnVecFile || FilterFile ||
OverlapFile || ((ExtremeFile || InpMatFile) && bFirstLastSet);
bVec2 = Vec2File || OverlapFile || InpMatFile;
bM = RmsfFile || bProj;
bTraj = ProjOnVecFile || FilterFile || (ExtremeFile && (max==0))
|| TwoDPlotFile || ThreeDPlotFile;
bIndex = bM || bProj;
bTPS = ftp2bSet(efTPS,NFILE,fnm) || bM || bTraj ||
FilterFile || (bIndex && indexfile);
bCompare = Vec2File || Eig2File;
bPDB3D = fn2ftp(ThreeDPlotFile)==efPDB;
read_eigenvectors(VecFile,&natoms,&bFit1,
&xref1,&bDMR1,&xav1,&bDMA1,
&nvec1,&eignr1,&eigvec1,&eigval1);
neig1 = DIM*natoms;
/* Overwrite eigenvalues from separate files if the user provides them */
if (EigFile != NULL) {
int neig_tmp = read_xvg(EigFile,&xvgdata,&i);
if (neig_tmp != neig1)
fprintf(stderr,"Warning: number of eigenvalues in xvg file (%d) does not mtch trr file (%d)\n",neig1,natoms);
neig1 = neig_tmp;
srenew(eigval1,neig1);
for(j=0;j<neig1;j++) {
real tmp = eigval1[j];
eigval1[j]=xvgdata[1][j];
if (debug && (eigval1[j] != tmp))
fprintf(debug,"Replacing eigenvalue %d. From trr: %10g, from xvg: %10g\n",
j,tmp,eigval1[j]);
}
for(j=0;j<i;j++)
sfree(xvgdata[j]);
sfree(xvgdata);
fprintf(stderr,"Read %d eigenvalues from %s\n",neig1,EigFile);
}
if (bEntropy) {
if (bDMA1) {
gmx_fatal(FARGS,"Can not calculate entropies from mass-weighted eigenvalues, redo the analysis without mass-weighting");
}
calc_entropy_qh(stdout,neig1,eigval1,temp,nskip);
calc_entropy_schlitter(stdout,neig1,nskip,eigval1,temp);
}
if (bVec2) {
if (!Vec2File)
gmx_fatal(FARGS,"Need a second eigenvector file to do this analysis.");
read_eigenvectors(Vec2File,&neig2,&bFit2,
&xref2,&bDMR2,&xav2,&bDMA2,&nvec2,&eignr2,&eigvec2,&eigval2);
neig2 = DIM*neig2;
if (neig2 != neig1)
gmx_fatal(FARGS,"Dimensions in the eigenvector files don't match");
}
if(Eig2File != NULL) {
neig2 = read_xvg(Eig2File,&xvgdata,&i);
srenew(eigval2,neig2);
for(j=0;j<neig2;j++)
eigval2[j]=xvgdata[1][j];
for(j=0;j<i;j++)
sfree(xvgdata[j]);
sfree(xvgdata);
fprintf(stderr,"Read %d eigenvalues from %s\n",neig2,Eig2File);
}
if ((!bFit1 || xref1) && !bDMR1 && !bDMA1)
bM=FALSE;
if ((xref1==NULL) && (bM || bTraj))
bTPS=TRUE;
xtop=NULL;
nfit=0;
ifit=NULL;
w_rls=NULL;
if (!bTPS) {
bTop=FALSE;
} else {
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);
gmx_rmpbc(gpbc,atoms->nr,topbox,xtop);
/* Fitting is only required for the projection */
if (bProj && bFit1) {
if (xref1 == NULL) {
printf("\nNote: the structure in %s should be the same\n"
" as the one used for the fit in g_covar\n",topfile);
}
printf("\nSelect the index group that was used for the least squares fit in g_covar\n");
get_index(atoms,indexfile,1,&nfit,&ifit,&grpname);
snew(w_rls,atoms->nr);
for(i=0; (i<nfit); i++) {
if (bDMR1) {
w_rls[ifit[i]] = atoms->atom[ifit[i]].m;
} else {
w_rls[ifit[i]] = 1.0;
}
}
snew(xrefp,atoms->nr);
if (xref1 != NULL) {
for(i=0; (i<nfit); i++) {
copy_rvec(xref1[i],xrefp[ifit[i]]);
}
} else {
/* The top coordinates are the fitting reference */
for(i=0; (i<nfit); i++) {
copy_rvec(xtop[ifit[i]],xrefp[ifit[i]]);
}
reset_x(nfit,ifit,atoms->nr,NULL,xrefp,w_rls);
}
}
gmx_rmpbc_done(gpbc);
}
if (bIndex) {
printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n",natoms);
get_index(atoms,indexfile,1,&i,&index,&grpname);
if (i!=natoms)
gmx_fatal(FARGS,"you selected a group with %d elements instead of %d",i,natoms);
printf("\n");
}
snew(sqrtm,natoms);
if (bM && bDMA1) {
proj_unit="u\\S1/2\\Nnm";
for(i=0; (i<natoms); i++)
sqrtm[i]=sqrt(atoms->atom[index[i]].m);
}
else {
proj_unit="nm";
for(i=0; (i<natoms); i++)
sqrtm[i]=1.0;
}
if (bVec2) {
t=0;
totmass=0;
for(i=0; (i<natoms); i++)
for(d=0;(d<DIM);d++) {
t+=sqr((xav1[i][d]-xav2[i][d])*sqrtm[i]);
totmass+=sqr(sqrtm[i]);
}
fprintf(stdout,"RMSD (without fit) between the two average structures:"
" %.3f (nm)\n\n",sqrt(t/totmass));
}
if (last==-1)
last=natoms*DIM;
if (first>-1) {
if (bFirstToLast) {
/* make an index from first to last */
nout=last-first+1;
snew(iout,nout);
for(i=0; i<nout; i++)
iout[i]=first-1+i;
}
else if (ThreeDPlotFile) {
/* make an index of first+(0,1,2) and last */
nout = bPDB3D ? 4 : 3;
nout = min(last-first+1, nout);
snew(iout,nout);
iout[0]=first-1;
iout[1]=first;
if (nout>3)
iout[2]=first+1;
iout[nout-1]=last-1;
}
else {
/* make an index of first and last */
nout=2;
snew(iout,nout);
iout[0]=first-1;
iout[1]=last-1;
}
}
else {
printf("Select eigenvectors for output, end your selection with 0\n");
nout=-1;
iout=NULL;
do {
nout++;
srenew(iout,nout+1);
if(1 != scanf("%d",&iout[nout]))
{
gmx_fatal(FARGS,"Error reading user input");
}
iout[nout]--;
}
while (iout[nout]>=0);
printf("\n");
}
/* make an index of the eigenvectors which are present */
snew(outvec,nout);
noutvec=0;
for(i=0; i<nout; i++)
{
j=0;
while ((j<nvec1) && (eignr1[j]!=iout[i]))
j++;
if ((j<nvec1) && (eignr1[j]==iout[i]))
{
outvec[noutvec]=j;
noutvec++;
}
}
fprintf(stderr,"%d eigenvectors selected for output",noutvec);
if (noutvec <= 100)
{
fprintf(stderr,":");
for(j=0; j<noutvec; j++)
fprintf(stderr," %d",eignr1[outvec[j]]+1);
}
fprintf(stderr,"\n");
if (CompFile)
components(CompFile,natoms,eignr1,eigvec1,noutvec,outvec,oenv);
if (RmsfFile)
rmsf(RmsfFile,natoms,sqrtm,eignr1,eigvec1,noutvec,outvec,eigval1,
neig1,oenv);
if (bProj)
project(bTraj ? opt2fn("-f",NFILE,fnm) : NULL,
bTop ? &top : NULL,ePBC,topbox,
ProjOnVecFile,TwoDPlotFile,ThreeDPlotFile,FilterFile,skip,
ExtremeFile,bFirstLastSet,max,nextr,atoms,natoms,index,
bFit1,xrefp,nfit,ifit,w_rls,
sqrtm,xav1,eignr1,eigvec1,noutvec,outvec,bSplit,
oenv);
if (OverlapFile)
overlap(OverlapFile,natoms,
eigvec1,nvec2,eignr2,eigvec2,noutvec,outvec,oenv);
if (InpMatFile)
inprod_matrix(InpMatFile,natoms,
nvec1,eignr1,eigvec1,nvec2,eignr2,eigvec2,
bFirstLastSet,noutvec,outvec);
if (bCompare)
compare(natoms,nvec1,eigvec1,nvec2,eigvec2,eigval1,neig1,eigval2,neig2);
if (!CompFile && !bProj && !OverlapFile && !InpMatFile &&
!bCompare && !bEntropy)
{
fprintf(stderr,"\nIf you want some output,"
" set one (or two or ...) of the output file options\n");
}
view_all(oenv,NFILE, fnm);
thanx(stdout);
return 0;
}
int gmx_editconf(int argc, char *argv[])
{
const char
*desc[] =
{
"editconf converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
"or [TT].pdb[tt].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and",
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"The volume of a dodecahedron is 0.71 and that of a truncated octahedron",
"is 0.77 of that of a cubic box with the same periodic image distance.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic box, dodecahedron and a truncated octahedron.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the x, y",
"and z directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and can not be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, this may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a gro",
"file is given as input. A special feature of the scaling option, when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the plains, when one uses -1 in three dimensions",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box sizes at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [TT].pdb[tt] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless an index is larger than the number of residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option -mead a special pdb (pqr) file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option -grasp is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Option [TT]-align[tt] allows alignment",
"of the principal axis of a specified group against the given vector, ",
"with an optional center of rotation specified by [TT]-aligncenter[tt].",
"[PAR]",
"Finally with option [TT]-label[tt] editconf can add a chain identifier",
"to a pdb file, which can be useful for analysis with e.g. rasmol.",
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as Gromos) use:[BR]",
"[TT]editconf -f <in> -rotate 0 45 35.264 -bt o -box <veclen> -o <out>[tt][BR]",
"where [TT]veclen[tt] is the size of the cubic box times sqrt(3)/2." };
const char *bugs[] =
{
"For complex molecules, the periodicity removal routine may break down, ",
"in that case you can use trjconv." };
static real dist = 0.0, rbox = 0.0, to_diam = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
FALSE, bCONECT = FALSE;
static gmx_bool peratom = FALSE, bLegend = FALSE, bOrient = FALSE, bMead =
FALSE, bGrasp = FALSE, bSig56 = FALSE;
static rvec scale =
{ 1, 1, 1 }, newbox =
{ 0, 0, 0 }, newang =
{ 90, 90, 90 };
static real rho = 1000.0, rvdw = 0.12;
static rvec center =
{ 0, 0, 0 }, translation =
{ 0, 0, 0 }, rotangles =
{ 0, 0, 0 }, aligncenter =
{ 0, 0, 0 }, targetvec =
{ 0, 0, 0 };
static const char *btype[] =
{ NULL, "triclinic", "cubic", "dodecahedron", "octahedron", NULL },
*label = "A";
static rvec visbox =
{ 0, 0, 0 };
t_pargs
pa[] =
{
{ "-ndef", FALSE, etBOOL,
{ &bNDEF }, "Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC,
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
{ btype }, "Box type for -box and -d" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ newang }, "Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
"Center molecule in box (implied by -box and -d)" },
{ "-center", FALSE, etRVEC,
{ center }, "Coordinates of geometrical center" },
{ "-aligncenter", FALSE, etRVEC,
{ aligncenter }, "Center of rotation for alignment" },
{ "-align", FALSE, etRVEC,
{ targetvec },
"Align to target vector" },
{ "-translate", FALSE, etRVEC,
{ translation }, "Translation" },
{ "-rotate", FALSE, etRVEC,
{ rotangles },
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL,
{ &bOrient },
"Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC,
{ scale }, "Scaling factor" },
{ "-density", FALSE, etREAL,
{ &rho },
"Density (g/l) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL,
{ &bRMPBC },
"Remove the periodicity (make molecule whole again)" },
{ "-grasp", FALSE, etBOOL,
{ &bGrasp },
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{
"-rvdw", FALSE, etREAL,
{ &rvdw },
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file" },
{ "-sig56", FALSE, etREAL,
{ &bSig56 },
"Use rmin/2 (minimum in the Van der Waals potential) rather than sigma/2 " },
{
"-vdwread", FALSE, etBOOL,
{ &bReadVDW },
"Read the Van der Waals radii from the file vdwradii.dat rather than computing the radii based on the force field" },
{ "-atom", FALSE, etBOOL,
{ &peratom }, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL,
{ &bLegend }, "Make B-factor legend" },
{ "-label", FALSE, etSTR,
{ &label }, "Add chain label for all residues" },
{
"-conect", FALSE, etBOOL,
{ &bCONECT },
"Add CONECT records to a pdb file when written. Can only be done when a topology is present" } };
#define NPA asize(pa)
FILE *out;
const char *infile, *outfile;
char title[STRLEN];
int outftp, inftp, natom, i, j, n_bfac, itype, ntype;
double *bfac = NULL, c6, c12;
int *bfac_nr = NULL;
t_topology *top = NULL;
t_atoms atoms;
char *grpname, *sgrpname, *agrpname;
int isize, ssize, tsize, asize;
atom_id *index, *sindex, *tindex, *aindex;
rvec *x, *v, gc, min, max, size;
int ePBC;
matrix box,rotmatrix,trans;
rvec princd,tmpvec;
gmx_bool bIndex, bSetSize, bSetAng, bCubic, bDist, bSetCenter, bAlign;
gmx_bool bHaveV, bScale, bRho, bTranslate, bRotate, bCalcGeom, bCalcDiam;
real xs, ys, zs, xcent, ycent, zcent, diam = 0, mass = 0, d, vdw;
gmx_atomprop_t aps;
gmx_conect conect;
output_env_t oenv;
t_filenm fnm[] =
{
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efSTO, NULL, NULL, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD } };
#define NFILE asize(fnm)
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_CAN_VIEW, NFILE, fnm, NPA, pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bIndex = opt2bSet("-n", NFILE, fnm) || bNDEF;
bMead = opt2bSet("-mead", NFILE, fnm);
bSetSize = opt2parg_bSet("-box", NPA, pa);
bSetAng = opt2parg_bSet("-angles", NPA, pa);
bSetCenter = opt2parg_bSet("-center", NPA, pa);
bDist = opt2parg_bSet("-d", NPA, pa);
bAlign = opt2parg_bSet("-align", NPA, pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c", NPA, pa))
{
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale", NPA, pa);
bRho = opt2parg_bSet("-density", NPA, pa);
bTranslate = opt2parg_bSet("-translate", NPA, pa);
bRotate = opt2parg_bSet("-rotate", NPA, pa);
if (bScale && bRho)
fprintf(stderr, "WARNING: setting -density overrides -scale\n");
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
bCalcDiam = btype[0][0] == 'c' || btype[0][0] == 'd' || btype[0][0] == 'o';
infile = ftp2fn(efSTX, NFILE, fnm);
if (bMead)
outfile = ftp2fn(efPQR, NFILE, fnm);
else
outfile = ftp2fn(efSTO, NFILE, fnm);
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp)
{
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
gmx_fatal(FARGS, "Output file should be a .pdb file"
" when using the -grasp option\n");
if ((bMead || bGrasp) && !((fn2ftp(infile) == efTPR) ||
(fn2ftp(infile) == efTPA) ||
(fn2ftp(infile) == efTPB)))
gmx_fatal(FARGS,"Input file should be a .tp[abr] file"
" when using the -mead option\n");
get_stx_coordnum(infile,&natom);
init_t_atoms(&atoms,natom,TRUE);
snew(x,natom);
snew(v,natom);
read_stx_conf(infile,title,&atoms,x,v,&ePBC,box);
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms,aps);
}
printf("Read %d atoms\n",atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
get_pdb_atomnumber(&atoms,aps);
if (ePBC != epbcNONE)
{
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol,100*((int)(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
top = read_top(infile,NULL);
if (bMead || bGrasp)
{
if (atoms.nr != top->atoms.nr)
gmx_fatal(FARGS,"Atom numbers don't match (%d vs. %d)",atoms.nr,top->atoms.nr);
snew(atoms.pdbinfo,top->atoms.nr);
ntype = top->idef.atnr;
for(i=0; (i<atoms.nr); i++) {
/* Determine the Van der Waals radius from the force field */
if (bReadVDW) {
if (!gmx_atomprop_query(aps,epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i],&vdw))
vdw = rvdw;
}
else {
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0)) {
real sig6;
if (bSig56)
sig6 = 2*c12/c6;
else
sig6 = c12/c6;
vdw = 0.5*pow(sig6,1.0/6.0);
}
else
vdw = rvdw;
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead) {
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else {
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV=FALSE;
for (i=0; (i<natom) && !bHaveV; i++)
for (j=0; (j<DIM) && !bHaveV; j++)
bHaveV=bHaveV || (v[i][j]!=0);
printf("%selocities found\n",bHaveV?"V":"No v");
if (visbox[0] > 0) {
if (bIndex)
gmx_fatal(FARGS,"Sorry, can not visualize box with index groups");
if (outftp != efPDB)
gmx_fatal(FARGS,"Sorry, can only visualize box with a pdb file");
} else if (visbox[0] == -1)
visualize_images("images.pdb",ePBC,box);
/* remove pbc */
if (bRMPBC)
rm_gropbc(&atoms,x,box);
if (bCalcGeom) {
if (bIndex) {
fprintf(stderr,"\nSelect a group for determining the system size:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
diam=calc_geom(ssize,sindex,x,gc,min,max,bCalcDiam);
rvec_sub(max, min, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
printf(" diameter :%7.3f (nm)\n",diam);
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf(" box volume :%7.2f (nm^3)\n",det(box));
}
if (bRho || bOrient || bAlign)
mass = calc_mass(&atoms,!fn2bTPX(infile),aps);
if (bOrient) {
atom_id *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr,"\nSelect group for the determining the orientation\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms,isize,index,natom,x,bHaveV ? v : NULL, NULL);
sfree(index);
sfree(grpnames);
}
if ( bScale ) {
/* scale coordinates and box */
if (bRho) {
/* Compute scaling constant */
real vol,dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr,"Volume of input %g (nm^3)\n",vol);
fprintf(stderr,"Mass of input %g (a.m.u.)\n",mass);
fprintf(stderr,"Density of input %g (g/l)\n",dens);
if (vol==0 || mass==0)
gmx_fatal(FARGS,"Cannot scale density with "
"zero mass (%g) or volume (%g)\n",mass,vol);
scale[XX] = scale[YY] = scale[ZZ] = pow(dens/rho,1.0/3.0);
fprintf(stderr,"Scaling all box vectors by %g\n",scale[XX]);
}
scale_conf(atoms.nr,x,box,scale);
}
if (bAlign) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to align:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&asize,&aindex,&agrpname);
} else {
asize = atoms.nr;
snew(aindex,asize);
for (i=0;i<asize;i++)
aindex[i]=i;
}
printf("Aligning %d atoms (out of %d) to %g %g %g, center of rotation %g %g %g\n",asize,natom,
targetvec[XX],targetvec[YY],targetvec[ZZ],
aligncenter[XX],aligncenter[YY],aligncenter[ZZ]);
/*subtract out pivot point*/
for(i=0; i<asize; i++)
rvec_dec(x[aindex[i]],aligncenter);
/*now determine transform and rotate*/
/*will this work?*/
principal_comp(asize,aindex,atoms.atom,x, trans,princd);
unitv(targetvec,targetvec);
printf("Using %g %g %g as principal axis\n", trans[0][2],trans[1][2],trans[2][2]);
tmpvec[XX]=trans[0][2]; tmpvec[YY]=trans[1][2]; tmpvec[ZZ]=trans[2][2];
calc_rotmatrix(tmpvec, targetvec, rotmatrix);
/* rotmatrix finished */
for (i=0;i<asize;++i)
{
mvmul(rotmatrix,x[aindex[i]],tmpvec);
copy_rvec(tmpvec,x[aindex[i]]);
}
/*add pivot point back*/
for(i=0; i<asize; i++)
rvec_inc(x[aindex[i]],aligncenter);
if (!bIndex)
sfree(aindex);
}
if (bTranslate) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to translate:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n",ssize,natom,
translation[XX],translation[YY],translation[ZZ]);
if (sindex) {
for(i=0; i<ssize; i++)
rvec_inc(x[sindex[i]],translation);
}
else {
for(i=0; i<natom; i++)
rvec_inc(x[i],translation);
}
}
if (bRotate) {
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n",rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<DIM; i++)
rotangles[i] *= DEG2RAD;
rotate_conf(natom,x,v,rotangles[XX],rotangles[YY],rotangles[ZZ]);
}
if (bCalcGeom) {
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize,sindex,x,gc,min,max,FALSE);
rvec_sub(max, min, size);
if (bScale || bOrient || bRotate)
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX],size[YY],size[ZZ]);
}
if (bSetSize || bDist || (btype[0][0]=='t' && bSetAng)) {
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
for (i=0; i<DIM; i++)
newbox[i] = norm(box[i]);
clear_mat(box);
/* calculate new boxsize */
switch(btype[0][0]){
case 't':
if (bDist)
for(i=0; i<DIM; i++)
newbox[i] = size[i]+2*dist;
if (!bSetAng) {
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
} else {
matrix_convert(box,newbox,newang);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
d = newbox[0];
else
d = diam+2*dist;
if (btype[0][0] == 'c')
for(i=0; i<DIM; i++)
box[i][i] = d;
else if (btype[0][0] == 'd') {
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*sqrt(2)/2;
} else {
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*sqrt(2)*2/3;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*sqrt(2)/3;
box[ZZ][ZZ] = d*sqrt(6)/3;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
calc_box_center(ecenterDEF,box,center);
/* center molecule on 'center' */
if (bCenter)
center_conf(natom,x,center,gc);
/* print some */
if (bCalcGeom) {
calc_geom(ssize,sindex,x, gc, min, max, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n",gc[XX],gc[YY],gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize) {
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf("new box volume :%7.2f (nm^3)\n",det(box));
}
if (check_box(epbcXYZ,box))
printf("\nWARNING: %s\n",check_box(epbcXYZ,box));
if (bDist && btype[0][0]=='t')
{
if(TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n",dist);
}
else
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
conect = gmx_conect_generate(top);
else
conect = NULL;
if (bIndex) {
fprintf(stderr,"\nSelect a group for output:\n");
get_index(&atoms,opt2fn_null("-n",NFILE,fnm),
1,&isize,&index,&grpname);
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
if (opt2bSet("-bf",NFILE,fnm) || bLegend)
{
gmx_fatal(FARGS,"Sorry, cannot do bfactors with an index group.");
}
if (outftp == efPDB)
{
out=ffopen(outfile,"w");
write_pdbfile_indexed(out,title,&atoms,x,ePBC,box,' ',1,isize,index,conect,TRUE);
ffclose(out);
}
else
{
write_sto_conf_indexed(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box,isize,index);
}
}
else {
if ((outftp == efPDB) || (outftp == efPQR)) {
out=ffopen(outfile,"w");
if (bMead) {
set_pdb_wide_format(TRUE);
fprintf(out,"REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp) {
fprintf(out,"GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out,"REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf",NFILE,fnm)) {
read_bfac(opt2fn("-bf",NFILE,fnm),&n_bfac,&bfac,&bfac_nr);
set_pdb_conf_bfac(atoms.nr,atoms.nres,&atoms,
n_bfac,bfac,bfac_nr,peratom);
}
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
write_pdbfile(out,title,&atoms,x,ePBC,box,' ',-1,conect,TRUE);
if (bLegend)
pdb_legend(out,atoms.nr,atoms.nres,&atoms,x);
if (visbox[0] > 0)
visualize_box(out,bLegend ? atoms.nr+12 : atoms.nr,
bLegend? atoms.nres=12 : atoms.nres,box,visbox);
ffclose(out);
}
else
write_sto_conf(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box);
}
gmx_atomprop_destroy(aps);
do_view(oenv,outfile,NULL);
thanx(stderr);
return 0;
}
int gmx_sdf(int argc,char *argv[])
{
const char *desc[] = {
"g_sdf calculates the spatial distribution function (SDF) of a set of atoms",
"within a coordinate system defined by three atoms. There is single body, ",
"two body and three body SDF implemented (select with option -mode). ",
"In the single body case the local coordinate system is defined by using",
"a triple of atoms from one single molecule, for the two and three body case",
"the configurations are dynamically searched complexes of two or three",
"molecules (or residues) meeting certain distance consitions (see below).[PAR]",
"The program needs a trajectory, a GROMACS run input file and an index ",
"file to work. ",
"You have to setup 4 groups in the index file before using g_sdf: [PAR]",
"The first three groups are used to define the SDF coordinate system.",
"The programm will dynamically generate the atom tripels according to ",
"the selected -mode: ",
"In -mode 1 the triples will be just the 1st, 2nd, 3rd, ... atoms from ",
"groups 1, 2 and 3. Hence the nth entries in groups 1, 2 and 3 must be from the",
"same residue. In -mode 2 the triples will be 1st, 2nd, 3rd, ... atoms from",
"groups 1 and 2 (with the nth entries in groups 1 and 2 having the same res-id).",
"For each pair from groups 1 and 2 group 3 is searched for an atom meeting the",
"distance conditions set with -triangle and -dtri relative to atoms 1 and 2. In",
"-mode 3 for each atom in group 1 group 2 is searched for an atom meeting the",
"distance condition and if a pair is found group 3 is searched for an atom",
"meeting the further conditions. The triple will only be used if all three atoms",
"have different res-id's.[PAR]",
"The local coordinate system is always defined using the following scheme:",
"Atom 1 will be used as the point of origin for the SDF. "
"Atom 1 and 2 will define the principle axis (Z) of the coordinate system.",
"The other two axis will be defined inplane (Y) and normal (X) to the plane through",
"Atoms 1, 2 and 3. "
"The fourth group",
"contains the atoms for which the SDF will be evaluated.[PAR]",
"For -mode 2 and 3 you have to define the distance conditions for the ",
"2 resp. 3 molecule complexes to be searched for using -triangle and -dtri.[PAR]",
"The SDF will be sampled in cartesian coordinates.",
"Use '-grid x y z' to define the size of the SDF grid around the ",
"reference molecule. ",
"The Volume of the SDF grid will be V=x*y*z (nm^3). "
"Use -bin to set the binwidth for grid.[PAR]",
"The output will be a binary 3D-grid file (gom_plt.dat) in the .plt format that can be be",
"read directly by gOpenMol. ",
"The option -r will generate a .gro file with the reference molecule(s) transfered to",
"the SDF coordinate system. Load this file into gOpenMol and display the",
"SDF as a contour plot (see http://www.csc.fi/gopenmol/index.phtml for ",
"further documentation). [PAR]",
"For further information about SDF's have a look at: A. Vishnyakov, JPC A, 105,",
"2001, 1702 and the references cited within."
};
static bool bRef=FALSE;
static int mode=1;
static rvec triangle={0.0,0.0,0.0};
static rvec dtri={0.03,0.03,0.03};
static rvec cutoff={1,1,1};
static real binwidth=0.05;
t_pargs pa[] = {
{ "-mode", FALSE, etINT, {&mode},
"SDF in [1,2,3] particle mode"},
{ "-triangle", FALSE, etRVEC, {&triangle},
"r(1,3), r(2,3), r(1,2)"},
{ "-dtri", FALSE, etRVEC, {&dtri},
"dr(1,3), dr(2,3), dr(1,2)"},
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth for the 3D-grid (nm)" },
{ "-grid", FALSE, etRVEC, {&cutoff},
"Size of the 3D-grid (nm,nm,nm)"}
};
#define NPA asize(pa)
char *fnTPS,*fnNDX,*fnREF;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efNDX, NULL, NULL, ffREAD },
{ efTPS, NULL, NULL, ffOPTRD },
{ efDAT, "-o", "gom_plt", ffWRITE },
{ efSTO, "-r", "refmol", ffOPTWR },
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_BE_NICE,
NFILE,fnm,NPA,pa,asize(desc),desc,0,NULL);
fnTPS = ftp2fn_null(efTPS,NFILE,fnm);
fnNDX = ftp2fn_null(efNDX,NFILE,fnm);
fnREF = opt2fn_null("-r",NFILE,fnm);
bRef = opt2bSet("-r",NFILE,fnm);
if (!fnNDX)
gmx_fatal(FARGS,"No index file specified\n"
" Nothing to do!");
if (!fnTPS)
gmx_fatal(FARGS,"No topology file specified\n"
" Nothing to do!");
if ( bRef && fn2ftp(fnREF) != efGRO)
{
fprintf(stderr,"\nOnly GROMACS format is supported for reference structures.\n");
fprintf(stderr,"Option -r will be ignored!\n");
bRef = FALSE;
}
if (mode < 1 || mode > 3)
gmx_fatal(FARGS,"Wrong -mode selection. Chose 1-, 2- oder 3-praticle mode.\n");
do_sdf(fnNDX,fnTPS,ftp2fn(efTRX,NFILE,fnm),opt2fn("-o",NFILE,fnm),
fnREF,bRef,cutoff,binwidth,mode,triangle,dtri);
thanx(stderr);
return 0;
}
int main(int argc,char *argv[])
{
static char *desc[] = {
"[TT]mkice[tt] generates an ice crystal in the Ih crystal form which is the",
"most stable form. The rectangular unitcell contains eight molecules",
"and all oxygens are tetrahedrally coordinated.[PAR]",
"If an input file is given it is interpreted as a series of oxygen",
"coordinates the distance between which can be scaled by the odist flag.",
"The program then adds hydrogens to the oxygens in random orientation",
"but with proper OH distances and HOH angle. This feature allows to",
"build water clusters based on oxygen coordinates only."
};
static int nx=1,ny=1,nz=1;
static gmx_bool bYaw=FALSE,bLJ=TRUE,bFull=TRUE,bSeries=FALSE;
static gmx_bool bOrdered=TRUE,bDiamond=FALSE,bPBC=TRUE;
static real rcut=0.3,odist=0.274,hdist=0.09572;
t_pargs pa[] = {
{ "-nx", FALSE, etINT, {&nx}, "nx" },
{ "-ny", FALSE, etINT, {&ny}, "ny" },
{ "-nz", FALSE, etINT, {&nz}, "nz" },
{ "-yaw", FALSE, etBOOL, {&bYaw},
"Generate virtual sites and shell positions" },
{ "-lj", FALSE, etBOOL, {&bLJ},
"Use LJ as well as coulomb for virial calculation" },
{ "-rcut", FALSE,etREAL, {&rcut},"Cut-off for virial calculations" },
{ "-full", FALSE,etBOOL, {&bFull},"Full virial output" },
{ "-odist", FALSE, etREAL, {&odist}, "Distance (nm) between oxygens" },
{ "-hdist", FALSE, etREAL, {&hdist}, "Bondlength (nm) for OH bond" },
{ "-diamond",FALSE,etBOOL, {&bDiamond}, "Make a diamond instead" },
{ "-pbc", FALSE, etBOOL, {&bPBC}, "Make a periodic diamond" },
{ "-order", FALSE,etBOOL, {&bOrdered}, "Make a proton-ordered ice lattice" },
{ "-series",FALSE, etBOOL, {&bSeries},
"Do a series of virial calculations with different cut-off (from 0.3 up till the specified one)" }
};
t_filenm fnm[] = {
{ efSTO, "-p", "ice", ffWRITE },
{ efSTO, "-c", NULL, ffOPTRD },
{ efDAT, "-f", NULL, ffOPTRD },
{ efTRN, "-o", "ice", ffOPTWR }
};
#define NFILE asize(fnm)
FILE *fp;
char *fn,quote[256];
int i,j,k,n,nmax,m,natom,natmol;
t_atoms *pdba;
t_atoms atoms;
t_symtab symtab;
rvec box,tmp,*xx;
matrix boxje;
CopyRight(stdout,argv[0]);
parse_common_args(&argc,argv,0,NFILE,fnm,asize(pa),pa,asize(desc),
desc,0,NULL);
if (debug) {
fprintf(debug,"nx = %3d, ny = %3d, nz = %3d\n",nx,ny,nz);
fprintf(debug,"YAW = %3s, LJ = %3s, rcut = %g\n",yesno_names[bYaw],
yesno_names[bLJ],rcut);
}
if (bYaw)
natmol = 5;
else if (bDiamond)
natmol = 1;
else
natmol = 3;
if (opt2bSet("-f",NFILE,fnm)) {
natom = read_rel_coords(opt2fn("-f",NFILE,fnm),&xx,natmol);
nmax = natom;
}
else {
natom = natmol*8;
nmax = natom*nx*ny*nz;
snew(xx,nmax);
}
snew(pdba,1);
init_t_atoms(pdba,nmax,TRUE);
pdba->nr = nmax;
open_symtab(&symtab);
for(n=0; (n<nmax); n++) {
pdba->pdbinfo[n].type = epdbATOM;
pdba->pdbinfo[n].atomnr = 1+n;
pdba->atom[n].resnr = 1+(n/natmol);
pdba->atomname[n] = put_symtab(&symtab,
bDiamond ? diamname[(n % natmol)] : watname[(n % natmol)]);
if (bDiamond)
pdba->resname[n] = put_symtab(&symtab,"DIA");
else
pdba->resname[n] = put_symtab(&symtab,"SOL");
sprintf(pdba->pdbinfo[n].pdbresnr,"%d",n);
pdba->atom[n].chain = ' ';
}
/* Generate the unit cell */
if (bDiamond)
unitcell_d(xx,box,odist);
else if (opt2bSet("-f",NFILE,fnm)) {
random_h_coords(natmol,natom/natmol,xx,box,bYaw,odist,hdist);
}
else
unitcell(xx,box,bYaw,odist,hdist);
if (debug) {
clear_mat(boxje);
boxje[XX][XX] = box[XX];
boxje[YY][YY] = box[YY];
boxje[ZZ][ZZ] = box[ZZ];
}
n=0;
for(i=0; (i<nx); i++) {
tmp[XX] = i*box[XX];
for(j=0; (j<ny); j++) {
tmp[YY] = j*box[YY];
for(k=0; (k<nz); k++) {
tmp[ZZ] = k*box[ZZ];
for(m=0; (m<natom); m++,n++) {
if ((!bOrdered && ((m % natmol) == 0)) || bOrdered)
rvec_add(xx[n % natom],tmp,xx[n]);
else
;
}
}
}
}
clear_mat(boxje);
boxje[XX][XX] = box[XX]*nx;
boxje[YY][YY] = box[YY]*ny;
boxje[ZZ][ZZ] = box[ZZ]*nz;
printf("Crystal: %10.5f %10.5f %10.5f\n",
nx*box[XX],ny*box[YY],nz*box[ZZ]);
if (debug && !bDiamond) {
if (bSeries)
for(i=3; (i<=10*rcut); i++) {
fprintf(debug,"This is with rcut = %g\n",i*0.1);
virial(debug,bFull,nmax/natmol,xx,boxje,
0.1*i,bYaw,bYaw ? qyaw : qspc,bLJ);
}
else
virial(debug,bFull,nmax/natmol,xx,boxje,
rcut,bYaw,bYaw ? qyaw : qspc,bLJ);
}
if (bDiamond)
mk_diamond(pdba,xx,odist,&symtab,bPBC,boxje);
fn = ftp2fn(efSTO,NFILE,fnm);
if (fn2ftp(fn) == efPDB) {
fp = gmx_ffopen(fn,"w");
if (bDiamond)
fprintf(fp,"HEADER This is a *diamond*\n");
else
fprintf(fp,"HEADER A beautiful Ice Ih crystal\n");
fprintf(fp,"REMARK Generated by mkice with the following options:\n"
"REMARK nx = %d, ny = %d, nz = %d, odist = %g, hdist = %g\n",
nx,ny,nz,odist,hdist);
bromacs(quote,255);
write_pdbfile(fp,quote,pdba,xx,boxje,' ',-1);
gmx_ffclose(fp);
}
else {
bromacs(quote,255);
write_sto_conf(fn,quote,pdba,xx,NULL,boxje);
}
if (ftp2bSet(efTRN,NFILE,fnm))
write_trn(ftp2fn(efTRN,NFILE,fnm),0,0,0,boxje,nmax,xx,NULL,NULL);
return 0;
}
int gmx_trjorder(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] orders molecules according to the smallest distance",
"to atoms in a reference group",
"or on z-coordinate (with option [TT]-z[tt]).",
"With distance ordering, it will ask for a group of reference",
"atoms and a group of molecules. For each frame of the trajectory",
"the selected molecules will be reordered according to the shortest",
"distance between atom number [TT]-da[tt] in the molecule and all the",
"atoms in the reference group. The center of mass of the molecules can",
"be used instead of a reference atom by setting [TT]-da[tt] to 0.",
"All atoms in the trajectory are written",
"to the output trajectory.[PAR]",
"[THISMODULE] can be useful for e.g. analyzing the n waters closest to a",
"protein.",
"In that case the reference group would be the protein and the group",
"of molecules would consist of all the water atoms. When an index group",
"of the first n waters is made, the ordered trajectory can be used",
"with any GROMACS program to analyze the n closest waters.",
"[PAR]",
"If the output file is a [REF].pdb[ref] file, the distance to the reference target",
"will be stored in the B-factor field in order to color with e.g. Rasmol.",
"[PAR]",
"With option [TT]-nshell[tt] the number of molecules within a shell",
"of radius [TT]-r[tt] around the reference group are printed."
};
static int na = 3, ref_a = 1;
static real rcut = 0;
static gmx_bool bCOM = FALSE, bZ = FALSE;
t_pargs pa[] = {
{ "-na", FALSE, etINT, {&na},
"Number of atoms in a molecule" },
{ "-da", FALSE, etINT, {&ref_a},
"Atom used for the distance calculation, 0 is COM" },
{ "-com", FALSE, etBOOL, {&bCOM},
"Use the distance to the center of mass of the reference group" },
{ "-r", FALSE, etREAL, {&rcut},
"Cutoff used for the distance calculation when computing the number of molecules in a shell around e.g. a protein" },
{ "-z", FALSE, etBOOL, {&bZ},
"Order molecules on z-coordinate" }
};
FILE *fp;
t_trxstatus *out;
t_trxstatus *status;
gmx_bool bNShell, bPDBout;
t_topology top;
int ePBC;
rvec *x, *xsol, xcom, dx;
matrix box;
t_pbc pbc;
gmx_rmpbc_t gpbc;
real t, totmass, mass, rcut2 = 0, n2;
int natoms, nwat, ncut;
char **grpname;
int i, j, d, *isize, isize_ref = 0, isize_sol;
atom_id sa, sr, *swi, **index, *ind_ref = NULL, *ind_sol;
output_env_t oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-o", "ordered", ffOPTWR },
{ efXVG, "-nshell", "nshell", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv, PCA_CAN_TIME,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), &top, &ePBC, &x, NULL, box, TRUE);
sfree(x);
/* get index groups */
printf("Select %sa group of molecules to be ordered:\n",
bZ ? "" : "a group of reference atoms and ");
snew(grpname, 2);
snew(index, 2);
snew(isize, 2);
get_index(&top.atoms, ftp2fn_null(efNDX, NFILE, fnm), bZ ? 1 : 2,
isize, index, grpname);
if (!bZ)
{
isize_ref = isize[0];
isize_sol = isize[1];
ind_ref = index[0];
ind_sol = index[1];
}
else
{
isize_sol = isize[0];
ind_sol = index[0];
}
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (natoms > top.atoms.nr)
{
gmx_fatal(FARGS, "Number of atoms in the run input file is larger than in the trjactory");
}
for (i = 0; (i < 2); i++)
{
for (j = 0; (j < isize[i]); j++)
{
if (index[i][j] > natoms)
{
gmx_fatal(FARGS, "An atom number in group %s is larger than the number of atoms in the trajectory");
}
}
}
if ((isize_sol % na) != 0)
{
gmx_fatal(FARGS, "Number of atoms in the molecule group (%d) is not a multiple of na (%d)",
isize[1], na);
}
nwat = isize_sol/na;
if (ref_a > na)
{
gmx_fatal(FARGS, "The reference atom can not be larger than the number of atoms in a molecule");
}
ref_a--;
snew(xsol, nwat);
snew(order, nwat);
snew(swi, natoms);
for (i = 0; (i < natoms); i++)
{
swi[i] = i;
}
out = NULL;
fp = NULL;
bNShell = ((opt2bSet("-nshell", NFILE, fnm)) ||
(opt2parg_bSet("-r", asize(pa), pa)));
bPDBout = FALSE;
if (bNShell)
{
rcut2 = rcut*rcut;
fp = xvgropen(opt2fn("-nshell", NFILE, fnm), "Number of molecules",
"Time (ps)", "N", oenv);
printf("Will compute the number of molecules within a radius of %g\n",
rcut);
}
if (!bNShell || opt2bSet("-o", NFILE, fnm))
{
bPDBout = (fn2ftp(opt2fn("-o", NFILE, fnm)) == efPDB);
if (bPDBout && !top.atoms.pdbinfo)
{
fprintf(stderr, "Creating pdbfino records\n");
snew(top.atoms.pdbinfo, top.atoms.nr);
}
out = open_trx(opt2fn("-o", NFILE, fnm), "w");
}
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
gmx_rmpbc(gpbc, natoms, box, x);
set_pbc(&pbc, ePBC, box);
if (ref_a == -1)
{
/* Calculate the COM of all solvent molecules */
for (i = 0; i < nwat; i++)
{
totmass = 0;
clear_rvec(xsol[i]);
for (j = 0; j < na; j++)
{
sa = ind_sol[i*na+j];
mass = top.atoms.atom[sa].m;
totmass += mass;
for (d = 0; d < DIM; d++)
{
xsol[i][d] += mass*x[sa][d];
}
}
svmul(1.0/totmass, xsol[i], xsol[i]);
}
}
else
{
/* Copy the reference atom of all solvent molecules */
for (i = 0; i < nwat; i++)
{
copy_rvec(x[ind_sol[i*na+ref_a]], xsol[i]);
}
}
if (bZ)
{
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
order[i].i = sa;
order[i].d2 = xsol[i][ZZ];
}
}
else if (bCOM)
{
totmass = 0;
clear_rvec(xcom);
for (i = 0; i < isize_ref; i++)
{
mass = top.atoms.atom[ind_ref[i]].m;
totmass += mass;
for (j = 0; j < DIM; j++)
{
xcom[j] += mass*x[ind_ref[i]][j];
}
}
svmul(1/totmass, xcom, xcom);
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
pbc_dx(&pbc, xcom, xsol[i], dx);
order[i].i = sa;
order[i].d2 = norm2(dx);
}
}
else
{
/* Set distance to first atom */
for (i = 0; (i < nwat); i++)
{
sa = ind_sol[na*i];
pbc_dx(&pbc, x[ind_ref[0]], xsol[i], dx);
order[i].i = sa;
order[i].d2 = norm2(dx);
}
for (j = 1; (j < isize_ref); j++)
{
sr = ind_ref[j];
for (i = 0; (i < nwat); i++)
{
pbc_dx(&pbc, x[sr], xsol[i], dx);
n2 = norm2(dx);
if (n2 < order[i].d2)
{
order[i].d2 = n2;
}
}
}
}
if (bNShell)
{
ncut = 0;
for (i = 0; (i < nwat); i++)
{
if (order[i].d2 <= rcut2)
{
ncut++;
}
}
fprintf(fp, "%10.3f %8d\n", t, ncut);
}
if (out)
{
qsort(order, nwat, sizeof(*order), ocomp);
for (i = 0; (i < nwat); i++)
{
for (j = 0; (j < na); j++)
{
swi[ind_sol[na*i]+j] = order[i].i+j;
}
}
/* Store the distance as the B-factor */
if (bPDBout)
{
for (i = 0; (i < nwat); i++)
{
for (j = 0; (j < na); j++)
{
top.atoms.pdbinfo[order[i].i+j].bfac = std::sqrt(order[i].d2);
}
}
}
write_trx(out, natoms, swi, &top.atoms, 0, t, box, x, NULL, NULL);
}
}
while (read_next_x(oenv, status, &t, x, box));
close_trj(status);
if (out)
{
close_trx(out);
}
if (fp)
{
xvgrclose(fp);
}
gmx_rmpbc_done(gpbc);
return 0;
}
void init_multisystem(t_commrec *cr,int nsim,
int nfile,t_filenm fnm[],bool bParFn)
{
gmx_multisim_t *ms;
int nnodes,nnodpersim,sim,i,ftp;
char buf[256];
#ifdef GMX_MPI
MPI_Group mpi_group_world;
#endif
int *rank;
nnodes = cr->nnodes;
if (nnodes % nsim != 0)
gmx_fatal(FARGS,"The number of nodes (%d) is not a multiple of the number of simulations (%d)",nnodes,nsim);
nnodpersim = nnodes/nsim;
sim = cr->nodeid/nnodpersim;
if (debug)
fprintf(debug,"We have %d simulations, %d nodes per simulation, local simulation is %d\n",nsim,nnodpersim,sim);
snew(ms,1);
cr->ms = ms;
ms->nsim = nsim;
ms->sim = sim;
#ifdef GMX_MPI
/* Create a communicator for the master nodes */
snew(rank,ms->nsim);
for(i=0; i<ms->nsim; i++)
rank[i] = i*nnodpersim;
MPI_Comm_group(MPI_COMM_WORLD,&mpi_group_world);
MPI_Group_incl(mpi_group_world,nsim,rank,&ms->mpi_group_masters);
sfree(rank);
MPI_Comm_create(MPI_COMM_WORLD,ms->mpi_group_masters,
&ms->mpi_comm_masters);
#endif
/* Reduce the intra-simulation communication */
cr->sim_nodeid = cr->nodeid % nnodpersim;
cr->nnodes = nnodpersim;
#ifdef GMX_MPI
MPI_Comm_split(MPI_COMM_WORLD,sim,cr->sim_nodeid,&cr->mpi_comm_mysim);
cr->mpi_comm_mygroup = cr->mpi_comm_mysim;
cr->nodeid = cr->sim_nodeid;
#endif
if (debug) {
fprintf(debug,"This is simulation %d",cr->ms->sim);
if (PAR(cr))
fprintf(debug,", local number of nodes %d, local nodeid %d",
cr->nnodes,cr->sim_nodeid);
fprintf(debug,"\n\n");
}
if (bParFn) {
/* Patch output and tpx file names (except log which has been done already)
*/
for(i=0; (i<nfile); i++) {
/* Because of possible multiple extensions per type we must look
* at the actual file name
*/
if (is_output(&fnm[i]) ||
fnm[i].ftp == efTPX || fnm[i].ftp == efCPT ||
strcmp(fnm[i].opt,"-rerun") == 0) {
ftp = fn2ftp(fnm[i].fns[0]);
par_fn(fnm[i].fns[0],ftp,cr,FALSE,buf,255);
sfree(fnm[i].fns[0]);
fnm[i].fns[0] = strdup(buf);
}
}
}
}
