-/* -*- mode: c; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; c-file-style: "stroustrup"; -*-
+/*
+ * This file is part of the GROMACS molecular simulation package.
*
- *
- * This source code is part of
- *
- * G R O M A C S
- *
- * GROningen MAchine for Chemical Simulations
- *
- * VERSION 3.2.0
- * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
* Copyright (c) 1991-2000, University of Groningen, The Netherlands.
- * Copyright (c) 2001-2004, The GROMACS development team,
- * check out http://www.gromacs.org for more information.
-
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
+ * Copyright (c) 2001-2004, The GROMACS development team.
+ * Copyright (c) 2013,2014, by the GROMACS development team, led by
+ * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
+ * and including many others, as listed in the AUTHORS file in the
+ * top-level source directory and at http://www.gromacs.org.
+ *
+ * GROMACS is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version.
*
- * If you want to redistribute modifications, please consider that
- * scientific software is very special. Version control is crucial -
- * bugs must be traceable. We will be happy to consider code for
- * inclusion in the official distribution, but derived work must not
- * be called official GROMACS. Details are found in the README & COPYING
- * files - if they are missing, get the official version at www.gromacs.org.
+ * GROMACS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
*
- * To help us fund GROMACS development, we humbly ask that you cite
- * the papers on the package - you can find them in the top README file.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with GROMACS; if not, see
+ * http://www.gnu.org/licenses, or write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
- * For more info, check our website at http://www.gromacs.org
+ * If you want to redistribute modifications to GROMACS, please
+ * consider that scientific software is very special. Version
+ * control is crucial - bugs must be traceable. We will be happy to
+ * consider code for inclusion in the official distribution, but
+ * derived work must not be called official GROMACS. Details are found
+ * in the README & COPYING files - if they are missing, get the
+ * official version at http://www.gromacs.org.
*
- * And Hey:
- * GROwing Monsters And Cloning Shrimps
+ * To help us fund GROMACS development, we humbly ask that you cite
+ * the research papers on the package. Check out http://www.gromacs.org.
*/
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "gmxpre.h"
+
+#include "config.h"
+#include <math.h>
#include <string.h>
#include <time.h>
-#include <math.h>
-#include "sysstuff.h"
-#include "string2.h"
-#include "network.h"
-#include "confio.h"
-#include "smalloc.h"
-#include "nrnb.h"
-#include "main.h"
-#include "force.h"
-#include "macros.h"
-#include "random.h"
-#include "names.h"
-#include "gmx_fatal.h"
-#include "txtdump.h"
-#include "typedefs.h"
-#include "update.h"
-#include "constr.h"
-#include "vec.h"
-#include "statutil.h"
-#include "tgroup.h"
-#include "mdebin.h"
-#include "vsite.h"
-#include "force.h"
-#include "mdrun.h"
-#include "md_support.h"
-#include "domdec.h"
-#include "partdec.h"
-#include "trnio.h"
-#include "mdatoms.h"
-#include "ns.h"
-#include "gmx_wallcycle.h"
-#include "mtop_util.h"
-#include "gmxfio.h"
-#include "pme.h"
-#include "bondf.h"
-#include "gmx_omp_nthreads.h"
-#include "md_logging.h"
-
-
-#include "gromacs/linearalgebra/mtxio.h"
+
+#include "gromacs/fileio/confio.h"
+#include "gromacs/fileio/mtxio.h"
+#include "gromacs/fileio/trajectory_writing.h"
+#include "gromacs/imd/imd.h"
+#include "gromacs/legacyheaders/bonded-threading.h"
+#include "gromacs/legacyheaders/constr.h"
+#include "gromacs/legacyheaders/domdec.h"
+#include "gromacs/legacyheaders/force.h"
+#include "gromacs/legacyheaders/gmx_omp_nthreads.h"
+#include "gromacs/legacyheaders/macros.h"
+#include "gromacs/legacyheaders/md_logging.h"
+#include "gromacs/legacyheaders/md_support.h"
+#include "gromacs/legacyheaders/mdatoms.h"
+#include "gromacs/legacyheaders/mdebin.h"
+#include "gromacs/legacyheaders/mdrun.h"
+#include "gromacs/legacyheaders/names.h"
+#include "gromacs/legacyheaders/network.h"
+#include "gromacs/legacyheaders/nrnb.h"
+#include "gromacs/legacyheaders/ns.h"
+#include "gromacs/legacyheaders/pme.h"
+#include "gromacs/legacyheaders/sim_util.h"
+#include "gromacs/legacyheaders/tgroup.h"
+#include "gromacs/legacyheaders/txtdump.h"
+#include "gromacs/legacyheaders/typedefs.h"
+#include "gromacs/legacyheaders/update.h"
+#include "gromacs/legacyheaders/vsite.h"
+#include "gromacs/legacyheaders/types/commrec.h"
#include "gromacs/linearalgebra/sparsematrix.h"
+#include "gromacs/math/vec.h"
+#include "gromacs/pbcutil/mshift.h"
+#include "gromacs/pbcutil/pbc.h"
+#include "gromacs/timing/wallcycle.h"
+#include "gromacs/timing/walltime_accounting.h"
+#include "gromacs/topology/mtop_util.h"
+#include "gromacs/utility/cstringutil.h"
+#include "gromacs/utility/fatalerror.h"
+#include "gromacs/utility/smalloc.h"
typedef struct {
t_state s;
return ems;
}
-static void print_em_start(FILE *fplog, t_commrec *cr, gmx_runtime_t *runtime,
- gmx_wallcycle_t wcycle,
- const char *name)
+static void print_em_start(FILE *fplog,
+ t_commrec *cr,
+ gmx_walltime_accounting_t walltime_accounting,
+ gmx_wallcycle_t wcycle,
+ const char *name)
{
- char buf[STRLEN];
-
- runtime_start(runtime);
-
- sprintf(buf, "Started %s", name);
- print_date_and_time(fplog, cr->nodeid, buf, NULL);
-
+ walltime_accounting_start(walltime_accounting);
wallcycle_start(wcycle, ewcRUN);
+ print_start(fplog, cr, walltime_accounting, name);
}
-static void em_time_end(gmx_runtime_t *runtime,
- gmx_wallcycle_t wcycle)
+static void em_time_end(gmx_walltime_accounting_t walltime_accounting,
+ gmx_wallcycle_t wcycle)
{
wallcycle_stop(wcycle, ewcRUN);
- runtime_end(runtime);
+ walltime_accounting_end(walltime_accounting);
}
static void sp_header(FILE *out, const char *minimizer, real ftol, int nsteps)
static void print_converged(FILE *fp, const char *alg, real ftol,
- gmx_large_int_t count, gmx_bool bDone, gmx_large_int_t nsteps,
+ gmx_int64_t count, gmx_bool bDone, gmx_int64_t nsteps,
real epot, real fmax, int nfmax, real fnorm)
{
char buf[STEPSTRSIZE];
fmax2 = 0;
la_max = -1;
gf = 0;
- start = mdatoms->start;
- end = mdatoms->homenr + start;
+ start = 0;
+ end = mdatoms->homenr;
if (mdatoms->cFREEZE)
{
for (i = start; i < end; i++)
t_graph **graph, t_mdatoms *mdatoms, gmx_global_stat_t *gstat,
gmx_vsite_t *vsite, gmx_constr_t constr,
int nfile, const t_filenm fnm[],
- gmx_mdoutf_t **outf, t_mdebin **mdebin)
+ gmx_mdoutf_t *outf, t_mdebin **mdebin,
+ int imdport, unsigned long gmx_unused Flags,
+ gmx_wallcycle_t wcycle)
{
- int start, homenr, i;
+ int i;
real dvdl_constr;
if (fplog)
init_nrnb(nrnb);
+ /* Interactive molecular dynamics */
+ init_IMD(ir, cr, top_global, fplog, 1, state_global->x,
+ nfile, fnm, NULL, imdport, Flags);
+
if (DOMAINDECOMP(cr))
{
*top = dd_init_local_top(top_global);
}
copy_mat(state_global->box, ems->s.box);
- if (PAR(cr) && ir->eI != eiNM)
- {
- /* Initialize the particle decomposition and split the topology */
- *top = split_system(fplog, top_global, ir, cr);
-
- pd_cg_range(cr, &fr->cg0, &fr->hcg);
- }
- else
- {
- *top = gmx_mtop_generate_local_top(top_global, ir);
- }
+ *top = gmx_mtop_generate_local_top(top_global, ir);
*f_global = *f;
- forcerec_set_excl_load(fr, *top, cr);
+ forcerec_set_excl_load(fr, *top);
setup_bonded_threading(fr, &(*top)->idef);
*graph = NULL;
}
- if (PARTDECOMP(cr))
- {
- pd_at_range(cr, &start, &homenr);
- homenr -= start;
- }
- else
- {
- start = 0;
- homenr = top_global->natoms;
- }
- atoms2md(top_global, ir, 0, NULL, start, homenr, mdatoms);
+ atoms2md(top_global, ir, 0, NULL, top_global->natoms, mdatoms);
update_mdatoms(mdatoms, state_global->lambda[efptFEP]);
if (vsite)
/* Constrain the starting coordinates */
dvdl_constr = 0;
constrain(PAR(cr) ? NULL : fplog, TRUE, TRUE, constr, &(*top)->idef,
- ir, NULL, cr, -1, 0, mdatoms,
+ ir, NULL, cr, -1, 0, 1.0, mdatoms,
ems->s.x, ems->s.x, NULL, fr->bMolPBC, ems->s.box,
ems->s.lambda[efptFEP], &dvdl_constr,
NULL, NULL, nrnb, econqCoord, FALSE, 0, 0);
*gstat = global_stat_init(ir);
}
- *outf = init_mdoutf(nfile, fnm, 0, cr, ir, NULL);
+ *outf = init_mdoutf(fplog, nfile, fnm, 0, cr, ir, top_global, NULL, wcycle);
snew(*enerd, 1);
init_enerdata(top_global->groups.grps[egcENER].nr, ir->fepvals->n_lambda,
if (mdebin != NULL)
{
/* Init bin for energy stuff */
- *mdebin = init_mdebin((*outf)->fp_ene, top_global, ir, NULL);
+ *mdebin = init_mdebin(mdoutf_get_fp_ene(*outf), top_global, ir, NULL);
}
clear_rvec(mu_tot);
calc_shifts(ems->s.box, fr->shift_vec);
}
-static void finish_em(t_commrec *cr, gmx_mdoutf_t *outf,
- gmx_runtime_t *runtime, gmx_wallcycle_t wcycle)
+static void finish_em(t_commrec *cr, gmx_mdoutf_t outf,
+ gmx_walltime_accounting_t walltime_accounting,
+ gmx_wallcycle_t wcycle)
{
if (!(cr->duty & DUTY_PME))
{
done_mdoutf(outf);
- em_time_end(runtime, wcycle);
+ em_time_end(walltime_accounting, wcycle);
}
static void swap_em_state(em_state_t *ems1, em_state_t *ems2)
}
static void write_em_traj(FILE *fplog, t_commrec *cr,
- gmx_mdoutf_t *outf,
+ gmx_mdoutf_t outf,
gmx_bool bX, gmx_bool bF, const char *confout,
gmx_mtop_t *top_global,
- t_inputrec *ir, gmx_large_int_t step,
+ t_inputrec *ir, gmx_int64_t step,
em_state_t *state,
t_state *state_global, rvec *f_global)
{
- int mdof_flags;
+ int mdof_flags;
+ gmx_bool bIMDout = FALSE;
+
+
+ /* Shall we do IMD output? */
+ if (ir->bIMD)
+ {
+ bIMDout = do_per_step(step, IMD_get_step(ir->imd->setup));
+ }
- if ((bX || bF || confout != NULL) && !DOMAINDECOMP(cr))
+ if ((bX || bF || bIMDout || confout != NULL) && !DOMAINDECOMP(cr))
{
copy_em_coords(state, state_global);
f_global = state->f;
{
mdof_flags |= MDOF_F;
}
- write_traj(fplog, cr, outf, mdof_flags,
- top_global, step, (double)step,
- &state->s, state_global, state->f, f_global, NULL, NULL);
+
+ /* If we want IMD output, set appropriate MDOF flag */
+ if (ir->bIMD)
+ {
+ mdof_flags |= MDOF_IMD;
+ }
+
+ mdoutf_write_to_trajectory_files(fplog, cr, outf, mdof_flags,
+ top_global, step, (double)step,
+ &state->s, state_global, state->f, f_global);
if (confout != NULL && MASTER(cr))
{
em_state_t *ems1, real a, rvec *f, em_state_t *ems2,
gmx_constr_t constr, gmx_localtop_t *top,
t_nrnb *nrnb, gmx_wallcycle_t wcycle,
- gmx_large_int_t count)
+ gmx_int64_t count)
{
t_state *s1, *s2;
}
copy_mat(s1->box, s2->box);
- start = md->start;
- end = md->start + md->homenr;
+ start = 0;
+ end = md->homenr;
x1 = s1->x;
x2 = s2->x;
wallcycle_start(wcycle, ewcCONSTR);
dvdl_constr = 0;
constrain(NULL, TRUE, TRUE, constr, &top->idef,
- ir, NULL, cr, count, 0, md,
+ ir, NULL, cr, count, 0, 1.0, md,
s1->x, s2->x, NULL, bMolPBC, s2->box,
s2->lambda[efptBONDED], &dvdl_constr,
NULL, NULL, nrnb, econqCoord, FALSE, 0, 0);
t_graph *graph, t_mdatoms *mdatoms,
t_forcerec *fr, rvec mu_tot,
gmx_enerdata_t *enerd, tensor vir, tensor pres,
- gmx_large_int_t count, gmx_bool bFirst)
+ gmx_int64_t count, gmx_bool bFirst)
{
real t;
gmx_bool bNS;
if (bFirst ||
(DOMAINDECOMP(cr) && ems->s.ddp_count < cr->dd->ddp_count))
{
- /* This the first state or an old state used before the last ns */
+ /* This is the first state or an old state used before the last ns */
bNS = TRUE;
}
else
{
construct_vsites(vsite, ems->s.x, 1, NULL,
top->idef.iparams, top->idef.il,
- fr->ePBC, fr->bMolPBC, graph, cr, ems->s.box);
+ fr->ePBC, fr->bMolPBC, cr, ems->s.box);
}
- if (DOMAINDECOMP(cr))
+ if (DOMAINDECOMP(cr) && bNS)
{
- if (bNS)
- {
- /* Repartition the domain decomposition */
- em_dd_partition_system(fplog, count, cr, top_global, inputrec,
- ems, top, mdatoms, fr, vsite, constr,
- nrnb, wcycle);
- }
+ /* Repartition the domain decomposition */
+ em_dd_partition_system(fplog, count, cr, top_global, inputrec,
+ ems, top, mdatoms, fr, vsite, constr,
+ nrnb, wcycle);
}
/* Calc force & energy on new trial position */
}
/* Calculate long range corrections to pressure and energy */
- calc_dispcorr(fplog, inputrec, fr, count, top_global->natoms, ems->s.box, ems->s.lambda[efptVDW],
+ calc_dispcorr(inputrec, fr, top_global->natoms, ems->s.box, ems->s.lambda[efptVDW],
pres, force_vir, &prescorr, &enercorr, &dvdlcorr);
enerd->term[F_DISPCORR] = enercorr;
enerd->term[F_EPOT] += enercorr;
wallcycle_start(wcycle, ewcCONSTR);
dvdl_constr = 0;
constrain(NULL, FALSE, FALSE, constr, &top->idef,
- inputrec, NULL, cr, count, 0, mdatoms,
+ inputrec, NULL, cr, count, 0, 1.0, mdatoms,
ems->s.x, ems->f, ems->f, fr->bMolPBC, ems->s.box,
ems->s.lambda[efptBONDED], &dvdl_constr,
NULL, &shake_vir, nrnb, econqForceDispl, FALSE, 0, 0);
- if (fr->bSepDVDL && fplog)
- {
- gmx_print_sepdvdl(fplog, "Constraints", t, dvdl_constr);
- }
enerd->term[F_DVDL_CONSTR] += dvdl_constr;
m_add(force_vir, shake_vir, vir);
wallcycle_stop(wcycle, ewcCONSTR);
/* This part of code can be incorrect with DD,
* since the atom ordering in s_b and s_min might differ.
*/
- for (i = mdatoms->start; i < mdatoms->start+mdatoms->homenr; i++)
+ for (i = 0; i < mdatoms->homenr; i++)
{
if (mdatoms->cFREEZE)
{
gmx_membed_t gmx_unused membed,
real gmx_unused cpt_period, real gmx_unused max_hours,
const char gmx_unused *deviceOptions,
+ int imdport,
unsigned long gmx_unused Flags,
- gmx_runtime_t *runtime)
+ gmx_walltime_accounting_t walltime_accounting)
{
const char *CG = "Polak-Ribiere Conjugate Gradients";
gmx_bool do_log = FALSE, do_ene = FALSE, do_x, do_f;
tensor vir, pres;
int number_steps, neval = 0, nstcg = inputrec->nstcgsteep;
- gmx_mdoutf_t *outf;
+ gmx_mdoutf_t outf;
int i, m, gf, step, nminstep;
real terminate = 0;
init_em(fplog, CG, cr, inputrec,
state_global, top_global, s_min, &top, &f, &f_global,
nrnb, mu_tot, fr, &enerd, &graph, mdatoms, &gstat, vsite, constr,
- nfile, fnm, &outf, &mdebin);
+ nfile, fnm, &outf, &mdebin, imdport, Flags, wcycle);
/* Print to log file */
- print_em_start(fplog, cr, runtime, wcycle, CG);
+ print_em_start(fplog, cr, walltime_accounting, wcycle, CG);
/* Max number of steps */
number_steps = inputrec->nsteps;
NULL, NULL, vir, pres, NULL, mu_tot, constr);
print_ebin_header(fplog, step, step, s_min->s.lambda[efptFEP]);
- print_ebin(outf->fp_ene, TRUE, FALSE, FALSE, fplog, step, step, eprNORMAL,
+ print_ebin(mdoutf_get_fp_ene(outf), TRUE, FALSE, FALSE, fplog, step, step, eprNORMAL,
TRUE, mdebin, fcd, &(top_global->groups), &(inputrec->opts));
}
where();
sf = s_min->f;
gpa = 0;
gf = 0;
- for (i = mdatoms->start; i < mdatoms->start+mdatoms->homenr; i++)
+ for (i = 0; i < mdatoms->homenr; i++)
{
if (mdatoms->cFREEZE)
{
* relative change in coordinate is smaller than precision
*/
minstep = 0;
- for (i = mdatoms->start; i < mdatoms->start+mdatoms->homenr; i++)
+ for (i = 0; i < mdatoms->homenr; i++)
{
for (m = 0; m < DIM; m++)
{
p = s_c->s.cg_p;
sf = s_c->f;
gpc = 0;
- for (i = mdatoms->start; i < mdatoms->start+mdatoms->homenr; i++)
+ for (i = 0; i < mdatoms->homenr; i++)
{
for (m = 0; m < DIM; m++)
{
p = s_b->s.cg_p;
sf = s_b->f;
gpb = 0;
- for (i = mdatoms->start; i < mdatoms->start+mdatoms->homenr; i++)
+ for (i = 0; i < mdatoms->homenr; i++)
{
for (m = 0; m < DIM; m++)
{
do_log = do_per_step(step, inputrec->nstlog);
do_ene = do_per_step(step, inputrec->nstenergy);
+
+ /* Prepare IMD energy record, if bIMD is TRUE. */
+ IMD_fill_energy_record(inputrec->bIMD, inputrec->imd, enerd, step, TRUE);
+
if (do_log)
{
print_ebin_header(fplog, step, step, s_min->s.lambda[efptFEP]);
}
- print_ebin(outf->fp_ene, do_ene, FALSE, FALSE,
+ print_ebin(mdoutf_get_fp_ene(outf), do_ene, FALSE, FALSE,
do_log ? fplog : NULL, step, step, eprNORMAL,
TRUE, mdebin, fcd, &(top_global->groups), &(inputrec->opts));
}
+ /* Send energies and positions to the IMD client if bIMD is TRUE. */
+ if (do_IMD(inputrec->bIMD, step, cr, TRUE, state_global->box, state_global->x, inputrec, 0, wcycle) && MASTER(cr))
+ {
+ IMD_send_positions(inputrec->imd);
+ }
+
/* Stop when the maximum force lies below tolerance.
* If we have reached machine precision, converged is already set to true.
*/
} /* End of the loop */
+ /* IMD cleanup, if bIMD is TRUE. */
+ IMD_finalize(inputrec->bIMD, inputrec->imd);
+
if (converged)
{
step--; /* we never took that last step in this case */
if (!do_ene || !do_log)
{
/* Write final energy file entries */
- print_ebin(outf->fp_ene, !do_ene, FALSE, FALSE,
+ print_ebin(mdoutf_get_fp_ene(outf), !do_ene, FALSE, FALSE,
!do_log ? fplog : NULL, step, step, eprNORMAL,
TRUE, mdebin, fcd, &(top_global->groups), &(inputrec->opts));
}
fprintf(fplog, "\nPerformed %d energy evaluations in total.\n", neval);
}
- finish_em(cr, outf, runtime, wcycle);
+ finish_em(cr, outf, walltime_accounting, wcycle);
/* To print the actual number of steps we needed somewhere */
- runtime->nsteps_done = step;
+ walltime_accounting_set_nsteps_done(walltime_accounting, step);
return 0;
} /* That's all folks */
gmx_membed_t gmx_unused membed,
real gmx_unused cpt_period, real gmx_unused max_hours,
const char gmx_unused *deviceOptions,
+ int imdport,
unsigned long gmx_unused Flags,
- gmx_runtime_t *runtime)
+ gmx_walltime_accounting_t walltime_accounting)
{
static const char *LBFGS = "Low-Memory BFGS Minimizer";
em_state_t ems;
gmx_bool do_log, do_ene, do_x, do_f, foundlower, *frozen;
tensor vir, pres;
int start, end, number_steps;
- gmx_mdoutf_t *outf;
+ gmx_mdoutf_t outf;
int i, k, m, n, nfmax, gf, step;
int mdof_flags;
/* not used */
init_em(fplog, LBFGS, cr, inputrec,
state, top_global, &ems, &top, &f, &f_global,
nrnb, mu_tot, fr, &enerd, &graph, mdatoms, &gstat, vsite, constr,
- nfile, fnm, &outf, &mdebin);
+ nfile, fnm, &outf, &mdebin, imdport, Flags, wcycle);
/* Do_lbfgs is not completely updated like do_steep and do_cg,
* so we free some memory again.
*/
xx = (real *)state->x;
ff = (real *)f;
- start = mdatoms->start;
- end = mdatoms->homenr + start;
+ start = 0;
+ end = mdatoms->homenr;
/* Print to log file */
- print_em_start(fplog, cr, runtime, wcycle, LBFGS);
+ print_em_start(fplog, cr, walltime_accounting, wcycle, LBFGS);
do_log = do_ene = do_x = do_f = TRUE;
{
construct_vsites(vsite, state->x, 1, NULL,
top->idef.iparams, top->idef.il,
- fr->ePBC, fr->bMolPBC, graph, cr, state->box);
+ fr->ePBC, fr->bMolPBC, cr, state->box);
}
/* Call the force routine and some auxiliary (neighboursearching etc.) */
NULL, NULL, vir, pres, NULL, mu_tot, constr);
print_ebin_header(fplog, step, step, state->lambda[efptFEP]);
- print_ebin(outf->fp_ene, TRUE, FALSE, FALSE, fplog, step, step, eprNORMAL,
+ print_ebin(mdoutf_get_fp_ene(outf), TRUE, FALSE, FALSE, fplog, step, step, eprNORMAL,
TRUE, mdebin, fcd, &(top_global->groups), &(inputrec->opts));
}
where();
}
stepsize = 1.0/fnorm;
- converged = FALSE;
/* Start the loop over BFGS steps.
* Each successful step is counted, and we continue until
mdof_flags |= MDOF_F;
}
- write_traj(fplog, cr, outf, mdof_flags,
- top_global, step, (real)step, state, state, f, f, NULL, NULL);
+ if (inputrec->bIMD)
+ {
+ mdof_flags |= MDOF_IMD;
+ }
+
+ mdoutf_write_to_trajectory_files(fplog, cr, outf, mdof_flags,
+ top_global, step, (real)step, state, state, f, f);
/* Do the linesearching in the direction dx[point][0..(n-1)] */
{
print_ebin_header(fplog, step, step, state->lambda[efptFEP]);
}
- print_ebin(outf->fp_ene, do_ene, FALSE, FALSE,
+ print_ebin(mdoutf_get_fp_ene(outf), do_ene, FALSE, FALSE,
do_log ? fplog : NULL, step, step, eprNORMAL,
TRUE, mdebin, fcd, &(top_global->groups), &(inputrec->opts));
}
+ /* Send x and E to IMD client, if bIMD is TRUE. */
+ if (do_IMD(inputrec->bIMD, step, cr, TRUE, state->box, state->x, inputrec, 0, wcycle) && MASTER(cr))
+ {
+ IMD_send_positions(inputrec->imd);
+ }
+
/* Stop when the maximum force lies below tolerance.
* If we have reached machine precision, converged is already set to true.
*/
} /* End of the loop */
+ /* IMD cleanup, if bIMD is TRUE. */
+ IMD_finalize(inputrec->bIMD, inputrec->imd);
+
if (converged)
{
step--; /* we never took that last step in this case */
}
if (!do_ene || !do_log) /* Write final energy file entries */
{
- print_ebin(outf->fp_ene, !do_ene, FALSE, FALSE,
+ print_ebin(mdoutf_get_fp_ene(outf), !do_ene, FALSE, FALSE,
!do_log ? fplog : NULL, step, step, eprNORMAL,
TRUE, mdebin, fcd, &(top_global->groups), &(inputrec->opts));
}
fprintf(fplog, "\nPerformed %d energy evaluations in total.\n", neval);
}
- finish_em(cr, outf, runtime, wcycle);
+ finish_em(cr, outf, walltime_accounting, wcycle);
/* To print the actual number of steps we needed somewhere */
- runtime->nsteps_done = step;
+ walltime_accounting_set_nsteps_done(walltime_accounting, step);
return 0;
} /* That's all folks */
gmx_membed_t gmx_unused membed,
real gmx_unused cpt_period, real gmx_unused max_hours,
const char gmx_unused *deviceOptions,
+ int imdport,
unsigned long gmx_unused Flags,
- gmx_runtime_t *runtime)
+ gmx_walltime_accounting_t walltime_accounting)
{
const char *SD = "Steepest Descents";
em_state_t *s_min, *s_try;
t_graph *graph;
real stepsize, constepsize;
real ustep, fnormn;
- gmx_mdoutf_t *outf;
+ gmx_mdoutf_t outf;
t_mdebin *mdebin;
gmx_bool bDone, bAbort, do_x, do_f;
tensor vir, pres;
init_em(fplog, SD, cr, inputrec,
state_global, top_global, s_try, &top, &f, &f_global,
nrnb, mu_tot, fr, &enerd, &graph, mdatoms, &gstat, vsite, constr,
- nfile, fnm, &outf, &mdebin);
+ nfile, fnm, &outf, &mdebin, imdport, Flags, wcycle);
/* Print to log file */
- print_em_start(fplog, cr, runtime, wcycle, SD);
+ print_em_start(fplog, cr, walltime_accounting, wcycle, SD);
/* Set variables for stepsize (in nm). This is the largest
* step that we are going to make in any direction.
upd_mdebin(mdebin, FALSE, FALSE, (double)count,
mdatoms->tmass, enerd, &s_try->s, inputrec->fepvals, inputrec->expandedvals,
s_try->s.box, NULL, NULL, vir, pres, NULL, mu_tot, constr);
- print_ebin(outf->fp_ene, TRUE,
+
+ /* Prepare IMD energy record, if bIMD is TRUE. */
+ IMD_fill_energy_record(inputrec->bIMD, inputrec->imd, enerd, count, TRUE);
+
+ print_ebin(mdoutf_get_fp_ene(outf), TRUE,
do_per_step(steps_accepted, inputrec->nstdisreout),
do_per_step(steps_accepted, inputrec->nstorireout),
fplog, count, count, eprNORMAL, TRUE,
bAbort = TRUE;
}
+ /* Send IMD energies and positions, if bIMD is TRUE. */
+ if (do_IMD(inputrec->bIMD, count, cr, TRUE, state_global->box, state_global->x, inputrec, 0, wcycle) && MASTER(cr))
+ {
+ IMD_send_positions(inputrec->imd);
+ }
+
count++;
} /* End of the loop */
- /* Print some shit... */
+ /* IMD cleanup, if bIMD is TRUE. */
+ IMD_finalize(inputrec->bIMD, inputrec->imd);
+
+ /* Print some data... */
if (MASTER(cr))
{
fprintf(stderr, "\nwriting lowest energy coordinates.\n");
s_min->epot, s_min->fmax, s_min->a_fmax, fnormn);
}
- finish_em(cr, outf, runtime, wcycle);
+ finish_em(cr, outf, walltime_accounting, wcycle);
/* To print the actual number of steps we needed somewhere */
inputrec->nsteps = count;
- runtime->nsteps_done = count;
+ walltime_accounting_set_nsteps_done(walltime_accounting, count);
return 0;
} /* That's all folks */
gmx_membed_t gmx_unused membed,
real gmx_unused cpt_period, real gmx_unused max_hours,
const char gmx_unused *deviceOptions,
+ int imdport,
unsigned long gmx_unused Flags,
- gmx_runtime_t *runtime)
+ gmx_walltime_accounting_t walltime_accounting)
{
const char *NM = "Normal Mode Analysis";
- gmx_mdoutf_t *outf;
+ gmx_mdoutf_t outf;
int natoms, atom, d;
int nnodes, node;
rvec *f_global;
rvec mu_tot;
rvec *fneg, *dfdx;
gmx_bool bSparse; /* use sparse matrix storage format */
- size_t sz=0;
+ size_t sz = 0;
gmx_sparsematrix_t * sparse_matrix = NULL;
real * full_matrix = NULL;
em_state_t * state_work;
state_global, top_global, state_work, &top,
&f, &f_global,
nrnb, mu_tot, fr, &enerd, &graph, mdatoms, &gstat, vsite, constr,
- nfile, fnm, &outf, NULL);
+ nfile, fnm, &outf, NULL, imdport, Flags, wcycle);
natoms = top_global->natoms;
snew(fneg, natoms);
where();
/* Write start time and temperature */
- print_em_start(fplog, cr, runtime, wcycle, NM);
+ print_em_start(fplog, cr, walltime_accounting, wcycle, NM);
/* fudge nr of steps to nr of atoms */
inputrec->nsteps = natoms*2;
gmx_mtxio_write(ftp2fn(efMTX, nfile, fnm), sz, sz, full_matrix, sparse_matrix);
}
- finish_em(cr, outf, runtime, wcycle);
+ finish_em(cr, outf, walltime_accounting, wcycle);
- runtime->nsteps_done = natoms*2;
+ walltime_accounting_set_nsteps_done(walltime_accounting, natoms*2);
return 0;
}