gmx_bool search_subdirs(const char *parent, char *libdir)
{
char *ptr;
gmx_bool found;
/* Search a few common subdirectory names for the gromacs library dir */
sprintf(libdir,"%s%cshare%ctop%cgurgle.dat",parent,
DIR_SEPARATOR,DIR_SEPARATOR,DIR_SEPARATOR);
found=gmx_fexist(libdir);
if(!found) {
sprintf(libdir,"%s%cshare%cgromacs%ctop%cgurgle.dat",parent,
DIR_SEPARATOR,DIR_SEPARATOR,
DIR_SEPARATOR,DIR_SEPARATOR);
found=gmx_fexist(libdir);
}
if(!found) {
sprintf(libdir,"%s%cshare%cgromacs-%s%ctop%cgurgle.dat",parent,
DIR_SEPARATOR,DIR_SEPARATOR,VERSION,
DIR_SEPARATOR,DIR_SEPARATOR);
found=gmx_fexist(libdir);
}
if(!found) {
sprintf(libdir,"%s%cshare%cgromacs%cgromacs-%s%ctop%cgurgle.dat",parent,
DIR_SEPARATOR,DIR_SEPARATOR,DIR_SEPARATOR,
VERSION,DIR_SEPARATOR,DIR_SEPARATOR);
found=gmx_fexist(libdir);
}
/* Remove the gurgle.dat part from libdir if we found something */
if(found) {
ptr=strrchr(libdir,DIR_SEPARATOR); /* slash or backslash always present, no check necessary */
*ptr='\0';
}
return found;
}
char *low_gmxlibfn(const char *file, gmx_bool bAddCWD, gmx_bool bFatal)
{
char *ret;
char *lib,*dir;
char buf[1024];
char libpath[GMX_PATH_MAX];
gmx_bool env_is_set=FALSE;
char *s,tmppath[GMX_PATH_MAX];
/* GMXLIB can be a path now */
lib=getenv("GMXLIB");
if (lib != NULL)
{
env_is_set=TRUE;
strncpy(libpath,lib,GMX_PATH_MAX);
}
else if (!get_libdir(libpath))
{
strncpy(libpath,GMXLIBDIR,GMX_PATH_MAX);
}
ret = NULL;
if (bAddCWD && gmx_fexist(file))
{
ret = strdup(file);
}
else
{
strncpy(tmppath,libpath,GMX_PATH_MAX);
s=tmppath;
while(ret == NULL && (dir=gmx_strsep(&s, PATH_SEPARATOR)) != NULL )
{
sprintf(buf,"%s%c%s",dir,DIR_SEPARATOR,file);
if (gmx_fexist(buf))
{
ret = strdup(buf);
}
}
if (ret == NULL && bFatal)
{
if (env_is_set)
{
gmx_fatal(FARGS,
"Library file %s not found %sin your GMXLIB path.",
bAddCWD ? "in current dir nor " : "",file);
}
else
{
gmx_fatal(FARGS,
"Library file %s not found %sin default directories.\n"
"(You can set the directories to search with the GMXLIB path variable)",
bAddCWD ? "in current dir nor " : "",file);
}
}
}
return ret;
}
FILE *ffopen(const char *file,const char *mode)
{
#ifdef SKIP_FFOPS
return fopen(file,mode);
#else
FILE *ff=NULL;
char buf[256],*bf,*bufsize=0,*ptr;
gmx_bool bRead;
int bs;
if (mode[0]=='w') {
make_backup(file);
}
where();
bRead= (mode[0]=='r'&&mode[1]!='+');
strcpy(buf,file);
if (gmx_fexist(buf) || !bRead) {
if ((ff=fopen(buf,mode))==NULL)
gmx_file(buf);
where();
/* Check whether we should be using buffering (default) or not
* (for debugging)
*/
if (bUnbuffered || ((bufsize=getenv("LOG_BUFS")) != NULL)) {
/* Check whether to use completely unbuffered */
if (bUnbuffered)
bs = 0;
else
bs=strtol(bufsize, NULL, 10);
if (bs <= 0)
setbuf(ff,NULL);
else {
snew(ptr,bs+8);
if (setvbuf(ff,ptr,_IOFBF,bs) != 0)
gmx_file("Buffering File");
}
}
where();
}
else {
sprintf(buf,"%s.Z",file);
if (gmx_fexist(buf)) {
ff=uncompress(buf,mode);
}
else {
sprintf(buf,"%s.gz",file);
if (gmx_fexist(buf)) {
ff=gunzip(buf,mode);
}
else
gmx_file(file);
}
}
return ff;
#endif
}
int
main(int argc, char *argv[])
{
t_x11 *x11;
t_sc *sc;
char *fn;
x11 = GetX11(&argc, argv);
if (argc > 1)
{
fn = argv[1];
}
else
{
fn = "/usr/lib/X11/rgb.txt";
}
if (!gmx_fexist(fn))
{
fprintf(stderr, "Usage: %s rgb.txt\n", argv[0]);
fprintf(stderr, "rgb.txt is usually somewhere in your X windows directories.\n");
exit(1);
}
sc = init_sc(x11, x11->root, fn);
XMapWindow(x11->disp, sc->wd.self);
XMapSubwindows(x11->disp, sc->wd.self);
x11->MainLoop(x11);
x11->CleanUp(x11);
return 0;
}
static void set_filenm(t_filenm *fnm, const char *name, gmx_bool bCanNotOverride,
gmx_bool bReadNode)
{
/* Set the default filename, extension and option for those fields that
* are not already set. An extension is added if not present, if fn = NULL
* or empty, the default filename is given.
*/
char buf[256];
int i, len, extlen;
if ((fnm->flag & ffREAD) && !bReadNode)
{
return;
}
if ((fnm->ftp < 0) || (fnm->ftp >= efNR))
{
gmx_fatal(FARGS, "file type out of range (%d)", fnm->ftp);
}
if (name)
{
strcpy(buf, name);
}
if ((fnm->flag & ffREAD) && name && gmx_fexist(name))
{
/* check if filename ends in .gz or .Z, if so remove that: */
len = strlen(name);
for (i = 0; i < NZEXT; i++)
{
extlen = strlen(z_ext[i]);
if (len > extlen)
{
if (gmx_strcasecmp(name+len-extlen, z_ext[i]) == 0)
{
buf[len-extlen] = '\0';
break;
}
}
}
}
if (deffile[fnm->ftp].ntps)
{
set_grpfnm(fnm, name ? buf : NULL, bCanNotOverride);
}
else
{
if ((name == NULL) || !(bCanNotOverride || (default_file_name == NULL)))
{
const char *defnm = ftp2defnm(fnm->ftp);
strcpy(buf, defnm);
}
set_extension(buf, fnm->ftp);
add_filenm(fnm, buf);
}
}
static char *backup_fn(const char *file, int count_max)
{
/* Use a reasonably low value for countmax; we might
* generate 4-5 files in each round, and we dont
* want to hit directory limits of 1024 or 2048 files.
*/
#define COUNTMAX 99
int i, count = 1;
char *directory, *fn;
char *buf;
if (count_max == -1)
{
count_max = COUNTMAX;
}
smalloc(buf, GMX_PATH_MAX);
for (i = strlen(file)-1; ((i > 0) && (file[i] != DIR_SEPARATOR)); i--)
{
;
}
/* Must check whether i > 0, i.e. whether there is a directory
* in the file name. In that case we overwrite the / sign with
* a '\0' to end the directory string .
*/
if (i > 0)
{
directory = gmx_strdup(file);
directory[i] = '\0';
fn = gmx_strdup(file+i+1);
}
else
{
directory = gmx_strdup(".");
fn = gmx_strdup(file);
}
do
{
sprintf(buf, "%s/#%s.%d#", directory, fn, count);
count++;
}
while ((count <= count_max) && gmx_fexist(buf));
/* Arbitrarily bail out */
if (count > count_max)
{
gmx_fatal(FARGS, "Won't make more than %d backups of %s for you.\n"
"The env.var. GMX_MAXBACKUP controls this maximum, -1 disables backups.",
count_max, fn);
}
sfree(directory);
sfree(fn);
return buf;
}
char *low_gmxlibfn(const char *file, gmx_bool bAddCWD, gmx_bool bFatal)
{
bool bEnvIsSet = false;
try
{
if (bAddCWD && gmx_fexist(file))
{
return gmx_strdup(file);
}
else
{
std::string libpath;
// GMXLIB can be a path.
const char *lib = getenv("GMXLIB");
if (lib != NULL)
{
bEnvIsSet = true;
libpath = lib;
}
else
{
libpath = gmx::getProgramContext().defaultLibraryDataPath();
}
std::vector<std::string> pathEntries;
gmx::Path::splitPathEnvironment(libpath, &pathEntries);
std::vector<std::string>::const_iterator i;
for (i = pathEntries.begin(); i != pathEntries.end(); ++i)
{
std::string testPath = gmx::Path::join(*i, file);
if (gmx::Path::exists(testPath))
{
return gmx_strdup(testPath.c_str());
}
}
}
}
GMX_CATCH_ALL_AND_EXIT_WITH_FATAL_ERROR;
if (bFatal)
{
if (bEnvIsSet)
{
gmx_fatal(FARGS,
"Library file %s not found %sin your GMXLIB path.",
file, bAddCWD ? "in current dir nor " : "");
}
else
{
gmx_fatal(FARGS,
"Library file %s not found %sin default directories.\n"
"(You can set the directories to search with the GMXLIB path variable)",
file, bAddCWD ? "in current dir nor " : "");
}
}
return NULL;
}
gmx_bool gmx_fexist_master(const char *fname, t_commrec *cr)
{
gmx_bool bExist;
if (SIMMASTER(cr))
{
bExist = gmx_fexist(fname);
}
if (PAR(cr))
{
gmx_bcast(sizeof(bExist),&bExist,cr);
}
return bExist;
}
static char *backup_fn(const char *file)
{
int i, count = 1;
char *directory, *fn;
char *buf;
smalloc(buf, GMX_PATH_MAX);
for (i = strlen(file)-1; ((i > 0) && (file[i] != DIR_SEPARATOR)); i--)
{
;
}
/* Must check whether i > 0, i.e. whether there is a directory
* in the file name. In that case we overwrite the / sign with
* a '\0' to end the directory string .
*/
if (i > 0)
{
directory = gmx_strdup(file);
directory[i] = '\0';
fn = gmx_strdup(file+i+1);
}
else
{
directory = gmx_strdup(".");
fn = gmx_strdup(file);
}
do
{
sprintf(buf, "%s/#%s.%d#", directory, fn, count);
count++;
}
while ((count <= s_maxBackupCount) && gmx_fexist(buf));
/* Arbitrarily bail out */
if (count > s_maxBackupCount)
{
/* TODO: The error message is only accurate for code that starts with
* Gromacs command-line interface. */
gmx_fatal(FARGS, "Won't make more than %d backups of %s for you.\n"
"The env.var. GMX_MAXBACKUP controls this maximum, -1 disables backups.",
s_maxBackupCount, fn);
}
sfree(directory);
sfree(fn);
return buf;
}
/*! \brief Search for \p fnm_cp in fnm and return true iff found
*
* \todo This could be implemented sanely with a for loop. */
static gmx_bool exist_output_file(const char *fnm_cp, int nfile, const t_filenm fnm[])
{
int i;
/* Check if the output file name stored in the checkpoint file
* is one of the output file names of mdrun.
*/
i = 0;
while (i < nfile &&
!(is_output(&fnm[i]) && strcmp(fnm_cp, fnm[i].fns[0]) == 0))
{
i++;
}
return (i < nfile && gmx_fexist(fnm_cp));
}
gmx_bool make_backup(const char * name)
{
char * env;
int count_max;
char * backup;
#ifdef GMX_FAHCORE
return FALSE; /* skip making backups */
#else
if (gmx_fexist(name))
{
env = getenv("GMX_MAXBACKUP");
if (env != NULL)
{
count_max = strtol(env, NULL, 10);
if (count_max == -1)
{
/* Do not make backups and possibly overwrite old files */
return TRUE;
}
}
else
{
/* Use the default maximum */
count_max = -1;
}
backup = backup_fn(name, count_max);
if (rename(name, backup) == 0)
{
fprintf(stderr, "\nBack Off! I just backed up %s to %s\n",
name, backup);
}
else
{
fprintf(stderr, "Sorry couldn't backup %s to %s\n", name, backup);
return FALSE;
}
sfree(backup);
}
return TRUE;
#endif
}
void make_backup(const char *name)
{
if (s_maxBackupCount <= 0)
{
return;
}
if (gmx_fexist(name))
{
char *backup = backup_fn(name);
if (rename(name, backup) == 0)
{
fprintf(stderr, "\nBack Off! I just backed up %s to %s\n",
name, backup);
}
else
{
fprintf(stderr, "\nSorry couldn't backup %s to %s\n", name, backup);
}
sfree(backup);
}
}
int main (int argc, char *argv[])
{
static const char *desc[] = {
"The gromacs preprocessor",
"reads a molecular topology file, checks the validity of the",
"file, expands the topology from a molecular description to an atomic",
"description. The topology file contains information about",
"molecule types and the number of molecules, the preprocessor",
"copies each molecule as needed. ",
"There is no limitation on the number of molecule types. ",
"Bonds and bond-angles can be converted into constraints, separately",
"for hydrogens and heavy atoms.",
"Then a coordinate file is read and velocities can be generated",
"from a Maxwellian distribution if requested.",
"grompp also reads parameters for the mdrun ",
"(eg. number of MD steps, time step, cut-off), and others such as",
"NEMD parameters, which are corrected so that the net acceleration",
"is zero.",
"Eventually a binary file is produced that can serve as the sole input",
"file for the MD program.[PAR]",
"grompp uses the atom names from the topology file. The atom names",
"in the coordinate file (option [TT]-c[tt]) are only read to generate",
"warnings when they do not match the atom names in the topology.",
"Note that the atom names are irrelevant for the simulation as",
"only the atom types are used for generating interaction parameters.[PAR]",
"grompp calls a preprocessor to resolve includes, macros ",
"etcetera. By default we use the cpp in your path. To specify a "
"different macro-preprocessor (e.g. m4) or alternative location",
"you can put a line in your parameter file specifying the path",
"to that program. Specifying [TT]-pp[tt] will get the pre-processed",
"topology file written out.[PAR]",
"If your system does not have a c-preprocessor, you can still",
"use grompp, but you do not have access to the features ",
"from the cpp. Command line options to the c-preprocessor can be given",
"in the [TT].mdp[tt] file. See your local manual (man cpp).[PAR]",
"When using position restraints a file with restraint coordinates",
"can be supplied with [TT]-r[tt], otherwise restraining will be done",
"with respect to the conformation from the [TT]-c[tt] option.",
"For free energy calculation the the coordinates for the B topology",
"can be supplied with [TT]-rb[tt], otherwise they will be equal to",
"those of the A topology.[PAR]",
"Starting coordinates can be read from trajectory with [TT]-t[tt].",
"The last frame with coordinates and velocities will be read,",
"unless the [TT]-time[tt] option is used.",
"Note that these velocities will not be used when [TT]gen_vel = yes[tt]",
"in your [TT].mdp[tt] file. An energy file can be supplied with",
"[TT]-e[tt] to have exact restarts when using pressure and/or",
"Nose-Hoover temperature coupling. For an exact restart do not forget",
"to turn off velocity generation and turn on unconstrained starting",
"when constraints are present in the system.",
"If you want to continue a crashed run, it is",
"easier to use [TT]tpbconv[tt].[PAR]",
"Using the [TT]-morse[tt] option grompp can convert the harmonic bonds",
"in your topology to morse potentials. This makes it possible to break",
"bonds. For this option to work you need an extra file in your $GMXLIB",
"with dissociation energy. Use the -debug option to get more information",
"on the workings of this option (look for MORSE in the grompp.log file",
"using less or something like that).[PAR]",
"By default all bonded interactions which have constant energy due to",
"virtual site constructions will be removed. If this constant energy is",
"not zero, this will result in a shift in the total energy. All bonded",
"interactions can be kept by turning off [TT]-rmvsbds[tt]. Additionally,",
"all constraints for distances which will be constant anyway because",
"of virtual site constructions will be removed. If any constraints remain",
"which involve virtual sites, a fatal error will result.[PAR]"
"To verify your run input file, please make notice of all warnings",
"on the screen, and correct where necessary. Do also look at the contents",
"of the [TT]mdout.mdp[tt] file, this contains comment lines, as well as",
"the input that [TT]grompp[tt] has read. If in doubt you can start grompp",
"with the [TT]-debug[tt] option which will give you more information",
"in a file called grompp.log (along with real debug info). Finally, you",
"can see the contents of the run input file with the [TT]gmxdump[tt]",
"program."
};
t_gromppopts *opts;
gmx_mtop_t *sys;
int nmi;
t_molinfo *mi;
gpp_atomtype_t atype;
t_inputrec *ir;
int natoms,nvsite,comb,mt;
t_params *plist;
t_state state;
matrix box;
real max_spacing,fudgeQQ;
double reppow;
char fn[STRLEN],fnB[STRLEN],*mdparin;
int nerror,ntype;
bool bNeedVel,bGenVel;
bool have_radius,have_vol,have_surftens,have_gb_radius,have_S_hct;
bool have_atomnumber;
int n12,n13,n14;
t_params *gb_plist = NULL;
gmx_genborn_t *born = NULL;
t_filenm fnm[] = {
{ efMDP, NULL, NULL, ffOPTRD },
{ efMDP, "-po", "mdout", ffWRITE },
{ efSTX, "-c", NULL, ffREAD },
{ efSTX, "-r", NULL, ffOPTRD },
{ efSTX, "-rb", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTOP, NULL, NULL, ffREAD },
{ efTOP, "-pp", "processed", ffOPTWR },
{ efTPX, "-o", NULL, ffWRITE },
{ efTRN, "-t", NULL, ffOPTRD },
{ efEDR, "-e", NULL, ffOPTRD }
};
#define NFILE asize(fnm)
/* Command line options */
static bool bVerbose=TRUE,bRenum=TRUE;
static bool bRmVSBds=TRUE,bZero=FALSE;
static int i,maxwarn=0;
static real fr_time=-1;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"Be loud and noisy" },
{ "-time", FALSE, etREAL, {&fr_time},
"Take frame at or first after this time." },
{ "-rmvsbds",FALSE, etBOOL, {&bRmVSBds},
"Remove constant bonded interactions with virtual sites" },
{ "-maxwarn", FALSE, etINT, {&maxwarn},
"Number of allowed warnings during input processing" },
{ "-zero", FALSE, etBOOL, {&bZero},
"Set parameters for bonded interactions without defaults to zero instead of generating an error" },
{ "-renum", FALSE, etBOOL, {&bRenum},
"Renumber atomtypes and minimize number of atomtypes" }
};
CopyRight(stdout,argv[0]);
/* Initiate some variables */
nerror=0;
snew(ir,1);
snew(opts,1);
init_ir(ir,opts);
/* Parse the command line */
parse_common_args(&argc,argv,0,NFILE,fnm,asize(pa),pa,
asize(desc),desc,0,NULL);
init_warning(maxwarn);
/* PARAMETER file processing */
mdparin = opt2fn("-f",NFILE,fnm);
set_warning_line(mdparin,-1);
get_ir(mdparin,opt2fn("-po",NFILE,fnm),ir,opts,&nerror);
if (bVerbose)
fprintf(stderr,"checking input for internal consistency...\n");
check_ir(mdparin,ir,opts,&nerror);
if (ir->ld_seed == -1) {
ir->ld_seed = make_seed();
fprintf(stderr,"Setting the LD random seed to %d\n",ir->ld_seed);
}
bNeedVel = EI_STATE_VELOCITY(ir->eI);
bGenVel = (bNeedVel && opts->bGenVel);
snew(plist,F_NRE);
init_plist(plist);
snew(sys,1);
atype = init_atomtype();
if (debug)
pr_symtab(debug,0,"Just opened",&sys->symtab);
strcpy(fn,ftp2fn(efTOP,NFILE,fnm));
if (!gmx_fexist(fn))
gmx_fatal(FARGS,"%s does not exist",fn);
new_status(fn,opt2fn_null("-pp",NFILE,fnm),opt2fn("-c",NFILE,fnm),
opts,ir,bZero,bGenVel,bVerbose,&state,
atype,sys,&nmi,&mi,plist,&comb,&reppow,&fudgeQQ,
opts->bMorse,
&nerror);
if (debug)
pr_symtab(debug,0,"After new_status",&sys->symtab);
if (count_constraints(sys,mi) && (ir->eConstrAlg == econtSHAKE)) {
if (ir->eI == eiCG || ir->eI == eiLBFGS) {
fprintf(stderr,
"ERROR: Can not do %s with %s, use %s\n",
EI(ir->eI),econstr_names[econtSHAKE],econstr_names[econtLINCS]);
nerror++;
}
if (ir->bPeriodicMols) {
fprintf(stderr,
"ERROR: can not do periodic molecules with %s, use %s\n",
econstr_names[econtSHAKE],econstr_names[econtLINCS]);
nerror++;
}
}
/* If we are doing GBSA, check that we got the parameters we need
* This checking is to see if there are GBSA paratmeters for all
* atoms in the force field. To go around this for testing purposes
* comment out the nerror++ counter temporarliy
*/
have_radius=have_vol=have_surftens=have_gb_radius=have_S_hct=TRUE;
for(i=0;i<get_atomtype_ntypes(atype);i++) {
have_radius=have_radius && (get_atomtype_radius(i,atype) > 0);
have_vol=have_vol && (get_atomtype_vol(i,atype) > 0);
have_surftens=have_surftens && (get_atomtype_surftens(i,atype) > 0);
have_gb_radius=have_gb_radius && (get_atomtype_gb_radius(i,atype) > 0);
have_S_hct=have_S_hct && (get_atomtype_S_hct(i,atype) > 0);
}
if(!have_radius && ir->implicit_solvent==eisGBSA) {
fprintf(stderr,"Can't do GB electrostatics; the forcefield is missing values for\n"
"atomtype radii, or they might be zero\n.");
/* nerror++; */
}
/*
if(!have_surftens && ir->implicit_solvent!=eisNO) {
fprintf(stderr,"Can't do implicit solvent; the forcefield is missing values\n"
" for atomtype surface tension\n.");
nerror++;
}
*/
/* If we are doing QM/MM, check that we got the atom numbers */
have_atomnumber = TRUE;
for (i=0; i<get_atomtype_ntypes(atype); i++) {
have_atomnumber = have_atomnumber && (get_atomtype_atomnumber(i,atype) >= 0);
}
if (!have_atomnumber && ir->bQMMM)
{
fprintf(stderr,"\n"
"It appears as if you are trying to run a QM/MM calculation, but the force\n"
"field you are using does not contain atom numbers fields. This is an\n"
"optional field (introduced in Gromacs 3.3) for general runs, but mandatory\n"
"for QM/MM. The good news is that it is easy to add - put the atom number as\n"
"an integer just before the mass column in ffXXXnb.itp.\n"
"NB: United atoms have the same atom numbers as normal ones.\n\n");
nerror++;
}
if (nerror) {
print_warn_num(FALSE);
gmx_fatal(FARGS,"There were %d error(s) processing your input",nerror);
}
if (opt2bSet("-r",NFILE,fnm))
sprintf(fn,"%s",opt2fn("-r",NFILE,fnm));
else
sprintf(fn,"%s",opt2fn("-c",NFILE,fnm));
if (opt2bSet("-rb",NFILE,fnm))
sprintf(fnB,"%s",opt2fn("-rb",NFILE,fnm));
else
strcpy(fnB,fn);
if (nint_ftype(sys,mi,F_POSRES) > 0) {
if (bVerbose) {
fprintf(stderr,"Reading position restraint coords from %s",fn);
if (strcmp(fn,fnB) == 0) {
fprintf(stderr,"\n");
} else {
fprintf(stderr," and %s\n",fnB);
if (ir->efep != efepNO && ir->n_flambda > 0) {
fprintf(stderr,"ERROR: can not change the position restraint reference coordinates with lambda togther with foreign lambda calculation.\n");
nerror++;
}
}
}
gen_posres(sys,mi,fn,fnB,
ir->refcoord_scaling,ir->ePBC,
ir->posres_com,ir->posres_comB);
}
nvsite = 0;
/* set parameters for virtual site construction (not for vsiten) */
for(mt=0; mt<sys->nmoltype; mt++) {
nvsite +=
set_vsites(bVerbose, &sys->moltype[mt].atoms, atype, mi[mt].plist);
}
/* now throw away all obsolete bonds, angles and dihedrals: */
/* note: constraints are ALWAYS removed */
if (nvsite) {
for(mt=0; mt<sys->nmoltype; mt++) {
clean_vsite_bondeds(mi[mt].plist,sys->moltype[mt].atoms.nr,bRmVSBds);
}
}
/* If we are using CMAP, setup the pre-interpolation grid */
if(plist->ncmap>0)
{
init_cmap_grid(&sys->cmap_grid, plist->nc, plist->grid_spacing);
setup_cmap(plist->grid_spacing, plist->nc, plist->cmap,&sys->cmap_grid);
}
set_wall_atomtype(atype,opts,ir);
if (bRenum) {
renum_atype(plist, sys, ir->wall_atomtype, atype, bVerbose);
ntype = get_atomtype_ntypes(atype);
}
/* PELA: Copy the atomtype data to the topology atomtype list */
copy_atomtype_atomtypes(atype,&(sys->atomtypes));
if (debug)
pr_symtab(debug,0,"After renum_atype",&sys->symtab);
if (bVerbose)
fprintf(stderr,"converting bonded parameters...\n");
ntype = get_atomtype_ntypes(atype);
convert_params(ntype, plist, mi, comb, reppow, fudgeQQ, sys);
if(ir->implicit_solvent)
{
printf("Constructing Generalized Born topology...\n");
/* Check for -normvsbds switch to grompp, necessary for gb together with vsites */
if(bRmVSBds && nvsite)
{
fprintf(stderr, "ERROR: Must use -normvsbds switch to grompp when doing Generalized Born\n"
"together with virtual sites\n");
nerror++;
}
if (nerror)
{
print_warn_num(FALSE);
gmx_fatal(FARGS,"There were %d error(s) processing your input",nerror);
}
generate_gb_topology(sys,mi);
}
if (debug)
pr_symtab(debug,0,"After convert_params",&sys->symtab);
/* set ptype to VSite for virtual sites */
for(mt=0; mt<sys->nmoltype; mt++) {
set_vsites_ptype(FALSE,&sys->moltype[mt]);
}
if (debug) {
pr_symtab(debug,0,"After virtual sites",&sys->symtab);
}
/* Check velocity for virtual sites and shells */
if (bGenVel) {
check_vel(sys,state.v);
}
/* check masses */
check_mol(sys);
for(i=0; i<sys->nmoltype; i++) {
check_cg_sizes(ftp2fn(efTOP,NFILE,fnm),&sys->moltype[i].cgs);
}
check_warning_error(FARGS);
if (bVerbose)
fprintf(stderr,"initialising group options...\n");
do_index(mdparin,ftp2fn_null(efNDX,NFILE,fnm),
sys,bVerbose,ir,
bGenVel ? state.v : NULL);
/* Init the temperature coupling state */
init_gtc_state(&state,ir->opts.ngtc);
if (bVerbose)
fprintf(stderr,"Checking consistency between energy and charge groups...\n");
check_eg_vs_cg(sys);
if (debug)
pr_symtab(debug,0,"After index",&sys->symtab);
triple_check(mdparin,ir,sys,&nerror);
close_symtab(&sys->symtab);
if (debug)
pr_symtab(debug,0,"After close",&sys->symtab);
/* make exclusions between QM atoms */
if (ir->bQMMM) {
generate_qmexcl(sys,ir);
}
if (ftp2bSet(efTRN,NFILE,fnm)) {
if (bVerbose)
fprintf(stderr,"getting data from old trajectory ...\n");
cont_status(ftp2fn(efTRN,NFILE,fnm),ftp2fn_null(efEDR,NFILE,fnm),
bNeedVel,bGenVel,fr_time,ir,&state,sys);
}
if (ir->ePBC==epbcXY && ir->nwall!=2)
clear_rvec(state.box[ZZ]);
if (EEL_FULL(ir->coulombtype)) {
/* Calculate the optimal grid dimensions */
copy_mat(state.box,box);
if (ir->ePBC==epbcXY && ir->nwall==2)
svmul(ir->wall_ewald_zfac,box[ZZ],box[ZZ]);
max_spacing = calc_grid(stdout,box,opts->fourierspacing,
&(ir->nkx),&(ir->nky),&(ir->nkz),1);
if ((ir->coulombtype == eelPPPM) && (max_spacing > 0.1)) {
set_warning_line(mdparin,-1);
sprintf(warn_buf,"Grid spacing larger then 0.1 while using PPPM.");
warning_note(NULL);
}
}
if (ir->ePull != epullNO)
set_pull_init(ir,sys,state.x,state.box,opts->pull_start);
/* reset_multinr(sys); */
if (EEL_PME(ir->coulombtype)) {
float ratio = pme_load_estimate(sys,ir,state.box);
fprintf(stderr,"Estimate for the relative computational load of the PME mesh part: %.2f\n",ratio);
if (ratio > 0.5)
warning_note("The optimal PME mesh load for parallel simulations is below 0.5\n"
"and for highly parallel simulations between 0.25 and 0.33,\n"
"for higher performance, increase the cut-off and the PME grid spacing");
}
{
double cio = compute_io(ir,sys->natoms,&sys->groups,F_NRE,1);
sprintf(warn_buf,"This run will generate roughly %.0f Mb of data",cio);
if (cio > 2000) {
set_warning_line(mdparin,-1);
warning_note(NULL);
} else {
printf("%s\n",warn_buf);
}
}
if (bVerbose)
fprintf(stderr,"writing run input file...\n");
print_warn_num(TRUE);
state.lambda = ir->init_lambda;
write_tpx_state(ftp2fn(efTPX,NFILE,fnm),ir,&state,sys);
thanx(stderr);
return 0;
}
int gmx_pppm_init(FILE *log, t_commrec *cr,
const output_env_t oenv, gmx_bool bVerbose,
gmx_bool bOld, matrix box,
char *ghatfn, t_inputrec *ir,
gmx_bool bReproducible)
{
int nx,ny,nz,m,porder;
ivec grids;
real r1,rc;
const real tol = 1e-5;
rvec box_diag,spacing;
#ifdef DISABLE_PPPM
gmx_fatal(FARGS,"PPPM is not functional in the current version, we plan to implement PPPM through a small modification of the PME code.");
return -1;
#else
#ifdef GMX_WITHOUT_FFTW
gmx_fatal(FARGS,"PPPM used, but GROMACS was compiled without FFTW support!\n");
#endif
if (log) {
if (cr != NULL) {
if (cr->nnodes > 1)
fprintf(log,"Initializing parallel PPPM.\n");
}
fprintf(log,
"Will use the PPPM algorithm for long-range electrostatics\n");
}
for(m=0; m<DIM; m++)
box_diag[m] = box[m][m];
if (!gmx_fexist(ghatfn)) {
beta[XX]=beta[YY]=beta[ZZ]= 1.85;
nx = ir->nkx;
ny = ir->nky;
nz = ir->nkz;
if (log) {
fprintf(log,"Generating Ghat function\n");
fprintf(log,"Grid size is %d x %d x %d\n",nx,ny,nz);
}
if ((nx < 4) || (ny < 4) || (nz < 4))
gmx_fatal(FARGS,"Grid must be at least 4 points in all directions");
ghat = mk_rgrid(nx,ny,nz);
mk_ghat(NULL,nx,ny,nz,ghat,box_diag,
ir->rcoulomb_switch,ir->rcoulomb,TRUE,bOld);
if (bVerbose)
pr_scalar_gk("generghat.xvg",oenv,nx,ny,nz,box_diag,ghat);
}
else {
fprintf(stderr,"Reading Ghat function from %s\n",ghatfn);
ghat = rd_ghat(log,oenv,ghatfn,grids,spacing,beta,&porder,&r1,&rc);
/* Check whether cut-offs correspond */
if ((fabs(r1-ir->rcoulomb_switch)>tol) || (fabs(rc-ir->rcoulomb)>tol)) {
if (log) {
fprintf(log,"rcoulomb_switch = %10.3e rcoulomb = %10.3e"
" r1 = %10.3e rc = %10.3e\n",
ir->rcoulomb_switch,ir->rcoulomb,r1,rc);
fflush(log);
}
gmx_fatal(FARGS,"Cut-off lengths in tpb file and Ghat file %s "
"do not match\nCheck your log file!",ghatfn);
}
/* Check whether boxes correspond */
for(m=0; (m<DIM); m++)
if (fabs(box_diag[m]-grids[m]*spacing[m]) > tol) {
if (log) {
pr_rvec(log,0,"box",box_diag,DIM,TRUE);
pr_rvec(log,0,"grid-spacing",spacing,DIM,TRUE);
pr_ivec(log,0,"grid size",grids,DIM,TRUE);
fflush(log);
}
gmx_fatal(FARGS,"Box sizes in tpb file and Ghat file %s do not match\n"
"Check your log file!",ghatfn);
}
if (porder != 2)
gmx_fatal(FARGS,"porder = %d, should be 2 in %s",porder,ghatfn);
nx = grids[XX];
ny = grids[YY];
nz = grids[ZZ];
if (bVerbose)
pr_scalar_gk("optimghat.xvg",oenv,nx,ny,nz,box_diag,ghat);
}
/* Now setup the FFT things */
#ifdef GMX_MPI
cr->mpi_comm_mygroup=cr->mpi_comm_mysim;
#endif
grid = mk_fftgrid(nx,ny,nz,NULL,NULL,cr,bReproducible);
return 0;
#endif
}
gmx_bool get_libdir(char *libdir)
{
#define GMX_BINNAME_MAX 512
char bin_name[GMX_BINNAME_MAX];
char buf[GMX_BINNAME_MAX];
char full_path[GMX_PATH_MAX+GMX_BINNAME_MAX];
char system_path[GMX_PATH_MAX];
char *dir,*ptr,*s,*pdum;
gmx_bool found=FALSE;
int i;
if (Program() != NULL)
{
/* First - detect binary name */
if (strlen(Program()) >= GMX_BINNAME_MAX)
{
gmx_fatal(FARGS,"The name of the binary is longer than the allowed buffer size (%d):\n'%s'",GMX_BINNAME_MAX,Program());
}
strncpy(bin_name,Program(),GMX_BINNAME_MAX-1);
/* On windows & cygwin we need to add the .exe extension
* too, or we wont be able to detect that the file exists
*/
#if (defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64 || defined __CYGWIN__ || defined __CYGWIN32__)
if(strlen(bin_name)<3 || gmx_strncasecmp(bin_name+strlen(bin_name)-4,".exe",4))
strcat(bin_name,".exe");
#endif
/* Only do the smart search part if we got a real name */
if (NULL!=bin_name && strncmp(bin_name,"GROMACS",GMX_BINNAME_MAX)) {
if (!strchr(bin_name,DIR_SEPARATOR)) {
/* No slash or backslash in name means it must be in the path - search it! */
/* Add the local dir since it is not in the path on windows */
#if ((defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64) && !defined __CYGWIN__ && !defined __CYGWIN32__)
pdum=_getcwd(system_path,sizeof(system_path)-1);
#else
pdum=getcwd(system_path,sizeof(system_path)-1);
#endif
sprintf(full_path,"%s%c%s",system_path,DIR_SEPARATOR,bin_name);
found = gmx_fexist(full_path);
if (!found && (s=getenv("PATH")) != NULL)
{
char *dupped;
dupped=gmx_strdup(s);
s=dupped;
while(!found && (dir=gmx_strsep(&s, PATH_SEPARATOR)) != NULL)
{
sprintf(full_path,"%s%c%s",dir,DIR_SEPARATOR,bin_name);
found = gmx_fexist(full_path);
}
sfree(dupped);
}
if (!found)
{
return FALSE;
}
} else if (!filename_is_absolute(bin_name)) {
/* name contains directory separators, but
* it does not start at the root, i.e.
* name is relative to the current dir
*/
#if ((defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64) && !defined __CYGWIN__ && !defined __CYGWIN32__)
pdum=_getcwd(buf,sizeof(buf)-1);
#else
pdum=getcwd(buf,sizeof(buf)-1);
#endif
sprintf(full_path,"%s%c%s",buf,DIR_SEPARATOR,bin_name);
} else {
strncpy(full_path,bin_name,GMX_PATH_MAX);
}
/* Now we should have a full path and name in full_path,
* but on unix it might be a link, or a link to a link to a link..
*/
#if (!defined WIN32 && !defined _WIN32 && !defined WIN64 && !defined _WIN64)
while( (i=readlink(full_path,buf,sizeof(buf)-1)) > 0 ) {
buf[i]='\0';
/* If it doesn't start with "/" it is relative */
if (buf[0]!=DIR_SEPARATOR) {
strncpy(strrchr(full_path,DIR_SEPARATOR)+1,buf,GMX_PATH_MAX);
} else
strncpy(full_path,buf,GMX_PATH_MAX);
}
#endif
/* Remove the executable name - it always contains at least one slash */
*(strrchr(full_path,DIR_SEPARATOR)+1)='\0';
/* Now we have the full path to the gromacs executable.
* Use it to find the library dir.
*/
found=FALSE;
while(!found && ( (ptr=strrchr(full_path,DIR_SEPARATOR)) != NULL ) ) {
*ptr='\0';
found=search_subdirs(full_path,libdir);
}
}
}
/* End of smart searching. If we didn't find it in our parent tree,
* or if the program name wasn't set, at least try some standard
* locations before giving up, in case we are running from e.g.
* a users home directory. This only works on unix or cygwin...
*/
#if ((!defined WIN32 && !defined _WIN32 && !defined WIN64 && !defined _WIN64) || defined __CYGWIN__ || defined __CYGWIN32__)
if(!found)
found=search_subdirs("/usr/local",libdir);
if(!found)
found=search_subdirs("/usr",libdir);
if(!found)
found=search_subdirs("/opt",libdir);
#endif
return found;
}
/* Extract the reference positions for the rotation group(s) */
extern void set_reference_positions(
t_rot *rot, gmx_mtop_t *mtop, rvec *x, matrix box,
const char *fn, gmx_bool bSet, warninp_t wi)
{
int g, i, ii;
t_rotgrp *rotg;
t_trnheader header; /* Header information of reference file */
char base[STRLEN], extension[STRLEN], reffile[STRLEN];
char *extpos;
rvec f_box[3]; /* Box from reference file */
/* Base name and extension of the reference file: */
strncpy(base, fn, STRLEN - 1);
base[STRLEN-1] = '\0';
extpos = strrchr(base, '.');
strcpy(extension, extpos+1);
*extpos = '\0';
for (g = 0; g < rot->ngrp; g++)
{
rotg = &rot->grp[g];
fprintf(stderr, "%s group %d has %d reference positions.\n", RotStr, g, rotg->nat);
snew(rotg->x_ref, rotg->nat);
/* Construct the name for the file containing the reference positions for this group: */
sprintf(reffile, "%s.%d.%s", base, g, extension);
/* If the base filename for the reference position files was explicitly set by
* the user, we issue a fatal error if the group file can not be found */
if (bSet && !gmx_fexist(reffile))
{
gmx_fatal(FARGS, "%s The file containing the reference positions was not found.\n"
"Expected the file '%s' for group %d.\n",
RotStr, reffile, g);
}
if (gmx_fexist(reffile))
{
fprintf(stderr, " Reading them from %s.\n", reffile);
read_trnheader(reffile, &header);
if (rotg->nat != header.natoms)
{
gmx_fatal(FARGS, "Number of atoms in file %s (%d) does not match the number of atoms in rotation group (%d)!\n",
reffile, header.natoms, rotg->nat);
}
read_trn(reffile, &header.step, &header.t, &header.lambda, f_box, &header.natoms, rotg->x_ref, NULL, NULL);
/* Check whether the box is unchanged and output a warning if not: */
check_box_unchanged(f_box, box, reffile, wi);
}
else
{
fprintf(stderr, " Saving them to %s.\n", reffile);
for (i = 0; i < rotg->nat; i++)
{
ii = rotg->ind[i];
copy_rvec(x[ii], rotg->x_ref[i]);
}
write_trn(reffile, g, 0.0, 0.0, box, rotg->nat, rotg->x_ref, NULL, NULL);
}
}
}
void
choose_ff(const char *ffsel,
char *forcefield, int ff_maxlen,
char *ffdir, int ffdir_maxlen)
{
int nff;
char **ffdirs,**ffs,**ffs_dir,*ptr;
int i,j,sel,cwdsel,nfound;
char buf[STRLEN],**desc;
FILE *fp;
char *pret;
nff = fflib_search_file_in_dirend(fflib_forcefield_itp(),
fflib_forcefield_dir_ext(),
&ffdirs);
if (nff == 0)
{
gmx_fatal(FARGS,"No force fields found (files with name '%s' in subdirectories ending on '%s')",
fflib_forcefield_itp(),fflib_forcefield_dir_ext());
}
/* Replace with unix path separators */
if(DIR_SEPARATOR!='/')
{
for(i=0;i<nff;i++)
{
while( (ptr=strchr(ffdirs[i],DIR_SEPARATOR))!=NULL )
{
*ptr='/';
}
}
}
/* Store the force field names in ffs */
snew(ffs,nff);
snew(ffs_dir,nff);
for(i=0; i<nff; i++)
{
/* Remove the path from the ffdir name - use our unix standard here! */
ptr = strrchr(ffdirs[i],'/');
if (ptr == NULL)
{
ffs[i] = strdup(ffdirs[i]);
ffs_dir[i] = low_gmxlibfn(ffdirs[i],FALSE,FALSE);
if (ffs_dir[i] == NULL)
{
gmx_fatal(FARGS,"Can no longer find file '%s'",ffdirs[i]);
}
}
else
{
ffs[i] = strdup(ptr+1);
ffs_dir[i] = strdup(ffdirs[i]);
}
ffs_dir[i][strlen(ffs_dir[i])-strlen(ffs[i])-1] = '\0';
/* Remove the extension from the ffdir name */
ffs[i][strlen(ffs[i])-strlen(fflib_forcefield_dir_ext())] = '\0';
}
if (ffsel != NULL)
{
sel = -1;
cwdsel = -1;
nfound = 0;
for(i=0; i<nff; i++)
{
if ( strcmp(ffs[i],ffsel)==0 )
{
/* Matching ff name */
sel = i;
nfound++;
if( strncmp(ffs_dir[i],".",1)==0 )
{
cwdsel = i;
}
}
}
if(cwdsel != -1)
{
sel = cwdsel;
}
if(nfound>1)
{
if(cwdsel!=-1)
{
fprintf(stderr,
"Force field '%s' occurs in %d places. pdb2gmx is using the one in the\n"
"current directory. Use interactive selection (not the -ff option) if\n"
"you would prefer a different one.\n",ffsel,nfound);
}
else
{
gmx_fatal(FARGS,
"Force field '%s' occurs in %d places, but not in the current directory.\n"
"Run without the -ff switch and select the force field interactively.",ffsel,nfound);
}
}
else if (nfound==0)
{
gmx_fatal(FARGS,"Could not find force field '%s' in current directory, install tree or GMXDATA path.",ffsel);
}
}
else if (nff > 1)
{
snew(desc,nff);
for(i=0; (i<nff); i++)
{
sprintf(buf,"%s%c%s%s%c%s",
ffs_dir[i],DIR_SEPARATOR,
ffs[i],fflib_forcefield_dir_ext(),DIR_SEPARATOR,
fflib_forcefield_doc());
if (gmx_fexist(buf))
{
/* We don't use fflib_open, because we don't want printf's */
fp = ffopen(buf,"r");
snew(desc[i],STRLEN);
get_a_line(fp,desc[i],STRLEN);
ffclose(fp);
}
else
{
desc[i] = strdup(ffs[i]);
}
}
/* Order force fields from the same dir alphabetically
* and put deprecated force fields at the end.
*/
for(i=0; (i<nff); i++)
{
for(j=i+1; (j<nff); j++)
{
if (strcmp(ffs_dir[i],ffs_dir[j]) == 0 &&
((desc[i][0] == '[' && desc[j][0] != '[') ||
((desc[i][0] == '[' || desc[j][0] != '[') &&
gmx_strcasecmp(desc[i],desc[j]) > 0)))
{
swap_strings(ffdirs,i,j);
swap_strings(ffs ,i,j);
swap_strings(desc ,i,j);
}
}
}
printf("\nSelect the Force Field:\n");
for(i=0; (i<nff); i++)
{
if (i == 0 || strcmp(ffs_dir[i-1],ffs_dir[i]) != 0)
{
if( strcmp(ffs_dir[i],".")==0 )
{
printf("From current directory:\n");
}
else
{
printf("From '%s':\n",ffs_dir[i]);
}
}
printf("%2d: %s\n",i+1,desc[i]);
sfree(desc[i]);
}
sfree(desc);
do
{
pret = fgets(buf,STRLEN,stdin);
if (pret != NULL)
{
sscanf(buf,"%d",&sel);
sel--;
}
}
while ( pret==NULL || (sel < 0) || (sel >= nff));
}
else
{
sel = 0;
}
if (strlen(ffs[sel]) >= (size_t)ff_maxlen)
{
gmx_fatal(FARGS,"Length of force field name (%d) >= maxlen (%d)",
strlen(ffs[sel]),ff_maxlen);
}
strcpy(forcefield,ffs[sel]);
if (strlen(ffdirs[sel]) >= (size_t)ffdir_maxlen)
{
gmx_fatal(FARGS,"Length of force field dir (%d) >= maxlen (%d)",
strlen(ffdirs[sel]),ffdir_maxlen);
}
strcpy(ffdir,ffdirs[sel]);
for(i=0; (i<nff); i++)
{
sfree(ffdirs[i]);
sfree(ffs[i]);
sfree(ffs_dir[i]);
}
sfree(ffdirs);
sfree(ffs);
sfree(ffs_dir);
}
/*! \brief Support handling restarts
*
* \todo Clean this up (next patch)
*
* Read just the simulation 'generation' and with bTryToAppendFiles check files.
* This is is needed at the beginning of mdrun,
* to be able to rename the logfile correctly.
* When file appending is requested, checks which output files are present,
* and returns TRUE/FALSE in bDoAppendFiles if all or none are present.
* If only some output files are present, give a fatal error.
* When bDoAppendFiles is TRUE upon return, bAddPart will tell whether the simulation part
* needs to be added to the output file name.
*
* This routine cannot print tons of data, since it is called before
* the log file is opened. */
static void
read_checkpoint_data(const char *filename, int *simulation_part,
t_commrec *cr,
gmx_bool bTryToAppendFiles,
int nfile, const t_filenm fnm[],
const char *part_suffix,
gmx_bool *bAddPart,
gmx_bool *bDoAppendFiles)
{
t_fileio *fp;
int nfiles;
gmx_file_position_t *outputfiles;
int nexist, f;
char *fn, suf_up[STRLEN];
*bDoAppendFiles = FALSE;
if (SIMMASTER(cr))
{
if (!gmx_fexist(filename) || (!(fp = gmx_fio_open(filename, "r")) ))
{
*simulation_part = 0;
}
else
{
read_checkpoint_simulation_part_and_filenames(fp,
simulation_part,
&nfiles,
&outputfiles);
if (bTryToAppendFiles)
{
nexist = 0;
for (f = 0; f < nfiles; f++)
{
if (exist_output_file(outputfiles[f].filename, nfile, fnm))
{
nexist++;
}
}
if (nexist == nfiles)
{
*bDoAppendFiles = bTryToAppendFiles;
}
else if (nexist > 0)
{
fprintf(stderr,
"Output file appending has been requested,\n"
"but some output files listed in the checkpoint file %s\n"
"are not present or are named differently by the current program:\n",
filename);
fprintf(stderr, "output files present:");
for (f = 0; f < nfiles; f++)
{
if (exist_output_file(outputfiles[f].filename,
nfile, fnm))
{
fprintf(stderr, " %s", outputfiles[f].filename);
}
}
fprintf(stderr, "\n");
fprintf(stderr, "output files not present or named differently:");
for (f = 0; f < nfiles; f++)
{
if (!exist_output_file(outputfiles[f].filename,
nfile, fnm))
{
fprintf(stderr, " %s", outputfiles[f].filename);
}
}
fprintf(stderr, "\n");
gmx_fatal(FARGS, "File appending requested, but %d of the %d output files are not present or are named differently", nfiles-nexist, nfiles);
}
}
if (*bDoAppendFiles)
{
if (nfiles == 0)
{
gmx_fatal(FARGS, "File appending requested, but no output file information is stored in the checkpoint file");
}
fn = outputfiles[0].filename;
if (strlen(fn) < 4 ||
gmx_strcasecmp(fn+strlen(fn)-4, ftp2ext(efLOG)) == 0)
{
gmx_fatal(FARGS, "File appending requested, but the log file is not the first file listed in the checkpoint file");
}
/* Set bAddPart to whether the suffix string '.part' is present
* in the log file name.
*/
strcpy(suf_up, part_suffix);
upstring(suf_up);
*bAddPart = (strstr(fn, part_suffix) != NULL ||
strstr(fn, suf_up) != NULL);
}
sfree(outputfiles);
}
}
if (PAR(cr))
{
gmx_bcast(sizeof(*simulation_part), simulation_part, cr);
if (*simulation_part > 0 && bTryToAppendFiles)
{
gmx_bcast(sizeof(*bDoAppendFiles), bDoAppendFiles, cr);
gmx_bcast(sizeof(*bAddPart), bAddPart, cr);
}
}
}
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;
}
/*****************************************************************
*
* EXPORTED SECTION
*
*****************************************************************/
int gmx_fio_open(const char *fn,const char *mode)
{
t_fileio *fio=NULL;
int i,nfio=0;
char *bf,newmode[5];
bool bRead;
int xdrid;
if (fn2ftp(fn)==efTPA)
{
strcpy(newmode,mode);
}
else
{
if (mode[0]=='r')
{
strcpy(newmode,"r");
}
else if (mode[0]=='w')
{
strcpy(newmode,"w");
}
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");
}
}
/* Determine whether we have to make a new one */
for(i=0; (i<nFIO); i++)
{
if (!FIO[i].bOpen)
{
fio = &(FIO[i]);
nfio = i;
break;
}
}
if (i == nFIO)
{
nFIO++;
srenew(FIO,nFIO);
fio = &(FIO[nFIO-1]);
nfio = nFIO-1;
}
bRead = (newmode[0]=='r');
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 */
if (gmx_fexist(fn))
{
bf=(char *)backup_fn(fn);
if (rename(fn,bf) == 0)
{
fprintf(stderr,"\nBack Off! I just backed up %s to %s\n",fn,bf);
}
else
{
fprintf(stderr,"Sorry, I couldn't backup %s to %s\n",fn,bf);
}
}
#endif
}
else
{
/* Check whether file exists */
if (!gmx_fexist(fn))
{
gmx_open(fn);
}
}
snew(fio->xdr,1);
xdrid = xdropen(fio->xdr,fn,newmode);
if (xdrid == 0)
{
if(newmode[0]=='r')
gmx_fatal(FARGS,"Cannot open file %s for reading\nCheck permissions if it exists.",fn);
else
gmx_fatal(FARGS,"Cannot open file %s for writing.\nCheck your permissions, disk space and/or quota.",fn);
}
fio->fp = xdr_get_fp(xdrid);
}
else
{
/* If it is not, open it as a regular file */
fio->fp = ffopen(fn,newmode);
}
}
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->bDouble= (sizeof(real) == sizeof(double));
fio->bDebug = FALSE;
fio->bOpen = TRUE;
return nfio;
}
bool Path::exists(const char *path)
{
return gmx_fexist(path);
}
/*****************************************************************
*
* 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;
}
/* Open the file to be processed. The handle variable holds internal
info for the cpp emulator. Return integer status */
int cpp_open_file(const char *filenm, gmx_cpp_t *handle, char **cppopts)
{
gmx_cpp_t cpp;
char *buf, *pdum;
char *ptr, *ptr2;
int i;
unsigned int i1;
/* First process options, they might be necessary for opening files
(especially include statements). */
i = 0;
if (cppopts)
{
while (cppopts[i])
{
if (strstr(cppopts[i], "-I") == cppopts[i])
{
add_include(cppopts[i]+2);
}
if (strstr(cppopts[i], "-D") == cppopts[i])
{
/* If the option contains a =, split it into name and value. */
ptr = strchr(cppopts[i], '=');
if (ptr)
{
buf = gmx_strndup(cppopts[i] + 2, ptr - cppopts[i] - 2);
add_define(buf, ptr + 1);
sfree(buf);
}
else
{
add_define(cppopts[i] + 2, NULL);
}
}
i++;
}
}
if (debug)
{
fprintf(debug, "GMXCPP: added %d command line arguments\n", i);
}
snew(cpp, 1);
*handle = cpp;
cpp->fn = NULL;
/* Find the file. First check whether it is in the current directory. */
if (gmx_fexist(filenm))
{
cpp->fn = gmx_strdup(filenm);
}
else
{
/* If not, check all the paths given with -I. */
for (i = 0; i < nincl; ++i)
{
snew(buf, strlen(incl[i]) + strlen(filenm) + 2);
sprintf(buf, "%s/%s", incl[i], filenm);
if (gmx_fexist(buf))
{
cpp->fn = buf;
break;
}
sfree(buf);
}
/* If still not found, check the Gromacs library search path. */
if (!cpp->fn)
{
cpp->fn = low_gmxlibfn(filenm, FALSE, FALSE);
}
}
if (!cpp->fn)
{
gmx_fatal(FARGS, "Topology include file \"%s\" not found", filenm);
}
if (NULL != debug)
{
fprintf(debug, "GMXCPP: cpp file open %s\n", cpp->fn);
}
/* If the file name has a path component, we need to change to that
* directory. Note that we - just as C - always use UNIX path separators
* internally in include file names.
*/
ptr = strrchr(cpp->fn, '/');
ptr2 = strrchr(cpp->fn, DIR_SEPARATOR);
if (ptr == NULL || (ptr2 != NULL && ptr2 > ptr))
{
ptr = ptr2;
}
if (ptr == NULL)
{
cpp->path = NULL;
cpp->cwd = NULL;
}
else
{
cpp->path = cpp->fn;
*ptr = '\0';
cpp->fn = gmx_strdup(ptr+1);
snew(cpp->cwd, STRLEN);
gmx_getcwd(cpp->cwd, STRLEN);
if (NULL != debug)
{
fprintf(debug, "GMXCPP: cwd %s\n", cpp->cwd);
}
gmx_chdir(cpp->path);
if (NULL != debug)
{
fprintf(debug, "GMXCPP: chdir to %s\n", cpp->path);
}
}
cpp->line_len = 0;
cpp->line = NULL;
cpp->line_nr = 0;
cpp->nifdef = 0;
cpp->ifdefs = NULL;
cpp->child = NULL;
cpp->parent = NULL;
if (cpp->fp == NULL)
{
if (NULL != debug)
{
fprintf(debug, "GMXCPP: opening file %s\n", cpp->fn);
}
cpp->fp = fopen(cpp->fn, "r");
}
if (cpp->fp == NULL)
{
switch (errno)
{
case EINVAL:
default:
return eCPP_UNKNOWN;
}
}
return eCPP_OK;
}
int gmx_do_dssp(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] ",
"reads a trajectory file and computes the secondary structure for",
"each time frame ",
"calling the dssp program. If you do not have the dssp program,",
"get it from http://swift.cmbi.ru.nl/gv/dssp. [THISMODULE] assumes ",
"that the dssp executable is located in ",
"[TT]/usr/local/bin/dssp[tt]. If this is not the case, then you should",
"set an environment variable [TT]DSSP[tt] pointing to the dssp",
"executable, e.g.: [PAR]",
"[TT]setenv DSSP /opt/dssp/bin/dssp[tt][PAR]",
"Since version 2.0.0, dssp is invoked with a syntax that differs",
"from earlier versions. If you have an older version of dssp,",
"use the [TT]-ver[tt] option to direct do_dssp to use the older syntax.",
"By default, do_dssp uses the syntax introduced with version 2.0.0.",
"Even newer versions (which at the time of writing are not yet released)",
"are assumed to have the same syntax as 2.0.0.[PAR]",
"The structure assignment for each residue and time is written to an",
"[TT].xpm[tt] matrix file. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [TT]xpm2ps[tt].",
"Individual chains are separated by light grey lines in the [TT].xpm[tt] and",
"postscript files.",
"The number of residues with each secondary structure type and the",
"total secondary structure ([TT]-sss[tt]) count as a function of",
"time are also written to file ([TT]-sc[tt]).[PAR]",
"Solvent accessible surface (SAS) per residue can be calculated, both in",
"absolute values (A^2) and in fractions of the maximal accessible",
"surface of a residue. The maximal accessible surface is defined as",
"the accessible surface of a residue in a chain of glycines.",
"[BB]Note[bb] that the program [gmx-sas] can also compute SAS",
"and that is more efficient.[PAR]",
"Finally, this program can dump the secondary structure in a special file",
"[TT]ssdump.dat[tt] for usage in the program [gmx-chi]. Together",
"these two programs can be used to analyze dihedral properties as a",
"function of secondary structure type."
};
static gmx_bool bVerbose;
static const char *ss_string = "HEBT";
static int dsspVersion = 2;
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" },
{ "-sss", FALSE, etSTR, {&ss_string},
"Secondary structures for structure count"},
{ "-ver", FALSE, etINT, {&dsspVersion},
"DSSP major version. Syntax changed with version 2"}
};
t_trxstatus *status;
FILE *tapein;
FILE *ss, *acc, *fTArea, *tmpf;
const char *fnSCount, *fnArea, *fnTArea, *fnAArea;
const char *leg[] = { "Phobic", "Phylic" };
t_topology top;
int ePBC;
t_atoms *atoms;
t_matrix mat;
int nres, nr0, naccr, nres_plus_separators;
gmx_bool *bPhbres, bDoAccSurf;
real t;
int i, j, natoms, nframe = 0;
matrix box = {{0}};
int gnx;
char *grpnm, *ss_str;
atom_id *index;
rvec *xp, *x;
int *average_area;
real **accr, *accr_ptr = NULL, *av_area, *norm_av_area;
char pdbfile[32], tmpfile[32], title[256];
char dssp[256];
const char *dptr;
output_env_t oenv;
gmx_rmpbc_t gpbc = NULL;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-ssdump", "ssdump", ffOPTWR },
{ efMAP, "-map", "ss", ffLIBRD },
{ efXPM, "-o", "ss", ffWRITE },
{ efXVG, "-sc", "scount", ffWRITE },
{ efXPM, "-a", "area", ffOPTWR },
{ efXVG, "-ta", "totarea", ffOPTWR },
{ efXVG, "-aa", "averarea", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
fnSCount = opt2fn("-sc", NFILE, fnm);
fnArea = opt2fn_null("-a", NFILE, fnm);
fnTArea = opt2fn_null("-ta", NFILE, fnm);
fnAArea = opt2fn_null("-aa", NFILE, fnm);
bDoAccSurf = (fnArea || fnTArea || fnAArea);
read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xp, NULL, box, FALSE);
atoms = &(top.atoms);
check_oo(atoms);
bPhbres = bPhobics(atoms);
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
{
fclose(tmpf);
}
strcpy(tmpfile, "ddXXXXXX");
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile, "w")) == NULL)
{
sprintf(tmpfile, "%ctmp%cfilterXXXXXX", DIR_SEPARATOR, DIR_SEPARATOR);
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile, "w")) == NULL)
{
gmx_fatal(FARGS, "Can not open tmp file %s", tmpfile);
}
}
else
{
fclose(tmpf);
}
if ((dptr = getenv("DSSP")) == NULL)
{
dptr = "/usr/local/bin/dssp";
}
if (!gmx_fexist(dptr))
{
gmx_fatal(FARGS, "DSSP executable (%s) does not exist (use setenv DSSP)",
dptr);
}
if (dsspVersion >= 2)
{
if (dsspVersion > 2)
{
printf("\nWARNING: You use DSSP version %d, which is not explicitly\nsupported by do_dssp. Assuming version 2 syntax.\n\n", dsspVersion);
}
sprintf(dssp, "%s -i %s -o %s > /dev/null %s",
dptr, pdbfile, tmpfile, bVerbose ? "" : "2> /dev/null");
}
else
{
sprintf(dssp, "%s %s %s %s > /dev/null %s",
dptr, bDoAccSurf ? "" : "-na", pdbfile, tmpfile, bVerbose ? "" : "2> /dev/null");
}
fprintf(stderr, "dssp cmd='%s'\n", dssp);
if (fnTArea)
{
fTArea = xvgropen(fnTArea, "Solvent Accessible Surface Area",
output_env_get_xvgr_tlabel(oenv), "Area (nm\\S2\\N)", oenv);
xvgr_legend(fTArea, 2, leg, oenv);
}
else
{
fTArea = NULL;
}
mat.map = NULL;
mat.nmap = readcmap(opt2fn("-map", NFILE, fnm), &(mat.map));
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
if (natoms > atoms->nr)
{
gmx_fatal(FARGS, "\nTrajectory does not match topology!");
}
if (gnx > natoms)
{
gmx_fatal(FARGS, "\nTrajectory does not match selected group!");
}
snew(average_area, atoms->nres);
snew(av_area, atoms->nres);
snew(norm_av_area, atoms->nres);
accr = NULL;
naccr = 0;
gpbc = gmx_rmpbc_init(&top.idef, ePBC, natoms);
do
{
t = output_env_conv_time(oenv, t);
if (bDoAccSurf && nframe >= naccr)
{
naccr += 10;
srenew(accr, naccr);
for (i = naccr-10; i < naccr; i++)
{
snew(accr[i], 2*atoms->nres-1);
}
}
gmx_rmpbc(gpbc, natoms, box, x);
tapein = gmx_ffopen(pdbfile, "w");
write_pdbfile_indexed(tapein, NULL, atoms, x, ePBC, box, ' ', -1, gnx, index, NULL, TRUE);
gmx_ffclose(tapein);
if (0 != system(dssp))
{
gmx_fatal(FARGS, "Failed to execute command: %s\n",
"Try specifying your dssp version with the -ver option.", dssp);
}
/* strip_dssp returns the number of lines found in the dssp file, i.e.
* the number of residues plus the separator lines */
if (bDoAccSurf)
{
accr_ptr = accr[nframe];
}
nres_plus_separators = strip_dssp(tmpfile, nres, bPhbres, t,
accr_ptr, fTArea, &mat, average_area, oenv);
remove(tmpfile);
remove(pdbfile);
nframe++;
}
while (read_next_x(oenv, status, &t, x, box));
fprintf(stderr, "\n");
close_trj(status);
if (fTArea)
{
xvgrclose(fTArea);
}
gmx_rmpbc_done(gpbc);
prune_ss_legend(&mat);
ss = opt2FILE("-o", NFILE, fnm, "w");
mat.flags = 0;
write_xpm_m(ss, mat);
gmx_ffclose(ss);
if (opt2bSet("-ssdump", NFILE, fnm))
{
ss = opt2FILE("-ssdump", NFILE, fnm, "w");
snew(ss_str, nres+1);
fprintf(ss, "%d\n", nres);
for (j = 0; j < mat.nx; j++)
{
for (i = 0; (i < mat.ny); i++)
{
ss_str[i] = mat.map[mat.matrix[j][i]].code.c1;
}
ss_str[i] = '\0';
fprintf(ss, "%s\n", ss_str);
}
gmx_ffclose(ss);
sfree(ss_str);
}
analyse_ss(fnSCount, &mat, ss_string, oenv);
if (bDoAccSurf)
{
write_sas_mat(fnArea, accr, nframe, nres_plus_separators, &mat);
for (i = 0; i < atoms->nres; i++)
{
av_area[i] = (average_area[i] / (real)nframe);
}
norm_acc(atoms, nres, av_area, norm_av_area);
if (fnAArea)
{
acc = xvgropen(fnAArea, "Average Accessible Area",
"Residue", "A\\S2", oenv);
for (i = 0; (i < nres); i++)
{
fprintf(acc, "%5d %10g %10g\n", i+1, av_area[i], norm_av_area[i]);
}
xvgrclose(acc);
}
}
view_all(oenv, NFILE, fnm);
return 0;
}
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);
}
int main(int argc,char *argv[])
{
const char *desc[] = {
"do_dssp ",
"reads a trajectory file and computes the secondary structure for",
"each time frame ",
"calling the dssp program. If you do not have the dssp program,",
"get it. do_dssp assumes that the dssp executable is",
"/usr/local/bin/dssp. If this is not the case, then you should",
"set an environment variable [BB]DSSP[bb] pointing to the dssp",
"executable, e.g.: [PAR]",
"[TT]setenv DSSP /opt/dssp/bin/dssp[tt][PAR]",
"The structure assignment for each residue and time is written to an",
"[TT].xpm[tt] matrix file. This file can be visualized with for instance",
"[TT]xv[tt] and can be converted to postscript with [TT]xpm2ps[tt].",
"Individual chains are separated by light grey lines in the xpm and",
"postscript files.",
"The number of residues with each secondary structure type and the",
"total secondary structure ([TT]-sss[tt]) count as a function of",
"time are also written to file ([TT]-sc[tt]).[PAR]",
"Solvent accessible surface (SAS) per residue can be calculated, both in",
"absolute values (A^2) and in fractions of the maximal accessible",
"surface of a residue. The maximal accessible surface is defined as",
"the accessible surface of a residue in a chain of glycines.",
"[BB]Note[bb] that the program [TT]g_sas[tt] can also compute SAS",
"and that is more efficient.[PAR]",
"Finally, this program can dump the secondary structure in a special file",
"[TT]ssdump.dat[tt] for usage in the program [TT]g_chi[tt]. Together",
"these two programs can be used to analyze dihedral properties as a",
"function of secondary structure type."
};
static bool bVerbose;
static const char *ss_string="HEBT";
t_pargs pa[] = {
{ "-v", FALSE, etBOOL, {&bVerbose},
"HIDDENGenerate miles of useless information" },
{ "-sss", FALSE, etSTR, {&ss_string},
"Secondary structures for structure count"}
};
int status;
FILE *tapein;
FILE *ss,*acc,*fTArea,*tmpf;
char *fnSCount,*fnArea,*fnTArea,*fnAArea;
char *leg[] = { "Phobic", "Phylic" };
t_topology top;
int ePBC;
t_atoms *atoms;
t_matrix mat;
int nres,nr0,naccr,nres_plus_separators;
bool *bPhbres,bDoAccSurf;
real t;
int i,natoms,nframe=0;
matrix box;
int gnx;
char *grpnm,*ss_str;
atom_id *index;
rvec *xp,*x;
int *average_area;
real **accr,*accr_ptr=NULL,*av_area, *norm_av_area;
char pdbfile[32],tmpfile[32],title[256];
char dssp[256];
const char *dptr;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efDAT, "-ssdump", "ssdump", ffOPTWR },
{ efMAP, "-map", "ss", ffLIBRD },
{ efXPM, "-o", "ss", ffWRITE },
{ efXVG, "-sc", "scount", ffWRITE },
{ efXPM, "-a", "area", ffOPTWR },
{ efXVG, "-ta", "totarea", ffOPTWR },
{ efXVG, "-aa", "averarea",ffOPTWR }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME | PCA_CAN_VIEW | PCA_TIME_UNIT | PCA_BE_NICE ,
NFILE,fnm, asize(pa),pa, asize(desc),desc,0,NULL);
fnSCount= opt2fn("-sc",NFILE,fnm);
fnArea = opt2fn_null("-a", NFILE,fnm);
fnTArea = opt2fn_null("-ta",NFILE,fnm);
fnAArea = opt2fn_null("-aa",NFILE,fnm);
bDoAccSurf=(fnArea || fnTArea || fnAArea);
read_tps_conf(ftp2fn(efTPS,NFILE,fnm),title,&top,&ePBC,&xp,NULL,box,FALSE);
atoms=&(top.atoms);
check_oo(atoms);
bPhbres=bPhobics(atoms);
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
fclose(tmpf);
strcpy(tmpfile,"ddXXXXXX");
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile,"w")) == NULL) {
sprintf(tmpfile,"%ctmp%cfilterXXXXXX",DIR_SEPARATOR,DIR_SEPARATOR);
gmx_tmpnam(tmpfile);
if ((tmpf = fopen(tmpfile,"w")) == NULL)
gmx_fatal(FARGS,"Can not open tmp file %s",tmpfile);
}
else
fclose(tmpf);
if ((dptr=getenv("DSSP")) == NULL)
dptr="/usr/local/bin/dssp";
if (!gmx_fexist(dptr))
gmx_fatal(FARGS,"DSSP executable (%s) does not exist (use setenv DSSP)",
dptr);
sprintf(dssp,"%s %s %s %s > /dev/null %s",
dptr,bDoAccSurf?"":"-na",pdbfile,tmpfile,bVerbose?"":"2> /dev/null");
if (bVerbose)
fprintf(stderr,"dssp cmd='%s'\n",dssp);
if (fnTArea) {
fTArea=xvgropen(fnTArea,"Solvent Accessible Surface Area",
xvgr_tlabel(),"Area (nm\\S2\\N)");
xvgr_legend(fTArea,2,leg);
} else
fTArea=NULL;
mat.map=NULL;
mat.nmap=getcmap(libopen(opt2fn("-map",NFILE,fnm)),
opt2fn("-map",NFILE,fnm),&(mat.map));
natoms=read_first_x(&status,ftp2fn(efTRX,NFILE,fnm),&t,&x,box);
if (natoms > atoms->nr)
gmx_fatal(FARGS,"\nTrajectory does not match topology!");
if (gnx > natoms)
gmx_fatal(FARGS,"\nTrajectory does not match selected group!");
snew(average_area, atoms->nres);
snew(av_area , atoms->nres);
snew(norm_av_area, atoms->nres);
accr=NULL;
naccr=0;
do {
t = convert_time(t);
if (bDoAccSurf && nframe>=naccr) {
naccr+=10;
srenew(accr,naccr);
for(i=naccr-10; i<naccr; i++)
snew(accr[i],2*atoms->nres-1);
}
rm_pbc(&(top.idef),ePBC,natoms,box,x,x);
tapein=ffopen(pdbfile,"w");
write_pdbfile_indexed(tapein,NULL,atoms,x,ePBC,box,0,-1,gnx,index,NULL);
fclose(tapein);
#ifdef GMX_NO_SYSTEM
printf("Warning-- No calls to system(3) supported on this platform.");
printf("Warning-- Skipping execution of 'system(\"%s\")'.", dssp);
exit(1);
#else
if(0 != system(dssp))
{
gmx_fatal(FARGS,"Failed to execute command: %s",dssp);
}
#endif
/* strip_dssp returns the number of lines found in the dssp file, i.e.
* the number of residues plus the separator lines */
if (bDoAccSurf)
accr_ptr = accr[nframe];
nres_plus_separators = strip_dssp(tmpfile,nres,bPhbres,t,
accr_ptr,fTArea,&mat,average_area);
remove(tmpfile);
remove(pdbfile);
nframe++;
} while(read_next_x(status,&t,natoms,x,box));
fprintf(stderr,"\n");
close_trj(status);
if (fTArea)
ffclose(fTArea);
prune_ss_legend(&mat);
ss=opt2FILE("-o",NFILE,fnm,"w");
mat.flags = 0;
write_xpm_m(ss,mat);
ffclose(ss);
if (opt2bSet("-ssdump",NFILE,fnm)) {
snew(ss_str,nres+1);
for(i=0; (i<nres); i++)
ss_str[i] = mat.map[mat.matrix[0][i]].code.c1;
ss_str[i] = '\0';
ss = opt2FILE("-ssdump",NFILE,fnm,"w");
fprintf(ss,"%d\n%s\n",nres,ss_str);
fclose(ss);
sfree(ss_str);
}
analyse_ss(fnSCount,&mat,ss_string);
if (bDoAccSurf) {
write_sas_mat(fnArea,accr,nframe,nres_plus_separators,&mat);
for(i=0; i<atoms->nres; i++)
av_area[i] = (average_area[i] / (real)nframe);
norm_acc(atoms, nres, av_area, norm_av_area);
if (fnAArea) {
acc=xvgropen(fnAArea,"Average Accessible Area",
"Residue","A\\S2");
for(i=0; (i<nres); i++)
fprintf(acc,"%5d %10g %10g\n",i+1,av_area[i], norm_av_area[i]);
ffclose(acc);
}
}
view_all(NFILE, fnm);
thanx(stderr);
return 0;
}
// static
bool File::exists(const char *filename)
{
return gmx_fexist(filename);
}