/*! \brief
* Handles initialization of method parameter token.
*/
static int
init_param_token(YYSTYPE *yylval, gmx_ana_selparam_t *param, bool bBoolNo)
{
if (bBoolNo)
{
GMX_RELEASE_ASSERT(param->name != nullptr,
"bBoolNo should only be set for a parameters with a name");
snew(yylval->str, strlen(param->name) + 3);
yylval->str[0] = 'n';
yylval->str[1] = 'o';
strcpy(yylval->str+2, param->name);
}
else
{
yylval->str = param->name ? gmx_strdup(param->name) : nullptr;
}
return PARAM;
}
t_specbond *get_specbonds(int *nspecbond)
{
const char *sbfile = "specbond.dat";
t_specbond *sb = NULL;
char r1buf[32], r2buf[32], a1buf[32], a2buf[32], nr1buf[32], nr2buf[32];
double length;
int nb1, nb2;
char **lines;
int nlines, i, n;
nlines = get_lines(sbfile, &lines);
if (nlines > 0)
{
snew(sb, nlines);
}
n = 0;
for (i = 0; (i < nlines); i++)
{
if (sscanf(lines[i], "%s%s%d%s%s%d%lf%s%s",
r1buf, a1buf, &nb1, r2buf, a2buf, &nb2, &length, nr1buf, nr2buf) != 9)
{
fprintf(stderr, "Invalid line '%s' in %s\n", lines[i], sbfile);
}
else
{
sb[n].res1 = gmx_strdup(r1buf);
sb[n].res2 = gmx_strdup(r2buf);
sb[n].newres1 = gmx_strdup(nr1buf);
sb[n].newres2 = gmx_strdup(nr2buf);
sb[n].atom1 = gmx_strdup(a1buf);
sb[n].atom2 = gmx_strdup(a2buf);
sb[n].nbond1 = nb1;
sb[n].nbond2 = nb2;
sb[n].length = length;
n++;
}
sfree(lines[i]);
}
if (nlines > 0)
{
sfree(lines);
}
fprintf(stderr, "%d out of %d lines of %s converted successfully\n",
n, nlines, sbfile);
*nspecbond = n;
return sb;
}
static void edr_strings(XDR *xdr, gmx_bool bRead, int file_version,
int n, gmx_enxnm_t **nms)
{
int i;
gmx_enxnm_t *nm;
if (*nms == NULL)
{
snew(*nms, n);
}
for (i = 0; i < n; i++)
{
nm = &(*nms)[i];
if (bRead)
{
if (nm->name)
{
sfree(nm->name);
nm->name = NULL;
}
if (nm->unit)
{
sfree(nm->unit);
nm->unit = NULL;
}
}
if (!xdr_string(xdr, &(nm->name), STRLEN))
{
gmx_file("Cannot write energy names to file; maybe you are out of disk space?");
}
if (file_version >= 2)
{
if (!xdr_string(xdr, &(nm->unit), STRLEN))
{
gmx_file("Cannot write energy names to file; maybe you are out of disk space?");
}
}
else
{
nm->unit = gmx_strdup("kJ/mol");
}
}
}
static void split_group(t_atoms *atoms, int sel_nr, t_blocka *block, char ***gn,
gmx_bool bAtom)
{
char buf[STRLEN], *name;
int i, resind;
atom_id a, n0, n1;
printf("Splitting group %d '%s' into %s\n", sel_nr, (*gn)[sel_nr],
bAtom ? "atoms" : "residues");
n0 = block->index[sel_nr];
n1 = block->index[sel_nr+1];
srenew(block->a, block->nra+n1-n0);
for (i = n0; i < n1; i++)
{
a = block->a[i];
resind = atoms->atom[a].resind;
name = *(atoms->resinfo[resind].name);
if (bAtom || (i == n0) || (atoms->atom[block->a[i-1]].resind != resind))
{
if (i > n0)
{
block->index[block->nr] = block->nra;
}
block->nr++;
srenew(block->index, block->nr+1);
srenew(*gn, block->nr);
if (bAtom)
{
sprintf(buf, "%s_%s_%d", (*gn)[sel_nr], *atoms->atomname[a], a+1);
}
else
{
sprintf(buf, "%s_%s_%d", (*gn)[sel_nr], name, atoms->resinfo[resind].nr);
}
(*gn)[block->nr-1] = gmx_strdup(buf);
}
block->a[block->nra] = a;
block->nra++;
}
block->index[block->nr] = block->nra;
}
/*!
* \param[in,out] sel Selection element to initialize.
* \param[in] type One of the enum values acceptable for
* PositionCalculationCollection::typeFromEnum().
*
* Initializes the reference position type for position evaluation.
* If called multiple times, the first setting takes effect, and later calls
* are neglected.
*/
void
_gmx_selelem_set_kwpos_type(gmx::SelectionTreeElement *sel, const char *type)
{
t_methoddata_pos *d = (t_methoddata_pos *)sel->u.expr.mdata;
if (sel->type != SEL_EXPRESSION || !sel->u.expr.method
|| sel->u.expr.method->name != sm_keyword_pos.name)
{
return;
}
if (!d->type && type)
{
d->type = gmx_strdup(type);
/* FIXME: It would be better not to have the string here hardcoded. */
if (type[0] != 'a')
{
sel->u.expr.method->flags |= SMETH_REQTOP;
}
}
}
static char *repallww(const char *s,int nsr,const t_sandr sa[])
{
int i;
char *buf1,*buf2;
/* Copy input to a non-constant char buffer.
* buf1 is allocated here
*/
buf1=gmx_strdup(s);
for(i=0; (i<nsr); i++) {
/* Replace in buffer1, put result in buffer2.
* buf2 is allocated here.
*/
buf2=replaceww(buf1,sa[i].search,sa[i].replace);
sfree(buf1);
buf1=buf2;
}
return buf1;
}
static void remove_group(int nr, int nr2, t_blocka *block, char ***gn)
{
int i, j, shift;
char *name;
if (nr2 == NOTSET)
{
nr2 = nr;
}
for (j = 0; j <= nr2-nr; j++)
{
if ((nr < 0) || (nr >= block->nr))
{
printf("Group %d does not exist\n", nr+j);
}
else
{
shift = block->index[nr+1]-block->index[nr];
for (i = block->index[nr+1]; i < block->nra; i++)
{
block->a[i-shift] = block->a[i];
}
for (i = nr; i < block->nr; i++)
{
block->index[i] = block->index[i+1]-shift;
}
name = gmx_strdup((*gn)[nr]);
sfree((*gn)[nr]);
for (i = nr; i < block->nr-1; i++)
{
(*gn)[i] = (*gn)[i+1];
}
block->nr--;
block->nra = block->index[block->nr];
printf("Removed group %d '%s'\n", nr+j, name);
sfree(name);
}
}
}
void TopologyManager::initAtomTypes(const ArrayRef<const char *const> &types)
{
GMX_RELEASE_ASSERT(mtop_ != nullptr, "Topology not initialized");
atomtypes_.reserve(types.size());
for (const char *type : types)
{
atomtypes_.push_back(gmx_strdup(type));
}
t_atoms &atoms = this->atoms();
snew(atoms.atomtype, atoms.nr);
index j = 0;
for (int i = 0; i < atoms.nr; ++i, ++j)
{
if (j == types.size())
{
j = 0;
}
atoms.atomtype[i] = &atomtypes_[j];
}
atoms.haveType = TRUE;
}
static int get_einp(int *ninp, t_inpfile **inp, const char *name)
{
int i;
int notfound = FALSE;
char warn_buf[STRLEN];
/* if (inp==NULL)
return -1;
for(i=0; (i<(*ninp)); i++)
if (gmx_strcasecmp_min(name,(*inp)[i].name) == 0)
break;
if (i == (*ninp)) {*/
i = search_einp(*ninp, *inp, name);
if (i == -1)
{
notfound = TRUE;
i = (*ninp)++;
srenew(*inp, (*ninp));
(*inp)[i].name = gmx_strdup(name);
(*inp)[i].bSet = TRUE;
}
(*inp)[i].count = (*inp)[0].inp_count++;
(*inp)[i].bSet = TRUE;
if (debug)
{
fprintf(debug, "Inp %d = %s\n", (*inp)[i].count, (*inp)[i].name);
}
/*if (i == (*ninp)-1)*/
if (notfound)
{
return -1;
}
else
{
return i;
}
}
static void add_include(const char *include)
{
int i;
if (include == NULL)
{
return;
}
for (i = 0; (i < nincl); i++)
{
if (strcmp(incl[i], include) == 0)
{
break;
}
}
if (i == nincl)
{
nincl++;
srenew(incl, nincl);
incl[nincl-1] = gmx_strdup(include);
}
}
void InitWin(t_windata *win, int x0, int y0, int w, int h, int bw, const char *text)
{
win->self = 0;
win->color = 0;
win->x = x0;
win->y = y0;
win->width = w;
win->height = h;
win->bwidth = bw;
win->bFocus = false;
win->cursor = 0;
if (text)
{
win->text = gmx_strdup(text);
}
else
{
win->text = NULL;
}
#ifdef DEBUG
printf("%s: %d x %d at %d, %d\n", text, w, h, x0, y0);
#endif
}
static gmx_bool is_equiv(int neq, t_equiv **equiv, char **nname,
int rnr1, char *rname1, char *aname1,
int rnr2, char *rname2, char *aname2)
{
int i, j;
gmx_bool bFound;
bFound = FALSE;
/* we can terminate each loop when bFound is true! */
for (i = 0; i < neq && !bFound; i++)
{
/* find first atom */
for (j = 0; equiv[i][j].rnr != NOTSET && !bFound; j++)
{
bFound = ( equiv[i][j].rnr == rnr1 &&
std::strcmp(equiv[i][j].rname, rname1) == 0 &&
std::strcmp(equiv[i][j].aname, aname1) == 0 );
}
if (bFound)
{
/* find second atom */
bFound = FALSE;
for (j = 0; equiv[i][j].rnr != NOTSET && !bFound; j++)
{
bFound = ( equiv[i][j].rnr == rnr2 &&
std::strcmp(equiv[i][j].rname, rname2) == 0 &&
std::strcmp(equiv[i][j].aname, aname2) == 0 );
}
}
}
if (bFound)
{
*nname = gmx_strdup(equiv[i-1][0].nname);
}
return bFound;
}
static t_hackblock *get_hackblocks(t_atoms *pdba, int nah, t_hackblock ah[],
int nterpairs,
t_hackblock **ntdb, t_hackblock **ctdb,
int *rN, int *rC)
{
int i, rnr;
t_hackblock *hb, *ahptr;
/* make space */
snew(hb, pdba->nres);
/* first the termini */
for (i = 0; i < nterpairs; i++)
{
if (ntdb[i] != NULL)
{
copy_t_hackblock(ntdb[i], &hb[rN[i]]);
}
if (ctdb[i] != NULL)
{
merge_t_hackblock(ctdb[i], &hb[rC[i]]);
}
}
/* then the whole hdb */
for (rnr = 0; rnr < pdba->nres; rnr++)
{
ahptr = search_h_db(nah, ah, *pdba->resinfo[rnr].rtp);
if (ahptr)
{
if (hb[rnr].name == NULL)
{
hb[rnr].name = gmx_strdup(ahptr->name);
}
merge_hacks(ahptr, &hb[rnr]);
}
}
return hb;
}
void replace_inp_entry(int ninp, t_inpfile *inp, const char *old_entry, const char *new_entry)
{
int i;
for (i = 0; (i < ninp); i++)
{
if (gmx_strcasecmp_min(old_entry, inp[i].name) == 0)
{
if (new_entry)
{
fprintf(stderr, "Replacing old mdp entry '%s' by '%s'\n",
inp[i].name, new_entry);
sfree(inp[i].name);
inp[i].name = gmx_strdup(new_entry);
}
else
{
fprintf(stderr, "Ignoring obsolete mdp entry '%s'\n",
inp[i].name);
inp[i].bObsolete = TRUE;
}
}
}
}
static void check_oo(t_atoms *atoms)
{
char *OOO;
int i;
OOO = gmx_strdup("O");
for (i = 0; (i < atoms->nr); i++)
{
if (strcmp(*(atoms->atomname[i]), "OXT") == 0)
{
*atoms->atomname[i] = OOO;
}
else if (strcmp(*(atoms->atomname[i]), "O1") == 0)
{
*atoms->atomname[i] = OOO;
}
else if (strcmp(*(atoms->atomname[i]), "OC1") == 0)
{
*atoms->atomname[i] = OOO;
}
}
}
int
_gmx_sel_lexer_process_identifier(YYSTYPE *yylval, YYLTYPE *yylloc,
char *yytext, size_t yyleng,
gmx_sel_lexer_t *state)
{
/* Check if the identifier matches with a parameter name */
if (state->msp >= 0)
{
gmx_ana_selparam_t *param = nullptr;
bool bBoolNo = false;
int sp = state->msp;
while (!param && sp >= 0)
{
int i;
for (i = 0; i < state->mstack[sp]->nparams; ++i)
{
/* Skip NULL parameters and too long parameters */
if (state->mstack[sp]->param[i].name == nullptr
|| strlen(state->mstack[sp]->param[i].name) > yyleng)
{
continue;
}
if (!strncmp(state->mstack[sp]->param[i].name, yytext, yyleng))
{
param = &state->mstack[sp]->param[i];
break;
}
/* Check separately for a 'no' prefix on boolean parameters */
if (state->mstack[sp]->param[i].val.type == NO_VALUE
&& yyleng > 2 && yytext[0] == 'n' && yytext[1] == 'o'
&& !strncmp(state->mstack[sp]->param[i].name, yytext+2, yyleng-2))
{
param = &state->mstack[sp]->param[i];
bBoolNo = true;
break;
}
}
if (!param)
{
--sp;
}
}
if (param)
{
if (param->val.type == NO_VALUE && !bBoolNo)
{
state->bMatchBool = true;
}
if (sp < state->msp)
{
state->neom = state->msp - sp - 1;
state->nextparam = param;
state->bBoolNo = bBoolNo;
return END_OF_METHOD;
}
_gmx_sel_lexer_add_token(yylloc, param->name, -1, state);
return init_param_token(yylval, param, bBoolNo);
}
}
/* Check if the identifier matches with a symbol */
const gmx::SelectionParserSymbol *symbol
= state->sc->symtab->findSymbol(std::string(yytext, yyleng));
/* If there is no match, return the token as a string */
if (!symbol)
{
yylval->str = gmx_strndup(yytext, yyleng);
_gmx_sel_lexer_add_token(yylloc, yytext, yyleng, state);
return IDENTIFIER;
}
gmx::SelectionParserSymbol::SymbolType symtype = symbol->type();
/* For method symbols, we need some extra processing. */
if (symtype == gmx::SelectionParserSymbol::MethodSymbol)
{
return init_method_token(yylval, yylloc, symbol, state->prev_pos_kw > 0, state);
}
_gmx_sel_lexer_add_token(yylloc, symbol->name().c_str(), -1, state);
/* Reserved symbols should have been caught earlier */
if (symtype == gmx::SelectionParserSymbol::ReservedSymbol)
{
GMX_THROW(gmx::InternalError(gmx::formatString(
"Mismatch between tokenizer and reserved symbol table (for '%s')",
symbol->name().c_str())));
}
/* For variable symbols, return the type of the variable value */
if (symtype == gmx::SelectionParserSymbol::VariableSymbol)
{
const gmx::SelectionTreeElementPointer &var = symbol->variableValue();
/* Return simple tokens for constant variables */
if (var->type == SEL_CONST)
{
switch (var->v.type)
{
case INT_VALUE:
yylval->i = var->v.u.i[0];
return TOK_INT;
case REAL_VALUE:
yylval->r = var->v.u.r[0];
return TOK_REAL;
case POS_VALUE:
break;
default:
GMX_THROW(gmx::InternalError("Unsupported variable type"));
}
}
yylval->sel = new gmx::SelectionTreeElementPointer(var);
switch (var->v.type)
{
case INT_VALUE: return VARIABLE_NUMERIC;
case REAL_VALUE: return VARIABLE_NUMERIC;
case POS_VALUE: return VARIABLE_POS;
case GROUP_VALUE: return VARIABLE_GROUP;
default:
delete yylval->sel;
GMX_THROW(gmx::InternalError("Unsupported variable type"));
}
/* This position should not be reached. */
}
/* For position symbols, we need to return KEYWORD_POS, but we also need
* some additional handling. */
if (symtype == gmx::SelectionParserSymbol::PositionSymbol)
{
state->bMatchOf = true;
yylval->str = gmx_strdup(symbol->name().c_str());
state->prev_pos_kw = 2;
return KEYWORD_POS;
}
/* Should not be reached */
return INVALID;
}
static void fill_ft_ind(int nft, int *ft, t_idef *idef,
int ft_ind[], char *grpnames[])
{
char buf[125];
int i, f, ftype, ind = 0;
/* Loop over all the function types in the topology */
for (i = 0; (i < idef->ntypes); i++)
{
ft_ind[i] = -1;
/* Check all the selected function types */
for (f = 0; f < nft; f++)
{
ftype = ft[f];
if (idef->functype[i] == ftype)
{
ft_ind[i] = ind;
switch (ftype)
{
case F_ANGLES:
sprintf(buf, "Theta=%.1f_%.2f", idef->iparams[i].harmonic.rA,
idef->iparams[i].harmonic.krA);
break;
case F_G96ANGLES:
sprintf(buf, "Cos_th=%.1f_%.2f", idef->iparams[i].harmonic.rA,
idef->iparams[i].harmonic.krA);
break;
case F_UREY_BRADLEY:
sprintf(buf, "UB_th=%.1f_%.2f2f", idef->iparams[i].u_b.thetaA,
idef->iparams[i].u_b.kthetaA);
break;
case F_QUARTIC_ANGLES:
sprintf(buf, "Q_th=%.1f_%.2f_%.2f", idef->iparams[i].qangle.theta,
idef->iparams[i].qangle.c[0], idef->iparams[i].qangle.c[1]);
break;
case F_TABANGLES:
sprintf(buf, "Table=%d_%.2f", idef->iparams[i].tab.table,
idef->iparams[i].tab.kA);
break;
case F_PDIHS:
sprintf(buf, "Phi=%.1f_%d_%.2f", idef->iparams[i].pdihs.phiA,
idef->iparams[i].pdihs.mult, idef->iparams[i].pdihs.cpA);
break;
case F_IDIHS:
sprintf(buf, "Xi=%.1f_%.2f", idef->iparams[i].harmonic.rA,
idef->iparams[i].harmonic.krA);
break;
case F_RBDIHS:
sprintf(buf, "RB-A1=%.2f", idef->iparams[i].rbdihs.rbcA[1]);
break;
case F_RESTRANGLES:
sprintf(buf, "Theta=%.1f_%.2f", idef->iparams[i].harmonic.rA,
idef->iparams[i].harmonic.krA);
break;
case F_RESTRDIHS:
sprintf(buf, "Theta=%.1f_%.2f", idef->iparams[i].harmonic.rA,
idef->iparams[i].harmonic.krA);
break;
case F_CBTDIHS:
sprintf(buf, "CBT-A1=%.2f", idef->iparams[i].cbtdihs.cbtcA[1]);
break;
default:
gmx_fatal(FARGS, "Unsupported function type '%s' selected",
interaction_function[ftype].longname);
}
grpnames[ind] = gmx_strdup(buf);
ind++;
}
}
}
}
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);
}
}
}
}
void gmx_log_open(const char *lognm, const t_commrec *cr, gmx_bool bMasterOnly,
gmx_bool bAppendFiles, FILE** fplog)
{
int len, pid;
char buf[256], host[256];
time_t t;
char timebuf[STRLEN];
FILE *fp = *fplog;
char *tmpnm;
debug_gmx();
/* Communicate the filename for logfile */
if (cr->nnodes > 1 && !bMasterOnly
#ifdef GMX_THREAD_MPI
/* With thread MPI the non-master log files are opened later
* when the files names are already known on all nodes.
*/
&& FALSE
#endif
)
{
if (MASTER(cr))
{
len = strlen(lognm) + 1;
}
gmx_bcast(sizeof(len), &len, cr);
if (!MASTER(cr))
{
snew(tmpnm, len+8);
}
else
{
tmpnm = gmx_strdup(lognm);
}
gmx_bcast(len*sizeof(*tmpnm), tmpnm, cr);
}
else
{
tmpnm = gmx_strdup(lognm);
}
debug_gmx();
if (!bMasterOnly && !MASTER(cr))
{
/* Since log always ends with '.log' let's use this info */
par_fn(tmpnm, efLOG, cr, FALSE, !bMasterOnly, buf, 255);
fp = gmx_fio_fopen(buf, bAppendFiles ? "a+" : "w+" );
}
else if (!bAppendFiles)
{
fp = gmx_fio_fopen(tmpnm, bAppendFiles ? "a+" : "w+" );
}
sfree(tmpnm);
gmx_fatal_set_log_file(fp);
/* Get some machine parameters */
gmx_gethostname(host, 256);
time(&t);
#ifndef NO_GETPID
# ifdef GMX_NATIVE_WINDOWS
pid = _getpid();
# else
pid = getpid();
# endif
#else
pid = 0;
#endif
if (bAppendFiles)
{
fprintf(fp,
"\n"
"\n"
"-----------------------------------------------------------\n"
"Restarting from checkpoint, appending to previous log file.\n"
"\n"
);
}
gmx_ctime_r(&t, timebuf, STRLEN);
fprintf(fp,
"Log file opened on %s"
"Host: %s pid: %d rank ID: %d number of ranks: %d\n",
timebuf, host, pid, cr->nodeid, cr->nnodes);
try
{
gmx::BinaryInformationSettings settings;
settings.extendedInfo(true);
settings.copyright(!bAppendFiles);
gmx::printBinaryInformation(fp, gmx::getProgramContext(), settings);
}
GMX_CATCH_ALL_AND_EXIT_WITH_FATAL_ERROR;
fprintf(fp, "\n\n");
fflush(fp);
debug_gmx();
*fplog = fp;
}
t_mdebin *init_mdebin(ener_file_t fp_ene,
const gmx_mtop_t *mtop,
const t_inputrec *ir,
FILE *fp_dhdl)
{
const char *ener_nm[F_NRE];
static const char *vir_nm[] = {
"Vir-XX", "Vir-XY", "Vir-XZ",
"Vir-YX", "Vir-YY", "Vir-YZ",
"Vir-ZX", "Vir-ZY", "Vir-ZZ"
};
static const char *sv_nm[] = {
"ShakeVir-XX", "ShakeVir-XY", "ShakeVir-XZ",
"ShakeVir-YX", "ShakeVir-YY", "ShakeVir-YZ",
"ShakeVir-ZX", "ShakeVir-ZY", "ShakeVir-ZZ"
};
static const char *fv_nm[] = {
"ForceVir-XX", "ForceVir-XY", "ForceVir-XZ",
"ForceVir-YX", "ForceVir-YY", "ForceVir-YZ",
"ForceVir-ZX", "ForceVir-ZY", "ForceVir-ZZ"
};
static const char *pres_nm[] = {
"Pres-XX", "Pres-XY", "Pres-XZ",
"Pres-YX", "Pres-YY", "Pres-YZ",
"Pres-ZX", "Pres-ZY", "Pres-ZZ"
};
static const char *surft_nm[] = {
"#Surf*SurfTen"
};
static const char *mu_nm[] = {
"Mu-X", "Mu-Y", "Mu-Z"
};
static const char *vcos_nm[] = {
"2CosZ*Vel-X"
};
static const char *visc_nm[] = {
"1/Viscosity"
};
static const char *baro_nm[] = {
"Barostat"
};
char **grpnms;
const gmx_groups_t *groups;
char **gnm;
char buf[256];
const char *bufi;
t_mdebin *md;
int i, j, ni, nj, n, k, kk, ncon, nset;
gmx_bool bBHAM, b14;
snew(md, 1);
if (EI_DYNAMICS(ir->eI))
{
md->delta_t = ir->delta_t;
}
else
{
md->delta_t = 0;
}
groups = &mtop->groups;
bBHAM = (mtop->ffparams.functype[0] == F_BHAM);
b14 = (gmx_mtop_ftype_count(mtop, F_LJ14) > 0 ||
gmx_mtop_ftype_count(mtop, F_LJC14_Q) > 0);
ncon = gmx_mtop_ftype_count(mtop, F_CONSTR);
nset = gmx_mtop_ftype_count(mtop, F_SETTLE);
md->bConstr = (ncon > 0 || nset > 0);
md->bConstrVir = FALSE;
if (md->bConstr)
{
if (ncon > 0 && ir->eConstrAlg == econtLINCS)
{
md->nCrmsd = 1;
}
md->bConstrVir = (getenv("GMX_CONSTRAINTVIR") != NULL);
}
else
{
md->nCrmsd = 0;
}
/* Energy monitoring */
for (i = 0; i < egNR; i++)
{
md->bEInd[i] = FALSE;
}
for (i = 0; i < F_NRE; i++)
{
md->bEner[i] = FALSE;
if (i == F_LJ)
{
md->bEner[i] = !bBHAM;
}
else if (i == F_BHAM)
{
md->bEner[i] = bBHAM;
}
else if (i == F_EQM)
{
md->bEner[i] = ir->bQMMM;
}
else if (i == F_RF_EXCL)
{
md->bEner[i] = (EEL_RF(ir->coulombtype) && ir->cutoff_scheme == ecutsGROUP);
}
else if (i == F_COUL_RECIP)
{
md->bEner[i] = EEL_FULL(ir->coulombtype);
}
else if (i == F_LJ_RECIP)
{
md->bEner[i] = EVDW_PME(ir->vdwtype);
}
else if (i == F_LJ14)
{
md->bEner[i] = b14;
}
else if (i == F_COUL14)
{
md->bEner[i] = b14;
}
else if (i == F_LJC14_Q || i == F_LJC_PAIRS_NB)
{
md->bEner[i] = FALSE;
}
else if ((i == F_DVDL_COUL && ir->fepvals->separate_dvdl[efptCOUL]) ||
(i == F_DVDL_VDW && ir->fepvals->separate_dvdl[efptVDW]) ||
(i == F_DVDL_BONDED && ir->fepvals->separate_dvdl[efptBONDED]) ||
(i == F_DVDL_RESTRAINT && ir->fepvals->separate_dvdl[efptRESTRAINT]) ||
(i == F_DKDL && ir->fepvals->separate_dvdl[efptMASS]) ||
(i == F_DVDL && ir->fepvals->separate_dvdl[efptFEP]))
{
md->bEner[i] = (ir->efep != efepNO);
}
else if ((interaction_function[i].flags & IF_VSITE) ||
(i == F_CONSTR) || (i == F_CONSTRNC) || (i == F_SETTLE))
{
md->bEner[i] = FALSE;
}
else if ((i == F_COUL_SR) || (i == F_EPOT) || (i == F_PRES) || (i == F_EQM))
{
md->bEner[i] = TRUE;
}
else if ((i == F_GBPOL) && ir->implicit_solvent == eisGBSA)
{
md->bEner[i] = TRUE;
}
else if ((i == F_NPSOLVATION) && ir->implicit_solvent == eisGBSA && (ir->sa_algorithm != esaNO))
{
md->bEner[i] = TRUE;
}
else if ((i == F_GB12) || (i == F_GB13) || (i == F_GB14))
{
md->bEner[i] = FALSE;
}
else if ((i == F_ETOT) || (i == F_EKIN) || (i == F_TEMP))
{
md->bEner[i] = EI_DYNAMICS(ir->eI);
}
else if (i == F_DISPCORR || i == F_PDISPCORR)
{
md->bEner[i] = (ir->eDispCorr != edispcNO);
}
else if (i == F_DISRESVIOL)
{
md->bEner[i] = (gmx_mtop_ftype_count(mtop, F_DISRES) > 0);
}
else if (i == F_ORIRESDEV)
{
md->bEner[i] = (gmx_mtop_ftype_count(mtop, F_ORIRES) > 0);
}
else if (i == F_CONNBONDS)
{
md->bEner[i] = FALSE;
}
else if (i == F_COM_PULL)
{
md->bEner[i] = (ir->bPull && pull_have_potential(ir->pull_work));
}
else if (i == F_ECONSERVED)
{
md->bEner[i] = ((ir->etc == etcNOSEHOOVER || ir->etc == etcVRESCALE) &&
(ir->epc == epcNO || ir->epc == epcMTTK));
}
else
{
md->bEner[i] = (gmx_mtop_ftype_count(mtop, i) > 0);
}
}
md->f_nre = 0;
for (i = 0; i < F_NRE; i++)
{
if (md->bEner[i])
{
ener_nm[md->f_nre] = interaction_function[i].longname;
md->f_nre++;
}
}
md->epc = ir->epc;
md->bDiagPres = !TRICLINIC(ir->ref_p);
md->ref_p = (ir->ref_p[XX][XX]+ir->ref_p[YY][YY]+ir->ref_p[ZZ][ZZ])/DIM;
md->bTricl = TRICLINIC(ir->compress) || TRICLINIC(ir->deform);
md->bDynBox = inputrecDynamicBox(ir);
md->etc = ir->etc;
md->bNHC_trotter = inputrecNvtTrotter(ir);
md->bPrintNHChains = ir->bPrintNHChains;
md->bMTTK = (inputrecNptTrotter(ir) || inputrecNphTrotter(ir));
md->bMu = inputrecNeedMutot(ir);
md->ebin = mk_ebin();
/* Pass NULL for unit to let get_ebin_space determine the units
* for interaction_function[i].longname
*/
md->ie = get_ebin_space(md->ebin, md->f_nre, ener_nm, NULL);
if (md->nCrmsd)
{
/* This should be called directly after the call for md->ie,
* such that md->iconrmsd follows directly in the list.
*/
md->iconrmsd = get_ebin_space(md->ebin, md->nCrmsd, conrmsd_nm, "");
}
if (md->bDynBox)
{
md->ib = get_ebin_space(md->ebin,
md->bTricl ? NTRICLBOXS : NBOXS,
md->bTricl ? tricl_boxs_nm : boxs_nm,
unit_length);
md->ivol = get_ebin_space(md->ebin, 1, vol_nm, unit_volume);
md->idens = get_ebin_space(md->ebin, 1, dens_nm, unit_density_SI);
if (md->bDiagPres)
{
md->ipv = get_ebin_space(md->ebin, 1, pv_nm, unit_energy);
md->ienthalpy = get_ebin_space(md->ebin, 1, enthalpy_nm, unit_energy);
}
}
if (md->bConstrVir)
{
md->isvir = get_ebin_space(md->ebin, asize(sv_nm), sv_nm, unit_energy);
md->ifvir = get_ebin_space(md->ebin, asize(fv_nm), fv_nm, unit_energy);
}
md->ivir = get_ebin_space(md->ebin, asize(vir_nm), vir_nm, unit_energy);
md->ipres = get_ebin_space(md->ebin, asize(pres_nm), pres_nm, unit_pres_bar);
md->isurft = get_ebin_space(md->ebin, asize(surft_nm), surft_nm,
unit_surft_bar);
if (md->epc == epcPARRINELLORAHMAN || md->epc == epcMTTK)
{
md->ipc = get_ebin_space(md->ebin, md->bTricl ? 6 : 3,
boxvel_nm, unit_vel);
}
if (md->bMu)
{
md->imu = get_ebin_space(md->ebin, asize(mu_nm), mu_nm, unit_dipole_D);
}
if (ir->cos_accel != 0)
{
md->ivcos = get_ebin_space(md->ebin, asize(vcos_nm), vcos_nm, unit_vel);
md->ivisc = get_ebin_space(md->ebin, asize(visc_nm), visc_nm,
unit_invvisc_SI);
}
/* Energy monitoring */
for (i = 0; i < egNR; i++)
{
md->bEInd[i] = FALSE;
}
md->bEInd[egCOULSR] = TRUE;
md->bEInd[egLJSR ] = TRUE;
if (bBHAM)
{
md->bEInd[egLJSR] = FALSE;
md->bEInd[egBHAMSR] = TRUE;
}
if (b14)
{
md->bEInd[egLJ14] = TRUE;
md->bEInd[egCOUL14] = TRUE;
}
md->nEc = 0;
for (i = 0; (i < egNR); i++)
{
if (md->bEInd[i])
{
md->nEc++;
}
}
n = groups->grps[egcENER].nr;
md->nEg = n;
md->nE = (n*(n+1))/2;
snew(md->igrp, md->nE);
if (md->nE > 1)
{
n = 0;
snew(gnm, md->nEc);
for (k = 0; (k < md->nEc); k++)
{
snew(gnm[k], STRLEN);
}
for (i = 0; (i < groups->grps[egcENER].nr); i++)
{
ni = groups->grps[egcENER].nm_ind[i];
for (j = i; (j < groups->grps[egcENER].nr); j++)
{
nj = groups->grps[egcENER].nm_ind[j];
for (k = kk = 0; (k < egNR); k++)
{
if (md->bEInd[k])
{
sprintf(gnm[kk], "%s:%s-%s", egrp_nm[k],
*(groups->grpname[ni]), *(groups->grpname[nj]));
kk++;
}
}
md->igrp[n] = get_ebin_space(md->ebin, md->nEc,
(const char **)gnm, unit_energy);
n++;
}
}
for (k = 0; (k < md->nEc); k++)
{
sfree(gnm[k]);
}
sfree(gnm);
if (n != md->nE)
{
gmx_incons("Number of energy terms wrong");
}
}
md->nTC = groups->grps[egcTC].nr;
md->nNHC = ir->opts.nhchainlength; /* shorthand for number of NH chains */
if (md->bMTTK)
{
md->nTCP = 1; /* assume only one possible coupling system for barostat
for now */
}
else
{
md->nTCP = 0;
}
if (md->etc == etcNOSEHOOVER)
{
if (md->bNHC_trotter)
{
md->mde_n = 2*md->nNHC*md->nTC;
}
else
{
md->mde_n = 2*md->nTC;
}
if (md->epc == epcMTTK)
{
md->mdeb_n = 2*md->nNHC*md->nTCP;
}
}
else
{
md->mde_n = md->nTC;
md->mdeb_n = 0;
}
snew(md->tmp_r, md->mde_n);
snew(md->tmp_v, md->mde_n);
snew(md->grpnms, md->mde_n);
grpnms = md->grpnms;
for (i = 0; (i < md->nTC); i++)
{
ni = groups->grps[egcTC].nm_ind[i];
sprintf(buf, "T-%s", *(groups->grpname[ni]));
grpnms[i] = gmx_strdup(buf);
}
md->itemp = get_ebin_space(md->ebin, md->nTC, (const char **)grpnms,
unit_temp_K);
if (md->etc == etcNOSEHOOVER)
{
if (md->bPrintNHChains)
{
if (md->bNHC_trotter)
{
for (i = 0; (i < md->nTC); i++)
{
ni = groups->grps[egcTC].nm_ind[i];
bufi = *(groups->grpname[ni]);
for (j = 0; (j < md->nNHC); j++)
{
sprintf(buf, "Xi-%d-%s", j, bufi);
grpnms[2*(i*md->nNHC+j)] = gmx_strdup(buf);
sprintf(buf, "vXi-%d-%s", j, bufi);
grpnms[2*(i*md->nNHC+j)+1] = gmx_strdup(buf);
}
}
md->itc = get_ebin_space(md->ebin, md->mde_n,
(const char **)grpnms, unit_invtime);
if (md->bMTTK)
{
for (i = 0; (i < md->nTCP); i++)
{
bufi = baro_nm[0]; /* All barostat DOF's together for now. */
for (j = 0; (j < md->nNHC); j++)
{
sprintf(buf, "Xi-%d-%s", j, bufi);
grpnms[2*(i*md->nNHC+j)] = gmx_strdup(buf);
sprintf(buf, "vXi-%d-%s", j, bufi);
grpnms[2*(i*md->nNHC+j)+1] = gmx_strdup(buf);
}
}
md->itcb = get_ebin_space(md->ebin, md->mdeb_n,
(const char **)grpnms, unit_invtime);
}
}
else
{
for (i = 0; (i < md->nTC); i++)
{
ni = groups->grps[egcTC].nm_ind[i];
bufi = *(groups->grpname[ni]);
sprintf(buf, "Xi-%s", bufi);
grpnms[2*i] = gmx_strdup(buf);
sprintf(buf, "vXi-%s", bufi);
grpnms[2*i+1] = gmx_strdup(buf);
}
md->itc = get_ebin_space(md->ebin, md->mde_n,
(const char **)grpnms, unit_invtime);
}
}
}
else if (md->etc == etcBERENDSEN || md->etc == etcYES ||
md->etc == etcVRESCALE)
{
for (i = 0; (i < md->nTC); i++)
{
ni = groups->grps[egcTC].nm_ind[i];
sprintf(buf, "Lamb-%s", *(groups->grpname[ni]));
grpnms[i] = gmx_strdup(buf);
}
md->itc = get_ebin_space(md->ebin, md->mde_n, (const char **)grpnms, "");
}
sfree(grpnms);
md->nU = groups->grps[egcACC].nr;
if (md->nU > 1)
{
snew(grpnms, 3*md->nU);
for (i = 0; (i < md->nU); i++)
{
ni = groups->grps[egcACC].nm_ind[i];
sprintf(buf, "Ux-%s", *(groups->grpname[ni]));
grpnms[3*i+XX] = gmx_strdup(buf);
sprintf(buf, "Uy-%s", *(groups->grpname[ni]));
grpnms[3*i+YY] = gmx_strdup(buf);
sprintf(buf, "Uz-%s", *(groups->grpname[ni]));
grpnms[3*i+ZZ] = gmx_strdup(buf);
}
md->iu = get_ebin_space(md->ebin, 3*md->nU, (const char **)grpnms, unit_vel);
sfree(grpnms);
}
if (fp_ene)
{
do_enxnms(fp_ene, &md->ebin->nener, &md->ebin->enm);
}
md->print_grpnms = NULL;
/* check whether we're going to write dh histograms */
md->dhc = NULL;
if (ir->fepvals->separate_dhdl_file == esepdhdlfileNO)
{
/* Currently dh histograms are only written with dynamics */
if (EI_DYNAMICS(ir->eI))
{
snew(md->dhc, 1);
mde_delta_h_coll_init(md->dhc, ir);
}
md->fp_dhdl = NULL;
snew(md->dE, ir->fepvals->n_lambda);
}
else
{
md->fp_dhdl = fp_dhdl;
snew(md->dE, ir->fepvals->n_lambda);
}
if (ir->bSimTemp)
{
int i;
snew(md->temperatures, ir->fepvals->n_lambda);
for (i = 0; i < ir->fepvals->n_lambda; i++)
{
md->temperatures[i] = ir->simtempvals->temperatures[i];
}
}
return md;
}
extern FILE *open_dhdl(const char *filename, const t_inputrec *ir,
const gmx_output_env_t *oenv)
{
FILE *fp;
const char *dhdl = "dH/d\\lambda", *deltag = "\\DeltaH", *lambda = "\\lambda",
*lambdastate = "\\lambda state";
char title[STRLEN], label_x[STRLEN], label_y[STRLEN];
int i, nps, nsets, nsets_de, nsetsbegin;
int n_lambda_terms = 0;
t_lambda *fep = ir->fepvals; /* for simplicity */
t_expanded *expand = ir->expandedvals;
char **setname;
char buf[STRLEN], lambda_vec_str[STRLEN], lambda_name_str[STRLEN];
int bufplace = 0;
int nsets_dhdl = 0;
int s = 0;
int nsetsextend;
gmx_bool write_pV = FALSE;
/* count the number of different lambda terms */
for (i = 0; i < efptNR; i++)
{
if (fep->separate_dvdl[i])
{
n_lambda_terms++;
}
}
if (fep->n_lambda == 0)
{
sprintf(title, "%s", dhdl);
sprintf(label_x, "Time (ps)");
sprintf(label_y, "%s (%s %s)",
dhdl, unit_energy, "[\\lambda]\\S-1\\N");
}
else
{
sprintf(title, "%s and %s", dhdl, deltag);
sprintf(label_x, "Time (ps)");
sprintf(label_y, "%s and %s (%s %s)",
dhdl, deltag, unit_energy, "[\\8l\\4]\\S-1\\N");
}
fp = gmx_fio_fopen(filename, "w+");
xvgr_header(fp, title, label_x, label_y, exvggtXNY, oenv);
if (!(ir->bSimTemp))
{
bufplace = sprintf(buf, "T = %g (K) ",
ir->opts.ref_t[0]);
}
if ((ir->efep != efepSLOWGROWTH) && (ir->efep != efepEXPANDED))
{
if ( (fep->init_lambda >= 0) && (n_lambda_terms == 1 ))
{
/* compatibility output */
sprintf(&(buf[bufplace]), "%s = %.4f", lambda, fep->init_lambda);
}
else
{
print_lambda_vector(fep, fep->init_fep_state, TRUE, FALSE,
lambda_vec_str);
print_lambda_vector(fep, fep->init_fep_state, TRUE, TRUE,
lambda_name_str);
sprintf(&(buf[bufplace]), "%s %d: %s = %s",
lambdastate, fep->init_fep_state,
lambda_name_str, lambda_vec_str);
}
}
xvgr_subtitle(fp, buf, oenv);
nsets_dhdl = 0;
if (fep->dhdl_derivatives == edhdlderivativesYES)
{
nsets_dhdl = n_lambda_terms;
}
/* count the number of delta_g states */
nsets_de = fep->lambda_stop_n - fep->lambda_start_n;
nsets = nsets_dhdl + nsets_de; /* dhdl + fep differences */
if (fep->n_lambda > 0 && (expand->elmcmove > elmcmoveNO))
{
nsets += 1; /*add fep state for expanded ensemble */
}
if (fep->edHdLPrintEnergy != edHdLPrintEnergyNO)
{
nsets += 1; /* add energy to the dhdl as well */
}
nsetsextend = nsets;
if ((ir->epc != epcNO) && (fep->n_lambda > 0) && (fep->init_lambda < 0))
{
nsetsextend += 1; /* for PV term, other terms possible if required for
the reduced potential (only needed with foreign
lambda, and only output when init_lambda is not
set in order to maintain compatibility of the
dhdl.xvg file) */
write_pV = TRUE;
}
snew(setname, nsetsextend);
if (expand->elmcmove > elmcmoveNO)
{
/* state for the fep_vals, if we have alchemical sampling */
sprintf(buf, "%s", "Thermodynamic state");
setname[s] = gmx_strdup(buf);
s += 1;
}
if (fep->edHdLPrintEnergy != edHdLPrintEnergyNO)
{
switch (fep->edHdLPrintEnergy)
{
case edHdLPrintEnergyPOTENTIAL:
sprintf(buf, "%s (%s)", "Potential Energy", unit_energy);
break;
case edHdLPrintEnergyTOTAL:
case edHdLPrintEnergyYES:
default:
sprintf(buf, "%s (%s)", "Total Energy", unit_energy);
}
setname[s] = gmx_strdup(buf);
s += 1;
}
if (fep->dhdl_derivatives == edhdlderivativesYES)
{
for (i = 0; i < efptNR; i++)
{
if (fep->separate_dvdl[i])
{
if ( (fep->init_lambda >= 0) && (n_lambda_terms == 1 ))
{
/* compatibility output */
sprintf(buf, "%s %s %.4f", dhdl, lambda, fep->init_lambda);
}
else
{
double lam = fep->init_lambda;
if (fep->init_lambda < 0)
{
lam = fep->all_lambda[i][fep->init_fep_state];
}
sprintf(buf, "%s %s = %.4f", dhdl, efpt_singular_names[i],
lam);
}
setname[s] = gmx_strdup(buf);
s += 1;
}
}
}
if (fep->n_lambda > 0)
{
/* g_bar has to determine the lambda values used in this simulation
* from this xvg legend.
*/
if (expand->elmcmove > elmcmoveNO)
{
nsetsbegin = 1; /* for including the expanded ensemble */
}
else
{
nsetsbegin = 0;
}
if (fep->edHdLPrintEnergy != edHdLPrintEnergyNO)
{
nsetsbegin += 1;
}
nsetsbegin += nsets_dhdl;
for (i = fep->lambda_start_n; i < fep->lambda_stop_n; i++)
{
print_lambda_vector(fep, i, FALSE, FALSE, lambda_vec_str);
if ( (fep->init_lambda >= 0) && (n_lambda_terms == 1 ))
{
/* for compatible dhdl.xvg files */
nps = sprintf(buf, "%s %s %s", deltag, lambda, lambda_vec_str);
}
else
{
nps = sprintf(buf, "%s %s to %s", deltag, lambda, lambda_vec_str);
}
if (ir->bSimTemp)
{
/* print the temperature for this state if doing simulated annealing */
sprintf(&buf[nps], "T = %g (%s)",
ir->simtempvals->temperatures[s-(nsetsbegin)],
unit_temp_K);
}
setname[s] = gmx_strdup(buf);
s++;
}
if (write_pV)
{
sprintf(buf, "pV (%s)", unit_energy);
setname[nsetsextend-1] = gmx_strdup(buf); /* the first entry after
nsets */
}
xvgr_legend(fp, nsetsextend, (const char **)setname, oenv);
for (s = 0; s < nsetsextend; s++)
{
sfree(setname[s]);
}
sfree(setname);
}
return fp;
}
void print_ebin(ener_file_t fp_ene, gmx_bool bEne, gmx_bool bDR, gmx_bool bOR,
FILE *log,
gmx_int64_t step, double time,
int mode,
t_mdebin *md, t_fcdata *fcd,
gmx_groups_t *groups, t_grpopts *opts)
{
/*static char **grpnms=NULL;*/
char buf[246];
int i, j, n, ni, nj, b;
int ndisre = 0;
real *disre_rm3tav, *disre_rt;
/* these are for the old-style blocks (1 subblock, only reals), because
there can be only one per ID for these */
int nr[enxNR];
int id[enxNR];
real *block[enxNR];
t_enxframe fr;
switch (mode)
{
case eprNORMAL:
init_enxframe(&fr);
fr.t = time;
fr.step = step;
fr.nsteps = md->ebin->nsteps;
fr.dt = md->delta_t;
fr.nsum = md->ebin->nsum;
fr.nre = (bEne) ? md->ebin->nener : 0;
fr.ener = md->ebin->e;
ndisre = bDR ? fcd->disres.npair : 0;
disre_rm3tav = fcd->disres.rm3tav;
disre_rt = fcd->disres.rt;
/* Optional additional old-style (real-only) blocks. */
for (i = 0; i < enxNR; i++)
{
nr[i] = 0;
}
if (fcd->orires.nr > 0 && bOR)
{
diagonalize_orires_tensors(&(fcd->orires));
nr[enxOR] = fcd->orires.nr;
block[enxOR] = fcd->orires.otav;
id[enxOR] = enxOR;
nr[enxORI] = (fcd->orires.oinsl != fcd->orires.otav) ?
fcd->orires.nr : 0;
block[enxORI] = fcd->orires.oinsl;
id[enxORI] = enxORI;
nr[enxORT] = fcd->orires.nex*12;
block[enxORT] = fcd->orires.eig;
id[enxORT] = enxORT;
}
/* whether we are going to wrte anything out: */
if (fr.nre || ndisre || nr[enxOR] || nr[enxORI])
{
/* the old-style blocks go first */
fr.nblock = 0;
for (i = 0; i < enxNR; i++)
{
if (nr[i] > 0)
{
fr.nblock = i + 1;
}
}
add_blocks_enxframe(&fr, fr.nblock);
for (b = 0; b < fr.nblock; b++)
{
add_subblocks_enxblock(&(fr.block[b]), 1);
fr.block[b].id = id[b];
fr.block[b].sub[0].nr = nr[b];
#if !GMX_DOUBLE
fr.block[b].sub[0].type = xdr_datatype_float;
fr.block[b].sub[0].fval = block[b];
#else
fr.block[b].sub[0].type = xdr_datatype_double;
fr.block[b].sub[0].dval = block[b];
#endif
}
/* check for disre block & fill it. */
if (ndisre > 0)
{
int db = fr.nblock;
fr.nblock += 1;
add_blocks_enxframe(&fr, fr.nblock);
add_subblocks_enxblock(&(fr.block[db]), 2);
fr.block[db].id = enxDISRE;
fr.block[db].sub[0].nr = ndisre;
fr.block[db].sub[1].nr = ndisre;
#if !GMX_DOUBLE
fr.block[db].sub[0].type = xdr_datatype_float;
fr.block[db].sub[1].type = xdr_datatype_float;
fr.block[db].sub[0].fval = disre_rt;
fr.block[db].sub[1].fval = disre_rm3tav;
#else
fr.block[db].sub[0].type = xdr_datatype_double;
fr.block[db].sub[1].type = xdr_datatype_double;
fr.block[db].sub[0].dval = disre_rt;
fr.block[db].sub[1].dval = disre_rm3tav;
#endif
}
/* here we can put new-style blocks */
/* Free energy perturbation blocks */
if (md->dhc)
{
mde_delta_h_coll_handle_block(md->dhc, &fr, fr.nblock);
}
/* we can now free & reset the data in the blocks */
if (md->dhc)
{
mde_delta_h_coll_reset(md->dhc);
}
/* do the actual I/O */
do_enx(fp_ene, &fr);
if (fr.nre)
{
/* We have stored the sums, so reset the sum history */
reset_ebin_sums(md->ebin);
}
}
free_enxframe(&fr);
break;
case eprAVER:
if (log)
{
pprint(log, "A V E R A G E S", md);
}
break;
case eprRMS:
if (log)
{
pprint(log, "R M S - F L U C T U A T I O N S", md);
}
break;
default:
gmx_fatal(FARGS, "Invalid print mode (%d)", mode);
}
if (log)
{
for (i = 0; i < opts->ngtc; i++)
{
if (opts->annealing[i] != eannNO)
{
fprintf(log, "Current ref_t for group %s: %8.1f\n",
*(groups->grpname[groups->grps[egcTC].nm_ind[i]]),
opts->ref_t[i]);
}
}
if (mode == eprNORMAL && fcd->orires.nr > 0)
{
print_orires_log(log, &(fcd->orires));
}
fprintf(log, " Energies (%s)\n", unit_energy);
pr_ebin(log, md->ebin, md->ie, md->f_nre+md->nCrmsd, 5, mode, TRUE);
fprintf(log, "\n");
if (mode == eprAVER)
{
if (md->bDynBox)
{
pr_ebin(log, md->ebin, md->ib, md->bTricl ? NTRICLBOXS : NBOXS, 5,
mode, TRUE);
fprintf(log, "\n");
}
if (md->bConstrVir)
{
fprintf(log, " Constraint Virial (%s)\n", unit_energy);
pr_ebin(log, md->ebin, md->isvir, 9, 3, mode, FALSE);
fprintf(log, "\n");
fprintf(log, " Force Virial (%s)\n", unit_energy);
pr_ebin(log, md->ebin, md->ifvir, 9, 3, mode, FALSE);
fprintf(log, "\n");
}
fprintf(log, " Total Virial (%s)\n", unit_energy);
pr_ebin(log, md->ebin, md->ivir, 9, 3, mode, FALSE);
fprintf(log, "\n");
fprintf(log, " Pressure (%s)\n", unit_pres_bar);
pr_ebin(log, md->ebin, md->ipres, 9, 3, mode, FALSE);
fprintf(log, "\n");
if (md->bMu)
{
fprintf(log, " Total Dipole (%s)\n", unit_dipole_D);
pr_ebin(log, md->ebin, md->imu, 3, 3, mode, FALSE);
fprintf(log, "\n");
}
if (md->nE > 1)
{
if (md->print_grpnms == NULL)
{
snew(md->print_grpnms, md->nE);
n = 0;
for (i = 0; (i < md->nEg); i++)
{
ni = groups->grps[egcENER].nm_ind[i];
for (j = i; (j < md->nEg); j++)
{
nj = groups->grps[egcENER].nm_ind[j];
sprintf(buf, "%s-%s", *(groups->grpname[ni]),
*(groups->grpname[nj]));
md->print_grpnms[n++] = gmx_strdup(buf);
}
}
}
sprintf(buf, "Epot (%s)", unit_energy);
fprintf(log, "%15s ", buf);
for (i = 0; (i < egNR); i++)
{
if (md->bEInd[i])
{
fprintf(log, "%12s ", egrp_nm[i]);
}
}
fprintf(log, "\n");
for (i = 0; (i < md->nE); i++)
{
fprintf(log, "%15s", md->print_grpnms[i]);
pr_ebin(log, md->ebin, md->igrp[i], md->nEc, md->nEc, mode,
FALSE);
}
fprintf(log, "\n");
}
if (md->nTC > 1)
{
pr_ebin(log, md->ebin, md->itemp, md->nTC, 4, mode, TRUE);
fprintf(log, "\n");
}
if (md->nU > 1)
{
fprintf(log, "%15s %12s %12s %12s\n",
"Group", "Ux", "Uy", "Uz");
for (i = 0; (i < md->nU); i++)
{
ni = groups->grps[egcACC].nm_ind[i];
fprintf(log, "%15s", *groups->grpname[ni]);
pr_ebin(log, md->ebin, md->iu+3*i, 3, 3, mode, FALSE);
}
fprintf(log, "\n");
}
}
}
}
static void update_topol(const char *topinout, int p_num, int n_num,
const char *p_name, const char *n_name, char *grpname)
{
FILE *fpin, *fpout;
char buf[STRLEN], buf2[STRLEN], *temp, **mol_line = NULL;
int line, i, nmol_line, sol_line, nsol_last;
gmx_bool bMolecules;
char temporary_filename[STRLEN];
printf("\nProcessing topology\n");
fpin = gmx_ffopen(topinout, "r");
std::strncpy(temporary_filename, "temp.topXXXXXX", STRLEN);
fpout = gmx_fopen_temporary(temporary_filename);
line = 0;
bMolecules = FALSE;
nmol_line = 0;
sol_line = -1;
nsol_last = -1;
while (fgets(buf, STRLEN, fpin))
{
line++;
std::strcpy(buf2, buf);
if ((temp = std::strchr(buf2, '\n')) != NULL)
{
temp[0] = '\0';
}
ltrim(buf2);
if (buf2[0] == '[')
{
buf2[0] = ' ';
if ((temp = std::strchr(buf2, '\n')) != NULL)
{
temp[0] = '\0';
}
rtrim(buf2);
if (buf2[std::strlen(buf2)-1] == ']')
{
buf2[std::strlen(buf2)-1] = '\0';
ltrim(buf2);
rtrim(buf2);
bMolecules = (gmx_strcasecmp(buf2, "molecules") == 0);
}
fprintf(fpout, "%s", buf);
}
else if (!bMolecules)
{
fprintf(fpout, "%s", buf);
}
else
{
/* Check if this is a line with solvent molecules */
sscanf(buf, "%s", buf2);
if (gmx_strcasecmp(buf2, grpname) == 0)
{
sol_line = nmol_line;
sscanf(buf, "%*s %d", &nsol_last);
}
/* Store this molecules section line */
srenew(mol_line, nmol_line+1);
mol_line[nmol_line] = gmx_strdup(buf);
nmol_line++;
}
}
gmx_ffclose(fpin);
if (sol_line == -1)
{
gmx_ffclose(fpout);
gmx_fatal(FARGS, "No line with moleculetype '%s' found the [ molecules ] section of file '%s'", grpname, topinout);
}
if (nsol_last < p_num+n_num)
{
gmx_ffclose(fpout);
gmx_fatal(FARGS, "The last entry for moleculetype '%s' in the [ molecules ] section of file '%s' has less solvent molecules (%d) than were replaced (%d)", grpname, topinout, nsol_last, p_num+n_num);
}
/* Print all the molecule entries */
for (i = 0; i < nmol_line; i++)
{
if (i != sol_line)
{
fprintf(fpout, "%s", mol_line[i]);
}
else
{
printf("Replacing %d solute molecules in topology file (%s) "
" by %d %s and %d %s ions.\n",
p_num+n_num, topinout, p_num, p_name, n_num, n_name);
nsol_last -= p_num + n_num;
if (nsol_last > 0)
{
fprintf(fpout, "%-10s %d\n", grpname, nsol_last);
}
if (p_num > 0)
{
fprintf(fpout, "%-15s %d\n", p_name, p_num);
}
if (n_num > 0)
{
fprintf(fpout, "%-15s %d\n", n_name, n_num);
}
}
}
gmx_ffclose(fpout);
make_backup(topinout);
gmx_file_rename(temporary_filename, topinout);
}
int gmx_wheel(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] plots a helical wheel representation of your sequence.",
"The input sequence is in the [REF].dat[ref] file where the first line contains",
"the number of residues and each consecutive line contains a residue "
"name."
};
gmx_output_env_t *oenv;
static real rot0 = 0;
static gmx_bool bNum = TRUE;
static char *title = NULL;
static int r0 = 1;
t_pargs pa [] = {
{ "-r0", FALSE, etINT, {&r0},
"The first residue number in the sequence" },
{ "-rot0", FALSE, etREAL, {&rot0},
"Rotate around an angle initially (90 degrees makes sense)" },
{ "-T", FALSE, etSTR, {&title},
"Plot a title in the center of the wheel (must be shorter than 10 characters, or it will overwrite the wheel)" },
{ "-nn", FALSE, etBOOL, {&bNum},
"Toggle numbers" }
};
t_filenm fnm[] = {
{ efDAT, "-f", NULL, ffREAD },
{ efEPS, "-o", NULL, ffWRITE }
};
#define NFILE asize(fnm)
int i, nres;
char **resnm;
if (!parse_common_args(&argc, argv, 0, NFILE, fnm, asize(pa), pa,
asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
for (i = 1; (i < argc); i++)
{
if (std::strcmp(argv[i], "-r0") == 0)
{
r0 = std::strtol(argv[++i], NULL, 10);
fprintf(stderr, "First residue is %d\n", r0);
}
else if (std::strcmp(argv[i], "-rot0") == 0)
{
rot0 = strtod(argv[++i], NULL);
fprintf(stderr, "Initial rotation is %g\n", rot0);
}
else if (std::strcmp(argv[i], "-T") == 0)
{
title = gmx_strdup(argv[++i]);
fprintf(stderr, "Title will be '%s'\n", title);
}
else if (std::strcmp(argv[i], "-nn") == 0)
{
bNum = FALSE;
fprintf(stderr, "No residue numbers\n");
}
else
{
gmx_fatal(FARGS, "Incorrect usage of option %s", argv[i]);
}
}
nres = get_lines(ftp2fn(efDAT, NFILE, fnm), &resnm);
if (bNum)
{
wheel(ftp2fn(efEPS, NFILE, fnm), nres, resnm, r0, rot0, title);
}
else
{
wheel2(ftp2fn(efEPS, NFILE, fnm), nres, resnm, rot0, title);
}
return 0;
}
int gmx_polystat(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] plots static properties of polymers as a function of time",
"and prints the average.[PAR]",
"By default it determines the average end-to-end distance and radii",
"of gyration of polymers. It asks for an index group and split this",
"into molecules. The end-to-end distance is then determined using",
"the first and the last atom in the index group for each molecules.",
"For the radius of gyration the total and the three principal components",
"for the average gyration tensor are written.",
"With option [TT]-v[tt] the eigenvectors are written.",
"With option [TT]-pc[tt] also the average eigenvalues of the individual",
"gyration tensors are written.",
"With option [TT]-i[tt] the mean square internal distances are",
"written.[PAR]",
"With option [TT]-p[tt] the persistence length is determined.",
"The chosen index group should consist of atoms that are",
"consecutively bonded in the polymer mainchains.",
"The persistence length is then determined from the cosine of",
"the angles between bonds with an index difference that is even,",
"the odd pairs are not used, because straight polymer backbones",
"are usually all trans and therefore only every second bond aligns.",
"The persistence length is defined as number of bonds where",
"the average cos reaches a value of 1/e. This point is determined",
"by a linear interpolation of [LOG]<cos>[log]."
};
static gmx_bool bMW = TRUE, bPC = FALSE;
t_pargs pa[] = {
{ "-mw", FALSE, etBOOL, {&bMW},
"Use the mass weighting for radii of gyration" },
{ "-pc", FALSE, etBOOL, {&bPC},
"Plot average eigenvalues" }
};
t_filenm fnm[] = {
{ efTPR, nullptr, nullptr, ffREAD },
{ efTRX, "-f", nullptr, ffREAD },
{ efNDX, nullptr, nullptr, ffOPTRD },
{ efXVG, "-o", "polystat", ffWRITE },
{ efXVG, "-v", "polyvec", ffOPTWR },
{ efXVG, "-p", "persist", ffOPTWR },
{ efXVG, "-i", "intdist", ffOPTWR }
};
#define NFILE asize(fnm)
t_topology *top;
gmx_output_env_t *oenv;
int ePBC;
int isize, *index, nmol, *molind, mol, nat_min = 0, nat_max = 0;
char *grpname;
t_trxstatus *status;
real t;
rvec *x, *bond = nullptr;
matrix box;
int natoms, i, j, frame, ind0, ind1, a, d, d2, ord[DIM] = {0};
dvec cm, sum_eig = {0, 0, 0};
double **gyr, **gyr_all, eig[DIM], **eigv;
double sum_eed2, sum_eed2_tot, sum_gyro, sum_gyro_tot, sum_pers_tot;
int *ninp = nullptr;
double *sum_inp = nullptr, pers;
double *intd, ymax, ymin;
double mmol, m;
char title[STRLEN];
FILE *out, *outv, *outp, *outi;
const char *leg[8] = {
"end to end", "<R\\sg\\N>",
"<R\\sg\\N> eig1", "<R\\sg\\N> eig2", "<R\\sg\\N> eig3",
"<R\\sg\\N eig1>", "<R\\sg\\N eig2>", "<R\\sg\\N eig3>"
};
char **legp, buf[STRLEN];
gmx_rmpbc_t gpbc = nullptr;
if (!parse_common_args(&argc, argv,
PCA_CAN_VIEW | PCA_CAN_TIME | PCA_TIME_UNIT,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, nullptr, &oenv))
{
return 0;
}
snew(top, 1);
ePBC = read_tpx_top(ftp2fn(efTPR, NFILE, fnm),
nullptr, box, &natoms, nullptr, nullptr, top);
fprintf(stderr, "Select a group of polymer mainchain atoms:\n");
get_index(&top->atoms, ftp2fn_null(efNDX, NFILE, fnm),
1, &isize, &index, &grpname);
snew(molind, top->mols.nr+1);
nmol = 0;
mol = -1;
for (i = 0; i < isize; i++)
{
if (i == 0 || index[i] >= top->mols.index[mol+1])
{
molind[nmol++] = i;
do
{
mol++;
}
while (index[i] >= top->mols.index[mol+1]);
}
}
molind[nmol] = i;
nat_min = top->atoms.nr;
nat_max = 0;
for (mol = 0; mol < nmol; mol++)
{
nat_min = std::min(nat_min, molind[mol+1]-molind[mol]);
nat_max = std::max(nat_max, molind[mol+1]-molind[mol]);
}
fprintf(stderr, "Group %s consists of %d molecules\n", grpname, nmol);
fprintf(stderr, "Group size per molecule, min: %d atoms, max %d atoms\n",
nat_min, nat_max);
sprintf(title, "Size of %d polymers", nmol);
out = xvgropen(opt2fn("-o", NFILE, fnm), title, output_env_get_xvgr_tlabel(oenv), "(nm)",
oenv);
xvgr_legend(out, bPC ? 8 : 5, leg, oenv);
if (opt2bSet("-v", NFILE, fnm))
{
outv = xvgropen(opt2fn("-v", NFILE, fnm), "Principal components",
output_env_get_xvgr_tlabel(oenv), "(nm)", oenv);
snew(legp, DIM*DIM);
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
sprintf(buf, "eig%d %c", d+1, 'x'+d2);
legp[d*DIM+d2] = gmx_strdup(buf);
}
}
xvgr_legend(outv, DIM*DIM, (const char**)legp, oenv);
}
else
{
outv = nullptr;
}
if (opt2bSet("-p", NFILE, fnm))
{
outp = xvgropen(opt2fn("-p", NFILE, fnm), "Persistence length",
output_env_get_xvgr_tlabel(oenv), "bonds", oenv);
snew(bond, nat_max-1);
snew(sum_inp, nat_min/2);
snew(ninp, nat_min/2);
}
else
{
outp = nullptr;
}
if (opt2bSet("-i", NFILE, fnm))
{
outi = xvgropen(opt2fn("-i", NFILE, fnm), "Internal distances",
"n", "<R\\S2\\N(n)>/n (nm\\S2\\N)", oenv);
i = index[molind[1]-1] - index[molind[0]]; /* Length of polymer -1 */
snew(intd, i);
}
else
{
intd = nullptr;
outi = nullptr;
}
natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
snew(gyr, DIM);
snew(gyr_all, DIM);
snew(eigv, DIM);
for (d = 0; d < DIM; d++)
{
snew(gyr[d], DIM);
snew(gyr_all[d], DIM);
snew(eigv[d], DIM);
}
frame = 0;
sum_eed2_tot = 0;
sum_gyro_tot = 0;
sum_pers_tot = 0;
gpbc = gmx_rmpbc_init(&top->idef, ePBC, natoms);
do
{
gmx_rmpbc(gpbc, natoms, box, x);
sum_eed2 = 0;
for (d = 0; d < DIM; d++)
{
clear_dvec(gyr_all[d]);
}
if (bPC)
{
clear_dvec(sum_eig);
}
if (outp)
{
for (i = 0; i < nat_min/2; i++)
{
sum_inp[i] = 0;
ninp[i] = 0;
}
}
for (mol = 0; mol < nmol; mol++)
{
ind0 = molind[mol];
ind1 = molind[mol+1];
/* Determine end to end distance */
sum_eed2 += distance2(x[index[ind0]], x[index[ind1-1]]);
/* Determine internal distances */
if (outi)
{
calc_int_dist(intd, x, index[ind0], index[ind1-1]);
}
/* Determine the radius of gyration */
clear_dvec(cm);
for (d = 0; d < DIM; d++)
{
clear_dvec(gyr[d]);
}
mmol = 0;
for (i = ind0; i < ind1; i++)
{
a = index[i];
if (bMW)
{
m = top->atoms.atom[a].m;
}
else
{
m = 1;
}
mmol += m;
for (d = 0; d < DIM; d++)
{
cm[d] += m*x[a][d];
for (d2 = 0; d2 < DIM; d2++)
{
gyr[d][d2] += m*x[a][d]*x[a][d2];
}
}
}
dsvmul(1/mmol, cm, cm);
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
gyr[d][d2] = gyr[d][d2]/mmol - cm[d]*cm[d2];
gyr_all[d][d2] += gyr[d][d2];
}
}
if (bPC)
{
gyro_eigen(gyr, eig, eigv, ord);
for (d = 0; d < DIM; d++)
{
sum_eig[d] += eig[ord[d]];
}
}
if (outp)
{
for (i = ind0; i < ind1-1; i++)
{
rvec_sub(x[index[i+1]], x[index[i]], bond[i-ind0]);
unitv(bond[i-ind0], bond[i-ind0]);
}
for (i = ind0; i < ind1-1; i++)
{
for (j = 0; (i+j < ind1-1 && j < nat_min/2); j += 2)
{
sum_inp[j] += iprod(bond[i-ind0], bond[i-ind0+j]);
ninp[j]++;
}
}
}
}
sum_eed2 /= nmol;
sum_gyro = 0;
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
gyr_all[d][d2] /= nmol;
}
sum_gyro += gyr_all[d][d];
}
gyro_eigen(gyr_all, eig, eigv, ord);
fprintf(out, "%10.3f %8.4f %8.4f %8.4f %8.4f %8.4f",
t*output_env_get_time_factor(oenv),
std::sqrt(sum_eed2), sqrt(sum_gyro),
std::sqrt(eig[ord[0]]), std::sqrt(eig[ord[1]]), std::sqrt(eig[ord[2]]));
if (bPC)
{
for (d = 0; d < DIM; d++)
{
fprintf(out, " %8.4f", std::sqrt(sum_eig[d]/nmol));
}
}
fprintf(out, "\n");
if (outv)
{
fprintf(outv, "%10.3f", t*output_env_get_time_factor(oenv));
for (d = 0; d < DIM; d++)
{
for (d2 = 0; d2 < DIM; d2++)
{
fprintf(outv, " %6.3f", eigv[ord[d]][d2]);
}
}
fprintf(outv, "\n");
}
sum_eed2_tot += sum_eed2;
sum_gyro_tot += sum_gyro;
if (outp)
{
i = -1;
for (j = 0; j < nat_min/2; j += 2)
{
sum_inp[j] /= ninp[j];
if (i == -1 && sum_inp[j] <= std::exp(-1.0))
{
i = j;
}
}
if (i == -1)
{
pers = j;
}
else
{
/* Do linear interpolation on a log scale */
pers = i - 2.0
+ 2.0*(std::log(sum_inp[i-2]) + 1.0)/(std::log(sum_inp[i-2]) - std::log(sum_inp[i]));
}
fprintf(outp, "%10.3f %8.4f\n", t*output_env_get_time_factor(oenv), pers);
sum_pers_tot += pers;
}
frame++;
}
while (read_next_x(oenv, status, &t, x, box));
gmx_rmpbc_done(gpbc);
close_trx(status);
xvgrclose(out);
if (outv)
{
xvgrclose(outv);
}
if (outp)
{
xvgrclose(outp);
}
sum_eed2_tot /= frame;
sum_gyro_tot /= frame;
sum_pers_tot /= frame;
fprintf(stdout, "\nAverage end to end distance: %.3f (nm)\n",
std::sqrt(sum_eed2_tot));
fprintf(stdout, "\nAverage radius of gyration: %.3f (nm)\n",
std::sqrt(sum_gyro_tot));
if (opt2bSet("-p", NFILE, fnm))
{
fprintf(stdout, "\nAverage persistence length: %.2f bonds\n",
sum_pers_tot);
}
/* Handle printing of internal distances. */
if (outi)
{
if (output_env_get_print_xvgr_codes(oenv))
{
fprintf(outi, "@ xaxes scale Logarithmic\n");
}
ymax = -1;
ymin = 1e300;
j = index[molind[1]-1] - index[molind[0]]; /* Polymer length -1. */
for (i = 0; i < j; i++)
{
intd[i] /= (i + 1) * frame * nmol;
if (intd[i] > ymax)
{
ymax = intd[i];
}
if (intd[i] < ymin)
{
ymin = intd[i];
}
}
xvgr_world(outi, 1, ymin, j, ymax, oenv);
for (i = 0; i < j; i++)
{
fprintf(outi, "%d %8.4f\n", i+1, intd[i]);
}
xvgrclose(outi);
}
do_view(oenv, opt2fn("-o", NFILE, fnm), "-nxy");
if (opt2bSet("-v", NFILE, fnm))
{
do_view(oenv, opt2fn("-v", NFILE, fnm), "-nxy");
}
if (opt2bSet("-p", NFILE, fnm))
{
do_view(oenv, opt2fn("-p", NFILE, fnm), "-nxy");
}
return 0;
}
t_inpfile *read_inpfile(const char *fn, int *ninp,
warninp_t wi)
{
FILE *in;
char buf[STRLEN], lbuf[STRLEN], rbuf[STRLEN], warn_buf[STRLEN];
char *ptr, *cptr;
t_inpfile *inp = NULL;
int nin, lc, i, j, k;
/* setting cppopts from command-line options would be cooler */
gmx_bool allow_override = FALSE;
if (debug)
{
fprintf(debug, "Reading MDP file %s\n", fn);
}
in = gmx_ffopen(fn, "r");
nin = lc = 0;
do
{
ptr = fgets2(buf, STRLEN-1, in);
lc++;
set_warning_line(wi, fn, lc);
if (ptr)
{
// TODO This parsing should be using strip_comment, trim,
// strchr, etc. rather than re-inventing wheels.
/* Strip comment */
if ((cptr = strchr(buf, COMMENTSIGN)) != NULL)
{
*cptr = '\0';
}
/* Strip spaces */
trim(buf);
for (j = 0; (buf[j] != '=') && (buf[j] != '\0'); j++)
{
;
}
if (buf[j] == '\0')
{
if (j > 0)
{
if (debug)
{
fprintf(debug, "No = on line %d in file %s, ignored\n", lc, fn);
}
}
}
else
{
for (i = 0; (i < j); i++)
{
lbuf[i] = buf[i];
}
lbuf[i] = '\0';
trim(lbuf);
if (lbuf[0] == '\0')
{
if (debug)
{
fprintf(debug, "Empty left hand side on line %d in file %s, ignored\n", lc, fn);
}
}
else
{
for (i = j+1, k = 0; (buf[i] != '\0'); i++, k++)
{
rbuf[k] = buf[i];
}
rbuf[k] = '\0';
trim(rbuf);
if (rbuf[0] == '\0')
{
if (debug)
{
fprintf(debug, "Empty right hand side on line %d in file %s, ignored\n", lc, fn);
}
}
else
{
/* Now finally something sensible */
int found_index;
/* first check whether we hit the 'multiple_entries' option */
if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptName], lbuf) == 0)
{
/* we now check whether to allow overrides from here or not */
if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptNo], rbuf) == 0)
{
allow_override = FALSE;
}
else if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptLast], rbuf) == 0)
{
allow_override = TRUE;
}
else
{
sprintf(warn_buf,
"Parameter \"%s\" should either be %s or %s\n",
lbuf,
eMultentOpt_names[eMultentOptNo],
eMultentOpt_names[eMultentOptLast]);
warning_error(wi, warn_buf);
}
}
else
{
/* it is a regular option; check for duplicates */
found_index = search_einp(nin, inp, lbuf);
if (found_index == -1)
{
/* add a new item */
srenew(inp, ++nin);
inp[nin-1].inp_count = 1;
inp[nin-1].count = 0;
inp[nin-1].bObsolete = FALSE;
inp[nin-1].bSet = FALSE;
inp[nin-1].name = gmx_strdup(lbuf);
inp[nin-1].value = gmx_strdup(rbuf);
}
else
{
if (!allow_override)
{
sprintf(warn_buf,
"Parameter \"%s\" doubly defined (and multiple assignments not allowed)\n",
lbuf);
warning_error(wi, warn_buf);
}
else
{
/* override */
sfree(inp[found_index].value);
inp[found_index].value = gmx_strdup(rbuf);
sprintf(warn_buf,
"Overriding existing parameter \"%s\" with value \"%s\"\n",
lbuf, rbuf);
warning_note(wi, warn_buf);
}
}
}
}
}
}
}
}
while (ptr);
gmx_ffclose(in);
if (debug)
{
fprintf(debug, "Done reading MDP file, there were %d entries in there\n",
nin);
}
*ninp = nin;
return inp;
}
void sort_ions(int nsa, int nw, int repl[], atom_id index[],
t_atoms *atoms, rvec x[],
const char *p_name, const char *n_name)
{
int i, j, k, r, np, nn, starta, startr, npi, nni;
rvec *xt;
char **pptr = NULL, **nptr = NULL, **paptr = NULL, **naptr = NULL;
snew(xt, atoms->nr);
/* Put all the solvent in front and count the added ions */
np = 0;
nn = 0;
j = index[0];
for (i = 0; i < nw; i++)
{
r = repl[i];
if (r == 0)
{
for (k = 0; k < nsa; k++)
{
copy_rvec(x[index[nsa*i+k]], xt[j++]);
}
}
else if (r > 0)
{
np++;
}
else if (r < 0)
{
nn++;
}
}
if (np+nn > 0)
{
/* Put the positive and negative ions at the end */
starta = index[nsa*(nw - np - nn)];
startr = atoms->atom[starta].resind;
if (np)
{
snew(pptr, 1);
pptr[0] = gmx_strdup(p_name);
snew(paptr, 1);
paptr[0] = aname(p_name);
}
if (nn)
{
snew(nptr, 1);
nptr[0] = gmx_strdup(n_name);
snew(naptr, 1);
naptr[0] = aname(n_name);
}
npi = 0;
nni = 0;
for (i = 0; i < nw; i++)
{
r = repl[i];
if (r > 0)
{
j = starta+npi;
k = startr+npi;
copy_rvec(x[index[nsa*i]], xt[j]);
atoms->atomname[j] = paptr;
atoms->atom[j].resind = k;
atoms->resinfo[k].name = pptr;
npi++;
}
else if (r < 0)
{
j = starta+np+nni;
k = startr+np+nni;
copy_rvec(x[index[nsa*i]], xt[j]);
atoms->atomname[j] = naptr;
atoms->atom[j].resind = k;
atoms->resinfo[k].name = nptr;
nni++;
}
}
for (i = index[nsa*nw-1]+1; i < atoms->nr; i++)
{
j = i-(nsa-1)*(np+nn);
atoms->atomname[j] = atoms->atomname[i];
atoms->atom[j] = atoms->atom[i];
copy_rvec(x[i], xt[j]);
}
atoms->nr -= (nsa-1)*(np+nn);
/* Copy the new positions back */
for (i = index[0]; i < atoms->nr; i++)
{
copy_rvec(xt[i], x[i]);
}
sfree(xt);
}
}
int main (int argc,char *argv[])
{
const char *desc[] = {
"[TT]g_protonate[tt] reads (a) conformation(s) and adds all missing",
"hydrogens as defined in [TT]gmx2.ff/aminoacids.hdb[tt]. If only [TT]-s[tt] is",
"specified, this conformation will be protonated, if also [TT]-f[tt]",
"is specified, the conformation(s) will be read from this file, ",
"which can be either a single conformation or a trajectory.",
"[PAR]",
"If a [TT].pdb[tt] file is supplied, residue names might not correspond to",
"to the GROMACS naming conventions, in which case these residues will",
"probably not be properly protonated.",
"[PAR]",
"If an index file is specified, please note that the atom numbers",
"should correspond to the [BB]protonated[bb] state."
};
char title[STRLEN+1];
const char *infile;
char *grpnm;
t_topology top;
int ePBC;
t_atoms *atoms,*iatoms;
t_protonate protdata;
atom_id *index;
t_trxstatus *status;
t_trxstatus *out;
t_trxframe fr,frout;
rvec *x,*ix;
int nidx,natoms,natoms_out;
matrix box;
int i,frame,resind;
gmx_bool bReadMultiple;
output_env_t oenv;
const char *bugs[] = {
"For the moment, only .pdb files are accepted to the -s flag"
};
t_filenm fnm[] = {
{ efTPS, NULL, NULL, ffREAD },
{ efTRX, "-f", NULL, ffOPTRD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efTRO, "-o", "protonated", ffWRITE }
};
#define NFILE asize(fnm)
CopyRight(stderr,argv[0]);
parse_common_args(&argc,argv,PCA_CAN_TIME,
NFILE,fnm,0,NULL,asize(desc),desc,asize(bugs),bugs,&oenv);
infile=opt2fn("-s",NFILE,fnm);
read_tps_conf(infile,title,&top,&ePBC,&x,NULL,box,FALSE);
atoms=&(top.atoms);
printf("Select group to process:\n");
get_index(atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&nidx,&index,&grpnm);
bReadMultiple = opt2bSet("-f",NFILE,fnm);
if (bReadMultiple) {
infile = opt2fn("-f",NFILE,fnm);
if ( !read_first_frame(oenv,&status, infile, &fr, TRX_NEED_X ) ) {
gmx_fatal(FARGS,"cannot read coordinate file %s",infile);
}
natoms = fr.natoms;
} else {
clear_trxframe(&fr,TRUE);
fr.natoms = atoms->nr;
fr.bTitle = TRUE;
fr.title = title;
fr.bX = TRUE;
fr.x = x;
fr.bBox = TRUE;
copy_mat(box, fr.box);
natoms = fr.natoms;
}
/* check input */
if ( natoms == 0 ) {
gmx_fatal(FARGS,"no atoms in coordinate file %s",infile);
}
if ( natoms > atoms->nr ) {
gmx_fatal(FARGS,"topology with %d atoms does not match "
"coordinates with %d atoms",atoms->nr,natoms);
}
for(i=0; i<nidx; i++) {
if (index[i] > natoms) {
gmx_fatal(FARGS,"An atom number in group %s is larger than the number of "
"atoms (%d) in the coordinate file %s",grpnm,natoms,infile);
}
}
/* get indexed copy of atoms */
snew(iatoms,1);
init_t_atoms(iatoms,nidx,FALSE);
snew(iatoms->atom, iatoms->nr);
resind = 0;
for(i=0; i<nidx; i++) {
iatoms->atom[i] = atoms->atom[index[i]];
iatoms->atomname[i] = atoms->atomname[index[i]];
if ( i>0 && (atoms->atom[index[i]].resind!=atoms->atom[index[i-1]].resind) ) {
resind++;
}
iatoms->atom[i].resind = resind;
iatoms->resinfo[resind] = atoms->resinfo[atoms->atom[index[i]].resind];
/* allocate some space for the rtp name and copy from name */
snew(iatoms->resinfo[resind].rtp,1);
*iatoms->resinfo[resind].rtp = gmx_strdup(*atoms->resinfo[resind].name);
iatoms->nres = max(iatoms->nres, iatoms->atom[i].resind+1);
}
init_t_protonate(&protdata);
out = open_trx(opt2fn("-o",NFILE,fnm),"w");
snew(ix, nidx);
frame=0;
do {
if (debug) {
fprintf(debug,"FRAME %d (%d %g)\n",frame,fr.step,fr.time);
}
/* get indexed copy of x */
for(i=0; i<nidx; i++) {
copy_rvec(fr.x[index[i]], ix[i]);
}
/* protonate */
natoms_out = protonate(&iatoms, &ix, &protdata);
/* setup output frame */
frout = fr;
frout.natoms = natoms_out;
frout.bAtoms = TRUE;
frout.atoms = iatoms;
frout.bV = FALSE;
frout.bF = FALSE;
frout.x = ix;
/* write output */
write_trxframe(out,&frout,NULL);
frame++;
} while ( bReadMultiple && read_next_frame(oenv,status, &fr) );
sfree(ix);
sfree(iatoms);
thanx(stderr);
return 0;
}
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;
}
void read_resall(char *rrdb, int *nrtpptr, t_restp **rtp,
gpp_atomtype_t atype, t_symtab *tab,
gmx_bool bAllowOverrideRTP)
{
FILE *in;
char filebase[STRLEN], line[STRLEN], header[STRLEN];
int i, nrtp, maxrtp, bt, nparam;
int dum1, dum2, dum3;
t_restp *rrtp, *header_settings;
gmx_bool bNextResidue, bError;
int firstrtp;
fflib_filename_base(rrdb, filebase, STRLEN);
in = fflib_open(rrdb);
if (debug)
{
fprintf(debug, "%9s %5s", "Residue", "atoms");
for (i = 0; i < ebtsNR; i++)
{
fprintf(debug, " %10s", btsNames[i]);
}
fprintf(debug, "\n");
}
snew(header_settings, 1);
/* these bonded parameters will overwritten be when *
* there is a [ bondedtypes ] entry in the .rtp file */
header_settings->rb[ebtsBONDS].type = 1; /* normal bonds */
header_settings->rb[ebtsANGLES].type = 1; /* normal angles */
header_settings->rb[ebtsPDIHS].type = 1; /* normal dihedrals */
header_settings->rb[ebtsIDIHS].type = 2; /* normal impropers */
header_settings->rb[ebtsEXCLS].type = 1; /* normal exclusions */
header_settings->rb[ebtsCMAP].type = 1; /* normal cmap torsions */
header_settings->bKeepAllGeneratedDihedrals = FALSE;
header_settings->nrexcl = 3;
header_settings->bGenerateHH14Interactions = TRUE;
header_settings->bRemoveDihedralIfWithImproper = TRUE;
/* Column 5 & 6 aren't really bonded types, but we include
* them here to avoid introducing a new section:
* Column 5 : This controls the generation of dihedrals from the bonding.
* All possible dihedrals are generated automatically. A value of
* 1 here means that all these are retained. A value of
* 0 here requires generated dihedrals be removed if
* * there are any dihedrals on the same central atoms
* specified in the residue topology, or
* * there are other identical generated dihedrals
* sharing the same central atoms, or
* * there are other generated dihedrals sharing the
* same central bond that have fewer hydrogen atoms
* Column 6: Number of bonded neighbors to exclude.
* Column 7: Generate 1,4 interactions between two hydrogen atoms
* Column 8: Remove proper dihedrals if centered on the same bond
* as an improper dihedral
*/
get_a_line(in, line, STRLEN);
if (!get_header(line, header))
{
gmx_fatal(FARGS, "in .rtp file at line:\n%s\n", line);
}
if (gmx_strncasecmp("bondedtypes", header, 5) == 0)
{
get_a_line(in, line, STRLEN);
if ((nparam = sscanf(line, "%d %d %d %d %d %d %d %d",
&header_settings->rb[ebtsBONDS].type, &header_settings->rb[ebtsANGLES].type,
&header_settings->rb[ebtsPDIHS].type, &header_settings->rb[ebtsIDIHS].type,
&dum1, &header_settings->nrexcl, &dum2, &dum3)) < 4)
{
gmx_fatal(FARGS, "need 4 to 8 parameters in the header of .rtp file %s at line:\n%s\n", rrdb, line);
}
header_settings->bKeepAllGeneratedDihedrals = (dum1 != 0);
header_settings->bGenerateHH14Interactions = (dum2 != 0);
header_settings->bRemoveDihedralIfWithImproper = (dum3 != 0);
get_a_line(in, line, STRLEN);
if (nparam < 5)
{
fprintf(stderr, "Using default: not generating all possible dihedrals\n");
header_settings->bKeepAllGeneratedDihedrals = FALSE;
}
if (nparam < 6)
{
fprintf(stderr, "Using default: excluding 3 bonded neighbors\n");
header_settings->nrexcl = 3;
}
if (nparam < 7)
{
fprintf(stderr, "Using default: generating 1,4 H--H interactions\n");
header_settings->bGenerateHH14Interactions = TRUE;
}
if (nparam < 8)
{
fprintf(stderr, "Using default: removing proper dihedrals found on the same bond as a proper dihedral\n");
header_settings->bRemoveDihedralIfWithImproper = TRUE;
}
}
else
{
fprintf(stderr,
"Reading .rtp file without '[ bondedtypes ]' directive,\n"
"Will proceed as if the entry was:\n");
print_resall_header(stderr, header_settings);
}
/* We don't know the current size of rrtp, but simply realloc immediately */
nrtp = *nrtpptr;
rrtp = *rtp;
maxrtp = nrtp;
while (!feof(in))
{
if (nrtp >= maxrtp)
{
maxrtp += 100;
srenew(rrtp, maxrtp);
}
/* Initialise rtp entry structure */
rrtp[nrtp] = *header_settings;
if (!get_header(line, header))
{
gmx_fatal(FARGS, "in .rtp file at line:\n%s\n", line);
}
rrtp[nrtp].resname = gmx_strdup(header);
rrtp[nrtp].filebase = gmx_strdup(filebase);
get_a_line(in, line, STRLEN);
bError = FALSE;
bNextResidue = FALSE;
do
{
if (!get_header(line, header))
{
bError = TRUE;
}
else
{
bt = get_bt(header);
if (bt != NOTSET)
{
/* header is an bonded directive */
bError = !read_bondeds(bt, in, line, &rrtp[nrtp]);
}
else if (gmx_strncasecmp("atoms", header, 5) == 0)
{
/* header is the atoms directive */
bError = !read_atoms(in, line, &(rrtp[nrtp]), tab, atype);
}
else
{
/* else header must be a residue name */
bNextResidue = TRUE;
}
}
if (bError)
{
gmx_fatal(FARGS, "in .rtp file in residue %s at line:\n%s\n",
rrtp[nrtp].resname, line);
}
}
while (!feof(in) && !bNextResidue);
if (rrtp[nrtp].natom == 0)
{
gmx_fatal(FARGS, "No atoms found in .rtp file in residue %s\n",
rrtp[nrtp].resname);
}
if (debug)
{
fprintf(debug, "%3d %5s %5d",
nrtp+1, rrtp[nrtp].resname, rrtp[nrtp].natom);
for (i = 0; i < ebtsNR; i++)
{
fprintf(debug, " %10d", rrtp[nrtp].rb[i].nb);
}
fprintf(debug, "\n");
}
firstrtp = -1;
for (i = 0; i < nrtp; i++)
{
if (gmx_strcasecmp(rrtp[i].resname, rrtp[nrtp].resname) == 0)
{
firstrtp = i;
}
}
if (firstrtp == -1)
{
nrtp++;
fprintf(stderr, "\rResidue %d", nrtp);
fflush(stderr);
}
else
{
if (firstrtp >= *nrtpptr)
{
gmx_fatal(FARGS, "Found a second entry for '%s' in '%s'",
rrtp[nrtp].resname, rrdb);
}
if (bAllowOverrideRTP)
{
fprintf(stderr, "\n");
fprintf(stderr, "Found another rtp entry for '%s' in '%s', ignoring this entry and keeping the one from '%s.rtp'\n",
rrtp[nrtp].resname, rrdb, rrtp[firstrtp].filebase);
/* We should free all the data for this entry.
* The current code gives a lot of dangling pointers.
*/
clear_t_restp(&rrtp[nrtp]);
}
else
{
gmx_fatal(FARGS, "Found rtp entries for '%s' in both '%s' and '%s'. If you want the first definition to override the second one, set the -rtpo option of pdb2gmx.", rrtp[nrtp].resname, rrtp[firstrtp].filebase, rrdb);
}
}
}
gmx_ffclose(in);
/* give back unused memory */
srenew(rrtp, nrtp);
fprintf(stderr, "\nSorting it all out...\n");
qsort(rrtp, nrtp, (size_t)sizeof(rrtp[0]), comprtp);
check_rtp(nrtp, rrtp, rrdb);
*nrtpptr = nrtp;
*rtp = rrtp;
}
