#include "gromacs/mdtypes/inputrec.h"
#include "gromacs/mdtypes/md_enums.h"
#include "gromacs/mdtypes/mdatom.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/pbcutil/pbc.h"
#include "gromacs/pulling/pull.h"
gmx::SimulationSignaller* signalCoordinator,
const matrix lastbox,
gmx_bool* bSumEkinhOld,
- const int flags)
+ const int flags,
+ int64_t step,
+ gmx::ObservablesReducer* observablesReducer)
{
gmx_bool bEner, bPres, bTemp;
gmx_bool bStopCM, bGStat, bReadEkin, bEkinAveVel, bScaleEkin, bConstrain;
calc_vcm_grp(*mdatoms, x, v, vcm);
}
- if (bTemp || bStopCM || bPres || bEner || bConstrain || bCheckNumberOfBondedInteractions)
+ if (bTemp || bStopCM || bPres || bEner || bConstrain || bCheckNumberOfBondedInteractions
+ || !observablesReducer->communicationBuffer().empty())
{
if (!bGStat)
{
bStopCM ? vcm : nullptr,
signalBuffer,
*bSumEkinhOld,
- flags);
+ flags,
+ step,
+ observablesReducer);
wallcycle_stop(wcycle, WallCycleCounter::MoveE);
}
signalCoordinator->finalizeSignals();
#ifndef GMX_MDLIB_MD_SUPPORT_H
#define GMX_MDLIB_MD_SUPPORT_H
+#include <cstdint>
+
#include "gromacs/mdlib/vcm.h"
#include "gromacs/mdtypes/md_enums.h"
#include "gromacs/timing/wallcycle.h"
class ArrayRef;
class Constraints;
class MDLogger;
+class ObservablesReducer;
class SimulationSignaller;
} // namespace gmx
gmx::SimulationSignaller* signalCoordinator,
const matrix lastbox,
gmx_bool* bSumEkinhOld,
- int flags);
+ int flags,
+ int64_t step,
+ gmx::ObservablesReducer* observablesReducer);
#endif
#include "gromacs/mdtypes/group.h"
#include "gromacs/mdtypes/inputrec.h"
#include "gromacs/mdtypes/md_enums.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/utility/fatalerror.h"
#include "gromacs/utility/futil.h"
#include "gromacs/utility/smalloc.h"
return to;
}
-void global_stat(const gmx_global_stat& gs,
- const t_commrec* cr,
- gmx_enerdata_t* enerd,
- tensor fvir,
- tensor svir,
- const t_inputrec& inputrec,
- gmx_ekindata_t* ekind,
- gmx::ArrayRef<real> constraintsRmsdData,
- t_vcm* vcm,
- gmx::ArrayRef<real> sig,
- bool bSumEkinhOld,
- int flags)
+void global_stat(const gmx_global_stat& gs,
+ const t_commrec* cr,
+ gmx_enerdata_t* enerd,
+ tensor fvir,
+ tensor svir,
+ const t_inputrec& inputrec,
+ gmx_ekindata_t* ekind,
+ gmx::ArrayRef<real> constraintsRmsdData,
+ t_vcm* vcm,
+ gmx::ArrayRef<real> sig,
+ bool bSumEkinhOld,
+ int flags,
+ int64_t step,
+ gmx::ObservablesReducer* observablesReducer)
/* instead of current system, gmx_booleans for summing virial, kinetic energy, and other terms */
{
int ie = 0, ifv = 0, isv = 0, irmsd = 0;
|| (inputrec.eI == IntegrationAlgorithm::VVAK && bPres));
bool bReadEkin = ((flags & CGLO_READEKIN) != 0);
+ // This structure implements something akin to a vector. As
+ // modules add their data into it with add_bin[rd], they save the
+ // index it returns, which allows them to look up their data later
+ // after the reduction with extract_bin[rd]. The various index
+ // variables are mostly named following the pattern
+ // "i<abbreviation for module>".
t_bin* rb = gs.rb;
int* itc0 = gs.itc0;
int* itc1 = gs.itc1;
isig = add_binr(rb, sig);
}
+ gmx::ArrayRef<double> observablesReducerBuffer = observablesReducer->communicationBuffer();
+ int tbinIndexForObservablesReducer = 0;
+ if (!observablesReducerBuffer.empty())
+ {
+ tbinIndexForObservablesReducer =
+ add_bind(rb, observablesReducerBuffer.ssize(), observablesReducerBuffer.data());
+ }
+
sum_bin(rb, cr);
/* Extract all the data locally */
{
extract_binr(rb, isig, sig);
}
+
+ if (!observablesReducerBuffer.empty())
+ {
+ extract_bind(rb,
+ tbinIndexForObservablesReducer,
+ observablesReducerBuffer.ssize(),
+ observablesReducerBuffer.data());
+ observablesReducer->reductionComplete(step);
+ }
}
template<typename T>
class ArrayRef;
class Constraints;
+class ObservablesReducer;
} // namespace gmx
typedef struct gmx_global_stat* gmx_global_stat_t;
void global_stat_destroy(gmx_global_stat_t gs);
/*! \brief All-reduce energy-like quantities over cr->mpi_comm_mysim */
-void global_stat(const gmx_global_stat& gs,
- const t_commrec* cr,
- gmx_enerdata_t* enerd,
- tensor fvir,
- tensor svir,
- const t_inputrec& inputrec,
- gmx_ekindata_t* ekind,
- gmx::ArrayRef<real> constraintsRmsdData,
- t_vcm* vcm,
- gmx::ArrayRef<real> sig,
- bool bSumEkinhOld,
- int flags);
+void global_stat(const gmx_global_stat& gs,
+ const t_commrec* cr,
+ gmx_enerdata_t* enerd,
+ tensor fvir,
+ tensor svir,
+ const t_inputrec& inputrec,
+ gmx_ekindata_t* ekind,
+ gmx::ArrayRef<real> constraintsRmsdData,
+ t_vcm* vcm,
+ gmx::ArrayRef<real> sig,
+ bool bSumEkinhOld,
+ int flags,
+ int64_t step,
+ gmx::ObservablesReducer* observablesReducer);
/*! \brief Returns TRUE if io should be done */
inline bool do_per_step(int64_t step, int64_t nstep)
t_vcm* vcm,
const gmx_localtop_t& top,
gmx_enerdata_t* enerd,
+ gmx::ObservablesReducer* observablesReducer,
gmx_ekindata_t* ekind,
gmx_global_stat* gstat,
real* last_ekin,
nullSignaller,
state->box,
bSumEkinhOld,
- cglo_flags);
+ cglo_flags,
+ step,
+ observablesReducer);
/* explanation of above:
a) We compute Ekin at the full time step
if 1) we are using the AveVel Ekin, and it's not the
nullSignaller,
state->box,
bSumEkinhOld,
- CGLO_GSTAT | CGLO_TEMPERATURE);
+ CGLO_GSTAT | CGLO_TEMPERATURE,
+ step,
+ observablesReducer);
wallcycle_start(wcycle, WallCycleCounter::Update);
}
}
}
}
-void integrateVVSecondStep(int64_t step,
- const t_inputrec* ir,
- t_forcerec* fr,
- t_commrec* cr,
- t_state* state,
- t_mdatoms* mdatoms,
- t_fcdata* fcdata,
- t_extmass* MassQ,
- t_vcm* vcm,
- pull_t* pull_work,
- gmx_enerdata_t* enerd,
- gmx_ekindata_t* ekind,
- gmx_global_stat* gstat,
- real* dvdl_constr,
- bool bCalcVir,
- tensor total_vir,
- tensor shake_vir,
- tensor force_vir,
- tensor pres,
- matrix M,
- matrix lastbox,
- bool do_log,
- bool do_ene,
- bool bGStat,
- bool* bSumEkinhOld,
- gmx::ForceBuffers* f,
- std::vector<gmx::RVec>* cbuf,
- gmx::Update* upd,
- gmx::Constraints* constr,
- gmx::SimulationSignaller* nullSignaller,
+void integrateVVSecondStep(int64_t step,
+ const t_inputrec* ir,
+ t_forcerec* fr,
+ t_commrec* cr,
+ t_state* state,
+ t_mdatoms* mdatoms,
+ t_fcdata* fcdata,
+ t_extmass* MassQ,
+ t_vcm* vcm,
+ pull_t* pull_work,
+ gmx_enerdata_t* enerd,
+ gmx::ObservablesReducer* observablesReducer,
+ gmx_ekindata_t* ekind,
+ gmx_global_stat* gstat,
+ real* dvdl_constr,
+ bool bCalcVir,
+ tensor total_vir,
+ tensor shake_vir,
+ tensor force_vir,
+ tensor pres,
+ matrix M,
+ matrix lastbox,
+ bool do_log,
+ bool do_ene,
+ bool bGStat,
+ bool* bSumEkinhOld,
+ gmx::ForceBuffers* f,
+ std::vector<gmx::RVec>* cbuf,
+ gmx::Update* upd,
+ gmx::Constraints* constr,
+ gmx::SimulationSignaller* nullSignaller,
gmx::EnumerationArray<TrotterSequence, std::vector<int>> trotter_seq,
t_nrnb* nrnb,
gmx_wallcycle* wcycle)
nullSignaller,
lastbox,
bSumEkinhOld,
- (bGStat ? CGLO_GSTAT : 0) | CGLO_TEMPERATURE);
+ (bGStat ? CGLO_GSTAT : 0) | CGLO_TEMPERATURE,
+ step,
+ observablesReducer);
wallcycle_start(wcycle, WallCycleCounter::Update);
trotter_update(ir,
step,
class Constraints;
class ForceBuffers;
class MDLogger;
+class ObservablesReducer;
class SimulationSignaller;
class Update;
enum class StartingBehavior : int;
* \param[in] vcm Center of mass motion removal.
* \param[in] top Local topology.
* \param[in] enerd Energy data.
+ * \param[in] observablesReducer Pointer to the \c ObservablesReducer object
* \param[in] ekind Kinetic energy data.
* \param[in] gstat Storage of thermodynamic parameters data.
* \param[out] last_ekin Kinetic energies of the last step.
t_vcm* vcm,
const gmx_localtop_t& top,
gmx_enerdata_t* enerd,
+ gmx::ObservablesReducer* observablesReducer,
gmx_ekindata_t* ekind,
gmx_global_stat* gstat,
real* last_ekin,
* \param[in] vcm Center of mass motion removal.
* \param[in] pull_work Pulling data.
* \param[in] enerd Energy data.
+ * \param[in] observablesReducer Pointer to the \c ObservablesReducer object
* \param[in] ekind Kinetic energy data.
* \param[in] gstat Storage of thermodynamic parameters data.
* \param[out] dvdl_constr FEP data for constraints.
* \param[in] nrnb Cycle counters.
* \param[in] wcycle Wall-clock cycle counter.
*/
-void integrateVVSecondStep(int64_t step,
- const t_inputrec* ir,
- t_forcerec* fr,
- t_commrec* cr,
- t_state* state,
- t_mdatoms* mdatoms,
- t_fcdata* fcdata,
- t_extmass* MassQ,
- t_vcm* vcm,
- pull_t* pull_work,
- gmx_enerdata_t* enerd,
- gmx_ekindata_t* ekind,
- gmx_global_stat* gstat,
- real* dvdl_constr,
- bool bCalcVir,
- tensor total_vir,
- tensor shake_vir,
- tensor force_vir,
- tensor pres,
- matrix M,
- matrix lastbox,
- bool do_log,
- bool do_ene,
- bool bGStat,
- bool* bSumEkinhOld,
- gmx::ForceBuffers* f,
- std::vector<gmx::RVec>* cbuf,
- gmx::Update* upd,
- gmx::Constraints* constr,
- gmx::SimulationSignaller* nullSignaller,
+void integrateVVSecondStep(int64_t step,
+ const t_inputrec* ir,
+ t_forcerec* fr,
+ t_commrec* cr,
+ t_state* state,
+ t_mdatoms* mdatoms,
+ t_fcdata* fcdata,
+ t_extmass* MassQ,
+ t_vcm* vcm,
+ pull_t* pull_work,
+ gmx_enerdata_t* enerd,
+ gmx::ObservablesReducer* observablesReducer,
+ gmx_ekindata_t* ekind,
+ gmx_global_stat* gstat,
+ real* dvdl_constr,
+ bool bCalcVir,
+ tensor total_vir,
+ tensor shake_vir,
+ tensor force_vir,
+ tensor pres,
+ matrix M,
+ matrix lastbox,
+ bool do_log,
+ bool do_ene,
+ bool bGStat,
+ bool* bSumEkinhOld,
+ gmx::ForceBuffers* f,
+ std::vector<gmx::RVec>* cbuf,
+ gmx::Update* upd,
+ gmx::Constraints* constr,
+ gmx::SimulationSignaller* nullSignaller,
gmx::EnumerationArray<TrotterSequence, std::vector<int>> trotter_seq,
t_nrnb* nrnb,
gmx_wallcycle* wcycle);
class ImdSession;
class MDLogger;
class MDAtoms;
+class ObservablesReducerBuilder;
class StopHandlerBuilder;
struct MdrunOptions;
class VirtualSitesHandler;
gmx_wallcycle* wcycle,
t_forcerec* fr,
gmx_enerdata_t* enerd,
+ ObservablesReducerBuilder* observablesReducerBuilder,
gmx_ekindata_t* ekind,
MdrunScheduleWorkload* runScheduleWork,
const ReplicaExchangeParameters& replExParams,
wcycle(wcycle),
fr(fr),
enerd(enerd),
+ observablesReducerBuilder(observablesReducerBuilder),
ekind(ekind),
runScheduleWork(runScheduleWork),
replExParams(replExParams),
t_forcerec* fr;
//! Data for energy output.
gmx_enerdata_t* enerd;
+ //! Builder for coordinator of reduction for observables
+ ObservablesReducerBuilder* observablesReducerBuilder;
//! Kinetic energy data.
gmx_ekindata_t* ekind;
//! Schedule of work for each MD step for this task.
#include "gromacs/mdtypes/mdrunoptions.h"
#include "gromacs/mdtypes/multipletimestepping.h"
#include "gromacs/mdtypes/observableshistory.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/mdtypes/pullhistory.h"
#include "gromacs/mdtypes/simulation_workload.h"
#include "gromacs/mdtypes/state.h"
std::unique_ptr<t_state> stateInstance;
t_state* state;
- gmx_localtop_t top(top_global.ffparams);
+ gmx_localtop_t top(top_global.ffparams);
+ ObservablesReducer observablesReducer = observablesReducerBuilder->build();
ForceBuffers f(simulationWork.useMts,
((useGpuForNonbonded && useGpuForBufferOps) || useGpuForUpdate)
t_vcm vcm(top_global.groups, *ir);
reportComRemovalInfo(fplog, vcm);
+ int64_t step = ir->init_step;
+ int64_t step_rel = 0;
+
/* To minimize communication, compute_globals computes the COM velocity
* and the kinetic energy for the velocities without COM motion removed.
* Thus to get the kinetic energy without the COM contribution, we need
&nullSignaller,
state->box,
&bSumEkinhOld,
- cglo_flags_iteration);
+ cglo_flags_iteration,
+ step,
+ &observablesReducer);
if (cglo_flags_iteration & CGLO_STOPCM)
{
/* At initialization, do not pass x with acceleration-correction mode
&nullSignaller,
state->box,
&bSumEkinhOld,
- cglo_flags & ~CGLO_PRESSURE);
+ cglo_flags & ~CGLO_PRESSURE,
+ step,
+ &observablesReducer);
}
/* Calculate the initial half step temperature, and save the ekinh_old */
bExchanged = FALSE;
bNeedRepartition = FALSE;
- int64_t step = ir->init_step;
- int64_t step_rel = 0;
-
auto stopHandler = stopHandlerBuilder->getStopHandlerMD(
compat::not_null<SimulationSignal*>(&signals[eglsSTOPCOND]),
simulationsShareState,
&nullSignaller,
state->box,
&bSumEkinhOld,
- cglo_flags);
+ cglo_flags,
+ step,
+ &observablesReducer);
if (DOMAINDECOMP(cr))
{
dd_localTopologyChecker(cr->dd)->checkNumberOfBondedInteractions(
&vcm,
top,
enerd,
+ &observablesReducer,
ekind,
gstat,
&last_ekin,
&vcm,
pull_work,
enerd,
+ &observablesReducer,
ekind,
gstat,
&dvdl_constr,
| (!EI_VV(ir->eI) ? CGLO_PRESSURE : 0) | CGLO_CONSTRAINT
| (DOMAINDECOMP(cr) && dd_localTopologyChecker(*cr->dd).shouldCheckNumberOfBondedInteractions()
? CGLO_CHECK_NUMBER_OF_BONDED_INTERACTIONS
- : 0));
+ : 0),
+ step,
+ &observablesReducer);
if (DOMAINDECOMP(cr))
{
dd_localTopologyChecker(cr->dd)->checkNumberOfBondedInteractions(
#include "gromacs/mdtypes/mdatom.h"
#include "gromacs/mdtypes/mdrunoptions.h"
#include "gromacs/mdtypes/observableshistory.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/mdtypes/simulation_workload.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/mimic/communicator.h"
int nstglobalcomm = 1;
const bool bNS = true;
+ ObservablesReducer observablesReducer = observablesReducerBuilder->build();
+
if (MASTER(cr))
{
MimicCommunicator::init();
doFreeEnergyPerturbation = true;
}
+ int64_t step = ir->init_step;
+ int64_t step_rel = 0;
+
{
int cglo_flags = CGLO_GSTAT;
if (DOMAINDECOMP(cr) && dd_localTopologyChecker(*cr->dd).shouldCheckNumberOfBondedInteractions())
&nullSignaller,
state->box,
&bSumEkinhOld,
- cglo_flags);
+ cglo_flags,
+ step,
+ &observablesReducer);
if (DOMAINDECOMP(cr))
{
dd_localTopologyChecker(cr->dd)->checkNumberOfBondedInteractions(
"MiMiC does not report kinetic energy, total energy, temperature, virial and "
"pressure.");
- int64_t step = ir->init_step;
- int64_t step_rel = 0;
-
auto stopHandler = stopHandlerBuilder->getStopHandlerMD(
compat::not_null<SimulationSignal*>(&signals[eglsSTOPCOND]),
false,
&signaller,
state->box,
&bSumEkinhOld,
- cglo_flags);
+ cglo_flags,
+ step,
+ &observablesReducer);
if (DOMAINDECOMP(cr))
{
dd_localTopologyChecker(cr->dd)->checkNumberOfBondedInteractions(
#include "gromacs/mdtypes/md_enums.h"
#include "gromacs/mdtypes/mdatom.h"
#include "gromacs/mdtypes/mdrunoptions.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/pbcutil/pbc.h"
#include "gromacs/timing/wallcycle.h"
* unsuited for aggregate initialization. When the types
* improve, the call signature of this method can be reduced.
*/
- void run(em_state_t* ems, rvec mu_tot, tensor vir, tensor pres, int64_t count, gmx_bool bFirst);
+ void run(em_state_t* ems, rvec mu_tot, tensor vir, tensor pres, int64_t count, gmx_bool bFirst, int64_t step);
//! Handles logging (deprecated).
FILE* fplog;
//! Handles logging.
t_nrnb* nrnb;
//! Manages wall cycle accounting.
gmx_wallcycle* wcycle;
- //! Coordinates global reduction.
+ //! Legacy coordinator of global reduction.
gmx_global_stat_t gstat;
+ //! Coordinates reduction for observables
+ gmx::ObservablesReducer* observablesReducer;
//! Handles virtual sites.
VirtualSitesHandler* vsite;
//! Handles constraints.
std::vector<RVec> pairSearchCoordinates;
};
-void EnergyEvaluator::run(em_state_t* ems, rvec mu_tot, tensor vir, tensor pres, int64_t count, gmx_bool bFirst)
+void EnergyEvaluator::run(em_state_t* ems, rvec mu_tot, tensor vir, tensor pres, int64_t count, gmx_bool bFirst, int64_t step)
{
real t;
gmx_bool bNS;
nullptr,
std::vector<real>(1, terminate),
FALSE,
- CGLO_ENERGY | CGLO_PRESSURE | CGLO_CONSTRAINT);
+ CGLO_ENERGY | CGLO_PRESSURE | CGLO_CONSTRAINT,
+ step,
+ observablesReducer);
wallcycle_stop(wcycle, WallCycleCounter::MoveE);
}
em_state_t* s_b = &s2;
em_state_t* s_c = &s3;
+ ObservablesReducer observablesReducer = observablesReducerBuilder->build();
+
/* Init em and store the local state in s_min */
init_em(fplog,
mdlog,
sp_header(fplog, CG, inputrec->em_tol, number_steps);
}
- EnergyEvaluator energyEvaluator{ fplog, mdlog, cr, ms, top_global,
- &top, inputrec, imdSession, pull_work, nrnb,
- wcycle, gstat, vsite, constr, mdAtoms,
- fr, runScheduleWork, enerd, -1, {} };
+ EnergyEvaluator energyEvaluator{ fplog,
+ mdlog,
+ cr,
+ ms,
+ top_global,
+ &top,
+ inputrec,
+ imdSession,
+ pull_work,
+ nrnb,
+ wcycle,
+ gstat,
+ &observablesReducer,
+ vsite,
+ constr,
+ mdAtoms,
+ fr,
+ runScheduleWork,
+ enerd,
+ -1,
+ {} };
/* Call the force routine and some auxiliary (neighboursearching etc.) */
/* do_force always puts the charge groups in the box and shifts again
* We do not unshift, so molecules are always whole in congrad.c
*/
- energyEvaluator.run(s_min, mu_tot, vir, pres, -1, TRUE);
+ energyEvaluator.run(s_min, mu_tot, vir, pres, -1, TRUE, step);
if (MASTER(cr))
{
neval++;
/* Calculate energy for the trial step */
- energyEvaluator.run(s_c, mu_tot, vir, pres, -1, FALSE);
+ energyEvaluator.run(s_c, mu_tot, vir, pres, -1, FALSE, step);
/* Calc derivative along line */
const rvec* pc = s_c->s.cg_p.rvec_array();
neval++;
/* Calculate energy for the trial step */
- energyEvaluator.run(s_b, mu_tot, vir, pres, -1, FALSE);
+ energyEvaluator.run(s_b, mu_tot, vir, pres, -1, FALSE, step);
/* p does not change within a step, but since the domain decomposition
* might change, we have to use cg_p of s_b here.
int step = 0;
int neval = 0;
+ ObservablesReducer observablesReducer = observablesReducerBuilder->build();
+
/* Init em */
init_em(fplog,
mdlog,
* We do not unshift, so molecules are always whole
*/
neval++;
- EnergyEvaluator energyEvaluator{ fplog, mdlog, cr, ms, top_global, &top,
- inputrec, imdSession, pull_work, nrnb, wcycle, gstat,
- vsite, constr, mdAtoms, fr, runScheduleWork, enerd };
+ EnergyEvaluator energyEvaluator{ fplog,
+ mdlog,
+ cr,
+ ms,
+ top_global,
+ &top,
+ inputrec,
+ imdSession,
+ pull_work,
+ nrnb,
+ wcycle,
+ gstat,
+ &observablesReducer,
+ vsite,
+ constr,
+ mdAtoms,
+ fr,
+ runScheduleWork,
+ enerd };
rvec mu_tot;
tensor vir;
tensor pres;
- energyEvaluator.run(&ems, mu_tot, vir, pres, -1, TRUE);
+ energyEvaluator.run(&ems, mu_tot, vir, pres, -1, TRUE, step);
if (MASTER(cr))
{
neval++;
// Calculate energy for the trial step in position C
- energyEvaluator.run(sc, mu_tot, vir, pres, step, FALSE);
+ energyEvaluator.run(sc, mu_tot, vir, pres, step, FALSE, step);
// Calc line gradient in position C
real* fc = static_cast<real*>(sc->f.view().force()[0]);
neval++;
// Calculate energy for the trial step in point B
- energyEvaluator.run(sb, mu_tot, vir, pres, step, FALSE);
+ energyEvaluator.run(sb, mu_tot, vir, pres, step, FALSE, step);
fnorm = sb->fnorm;
// Calculate gradient in point B
em_state_t* s_min = &s0;
em_state_t* s_try = &s1;
+ ObservablesReducer observablesReducer = observablesReducerBuilder->build();
+
/* Init em and store the local state in s_try */
init_em(fplog,
mdlog,
{
sp_header(fplog, SD, inputrec->em_tol, nsteps);
}
- EnergyEvaluator energyEvaluator{ fplog, mdlog, cr, ms, top_global, &top,
- inputrec, imdSession, pull_work, nrnb, wcycle, gstat,
- vsite, constr, mdAtoms, fr, runScheduleWork, enerd };
+ EnergyEvaluator energyEvaluator{ fplog,
+ mdlog,
+ cr,
+ ms,
+ top_global,
+ &top,
+ inputrec,
+ imdSession,
+ pull_work,
+ nrnb,
+ wcycle,
+ gstat,
+ &observablesReducer,
+ vsite,
+ constr,
+ mdAtoms,
+ fr,
+ runScheduleWork,
+ enerd };
/**** HERE STARTS THE LOOP ****
* count is the counter for the number of steps
if (validStep)
{
- energyEvaluator.run(s_try, mu_tot, vir, pres, count, count == 0);
+ energyEvaluator.run(s_try, mu_tot, vir, pres, count, count == 0, count);
}
else
{
em_state_t state_work{};
+ ObservablesReducer observablesReducer = observablesReducerBuilder->build();
+
/* Init em and store the local state in state_minimum */
init_em(fplog,
mdlog,
/* Make evaluate_energy do a single node force calculation */
cr->nnodes = 1;
- EnergyEvaluator energyEvaluator{ fplog, mdlog, cr, ms, top_global, &top,
- inputrec, imdSession, pull_work, nrnb, wcycle, gstat,
- vsite, constr, mdAtoms, fr, runScheduleWork, enerd };
- energyEvaluator.run(&state_work, mu_tot, vir, pres, -1, TRUE);
+ EnergyEvaluator energyEvaluator{ fplog,
+ mdlog,
+ cr,
+ ms,
+ top_global,
+ &top,
+ inputrec,
+ imdSession,
+ pull_work,
+ nrnb,
+ wcycle,
+ gstat,
+ &observablesReducer,
+ vsite,
+ constr,
+ mdAtoms,
+ fr,
+ runScheduleWork,
+ enerd };
+ energyEvaluator.run(&state_work, mu_tot, vir, pres, -1, TRUE, 0);
cr->nnodes = nnodes;
/* if forces are not small, warn user */
}
else
{
- energyEvaluator.run(&state_work, mu_tot, vir, pres, aid * 2 + dx, FALSE);
+ energyEvaluator.run(&state_work, mu_tot, vir, pres, aid * 2 + dx, FALSE, step);
}
cr->nnodes = nnodes;
#include "gromacs/mdtypes/mdatom.h"
#include "gromacs/mdtypes/mdrunoptions.h"
#include "gromacs/mdtypes/observableshistory.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/mdtypes/simulation_workload.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/mimic/utilities.h"
int nstglobalcomm = 1;
const bool bNS = true;
+ ObservablesReducer observablesReducer = observablesReducerBuilder->build();
+
const SimulationGroups* groups = &top_global.groups;
if (ir->eI == IntegrationAlgorithm::Mimic)
{
doFreeEnergyPerturbation = true;
}
+ int64_t step = ir->init_step;
+ int64_t step_rel = 0;
+
{
int cglo_flags = CGLO_GSTAT;
if (DOMAINDECOMP(cr) && dd_localTopologyChecker(*cr->dd).shouldCheckNumberOfBondedInteractions())
&nullSignaller,
state->box,
&bSumEkinhOld,
- cglo_flags);
+ cglo_flags,
+ step,
+ &observablesReducer);
if (DOMAINDECOMP(cr))
{
dd_localTopologyChecker(cr->dd)->checkNumberOfBondedInteractions(
calc_shifts(rerun_fr.box, fr->shift_vec);
}
- int64_t step = ir->init_step;
- int64_t step_rel = 0;
-
auto stopHandler = stopHandlerBuilder->getStopHandlerMD(
compat::not_null<SimulationSignal*>(&signals[eglsSTOPCOND]),
false,
&signaller,
state->box,
&bSumEkinhOld,
- cglo_flags);
+ cglo_flags,
+ step,
+ &observablesReducer);
if (DOMAINDECOMP(cr))
{
dd_localTopologyChecker(cr->dd)->checkNumberOfBondedInteractions(
#include "gromacs/mdtypes/mdatom.h"
#include "gromacs/mdtypes/mdrunoptions.h"
#include "gromacs/mdtypes/observableshistory.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/mdtypes/simulation_workload.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/mdtypes/state_propagator_data_gpu.h"
doEssentialDynamics,
membedHolder.doMembed());
+ ObservablesReducerBuilder observablesReducerBuilder;
+
// Build restraints.
// TODO: hide restraint implementation details from Mdrunner.
// There is nothing unique about restraints at this point as far as the
simulatorBuilder.add(SimulatorConfig(mdrunOptions, startingBehavior, &runScheduleWork));
- simulatorBuilder.add(SimulatorEnv(fplog, cr, ms, mdlog, oenv));
+ simulatorBuilder.add(SimulatorEnv(fplog, cr, ms, mdlog, oenv, &observablesReducerBuilder));
simulatorBuilder.add(Profiling(&nrnb, walltime_accounting, wcycle.get()));
simulatorBuilder.add(ConstraintsParam(
constr.get(), enforcedRotation ? enforcedRotation->getLegacyEnfrot() : nullptr, vsite.get()));
profiling_->wallCycle,
legacyInput_->forceRec,
simulatorStateData_->enerdata_p,
+ simulatorEnv_->observablesReducerBuilder_,
simulatorStateData_->ekindata_p,
simulatorConfig_->runScheduleWork_,
*replicaExchangeParameters_,
profiling_->wallCycle,
legacyInput_->forceRec,
simulatorStateData_->enerdata_p,
+ simulatorEnv_->observablesReducerBuilder_,
simulatorStateData_->ekindata_p,
simulatorConfig_->runScheduleWork_,
*replicaExchangeParameters_,
class MDLogger;
struct MDModulesNotifiers;
struct MdrunOptions;
+class ObservablesReducerBuilder;
class ReadCheckpointDataHolder;
enum class StartingBehavior;
class StopHandlerBuilder;
{
public:
//! Build from current simulation environment.
- SimulatorEnv(FILE* fplog,
- t_commrec* commRec,
- gmx_multisim_t* multisimCommRec,
- const MDLogger& logger,
- gmx_output_env_t* outputEnv) :
- fplog_{ fplog }, commRec_{ commRec }, multisimCommRec_{ multisimCommRec }, logger_{ logger }, outputEnv_{ outputEnv }
+ SimulatorEnv(FILE* fplog,
+ t_commrec* commRec,
+ gmx_multisim_t* multisimCommRec,
+ const MDLogger& logger,
+ gmx_output_env_t* outputEnv,
+ ObservablesReducerBuilder* observablesReducerBuilder) :
+ fplog_{ fplog }, commRec_{ commRec }, multisimCommRec_{ multisimCommRec }, logger_{ logger }, outputEnv_{ outputEnv }, observablesReducerBuilder_{ observablesReducerBuilder }
{
}
const MDLogger& logger_;
//! Handle to file output handling.
const gmx_output_env_t* outputEnv_;
+ //! Builder for coordinator of reduction for observables
+ ObservablesReducerBuilder* observablesReducerBuilder_;
};
/*! \brief
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper gmx_unused* globalCommunicationHelper)
+ GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer gmx_unused* observablesReducer)
{
GMX_RELEASE_ASSERT(legacySimulatorData->inputrec->etc == TemperatureCoupling::Andersen
|| legacySimulatorData->inputrec->etc == TemperatureCoupling::AndersenMassive,
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
*/
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper);
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer);
//! Returns the frequency at which temperature coupling is performed
[[nodiscard]] int frequency() const;
ComputeGlobalsElement<algorithm>::ComputeGlobalsElement(StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- SimulationSignals* signals,
- int nstglobalcomm,
- FILE* fplog,
- const MDLogger& mdlog,
- t_commrec* cr,
- const t_inputrec* inputrec,
- const MDAtoms* mdAtoms,
- t_nrnb* nrnb,
- gmx_wallcycle* wcycle,
- t_forcerec* fr,
- const gmx_mtop_t& global_top,
- Constraints* constr) :
+ SimulationSignals* signals,
+ int nstglobalcomm,
+ FILE* fplog,
+ const MDLogger& mdlog,
+ t_commrec* cr,
+ const t_inputrec* inputrec,
+ const MDAtoms* mdAtoms,
+ t_nrnb* nrnb,
+ gmx_wallcycle* wcycle,
+ t_forcerec* fr,
+ const gmx_mtop_t& global_top,
+ Constraints* constr,
+ ObservablesReducer* observablesReducer) :
energyReductionStep_(-1),
virialReductionStep_(-1),
vvSchedulingStep_(-1),
constr_(constr),
nrnb_(nrnb),
wcycle_(wcycle),
- fr_(fr)
+ fr_(fr),
+ observablesReducer_(observablesReducer)
{
reportComRemovalInfo(fplog, vcm_);
gstat_ = global_stat_init(inputrec_);
signaller,
lastbox,
energyData_->needToSumEkinhOld(),
- flags);
+ flags,
+ step,
+ observablesReducer_);
if (DOMAINDECOMP(cr_))
{
dd_localTopologyChecker(cr_->dd)->checkNumberOfBondedInteractions(localTopology_, x, box);
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper)
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer)
{
auto* element = builderHelper->storeElement(
std::make_unique<ComputeGlobalsElement<ComputeGlobalsAlgorithm::LeapFrog>>(
legacySimulatorData->wcycle,
legacySimulatorData->fr,
legacySimulatorData->top_global,
- legacySimulatorData->constr));
+ legacySimulatorData->constr,
+ observablesReducer));
return element;
}
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper)
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer)
{
// We allow this element to be added multiple times to the call list, but we only want one
// actual element built
simulator->wcycle,
simulator->fr,
simulator->top_global,
- simulator->constr));
+ simulator->constr,
+ observablesReducer));
builderHelper->storeBuilderData(key, vvComputeGlobalsElement);
return vvComputeGlobalsElement;
}
class LegacySimulatorData;
class MDAtoms;
class MDLogger;
+class ObservablesReducer;
//! \addtogroup module_modularsimulator
//! \{
gmx_wallcycle* wcycle,
t_forcerec* fr,
const gmx_mtop_t& global_top,
- Constraints* constr);
+ Constraints* constr,
+ ObservablesReducer* observablesReducer);
//! Destructor
~ComputeGlobalsElement() override;
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
*
* \throws std::bad_any_cast on internal error in VelocityVerlet algorithm builder.
* \throws std::bad_alloc when out of memory.
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper);
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer);
private:
//! ITopologyClient implementation
gmx_wallcycle* wcycle_;
//! Parameters for force calculations.
t_forcerec* fr_;
+ //! Coordinates reduction for observables
+ ObservablesReducer* observablesReducer_;
};
//! \}
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper gmx_unused* globalCommunicationHelper)
+ GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer* /*observablesReducer*/)
{
return builderHelper->storeElement(
std::make_unique<ConstraintsElement<variable>>(legacySimulatorData->constr,
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2019,2020, by the GROMACS development team, led by
+ * Copyright (c) 2019,2020,2021, 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.
class GlobalCommunicationHelper;
class LegacySimulatorData;
class ModularSimulatorAlgorithmBuilderHelper;
+class ObservablesReducer;
class StatePropagatorData;
/*! \internal
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
*/
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper);
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer);
private:
//! The actual constraining computation
StatePropagatorData gmx_unused* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
- GlobalCommunicationHelper gmx_unused* globalCommunicationHelper)
+ GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer* /*observablesReducer*/)
{
return energyData->element();
}
class LegacySimulatorData;
class MDAtoms;
class ModularSimulatorAlgorithmBuilderHelper;
+class ObservablesReducer;
class ParrinelloRahmanBarostat;
class StatePropagatorData;
class VelocityScalingTemperatureCoupling;
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
*/
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper);
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer);
private:
EnergyData* energyData_;
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
- int offset,
- ReportPreviousStepConservedEnergy reportPreviousStepConservedEnergy)
+ ObservablesReducer* /*observablesReducer*/,
+ int offset,
+ ReportPreviousStepConservedEnergy reportPreviousStepConservedEnergy)
{
return builderHelper->storeElement(std::make_unique<FirstOrderPressureCoupling>(
legacySimulatorData->inputrec->nstpcouple,
class LegacySimulatorData;
class MDAtoms;
class ModularSimulatorAlgorithmBuilderHelper;
+class ObservablesReducer;
class StatePropagatorData;
/*! \internal
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param offset The step offset at which the barostat is applied
* \param reportPreviousStepConservedEnergy Report the previous or the current step conserved energy
*
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
int offset,
ReportPreviousStepConservedEnergy reportPreviousStepConservedEnergy);
{
// TODO: Correcting the box is done in DomDecHelper (if using DD) or here (non-DD simulations).
// Think about unifying this responsibility, could this be done in one place?
- auto box = statePropagatorData_->box();
+ auto* box = statePropagatorData_->box();
correct_box(fplog_, step, box);
}
* This is parallelized as well, and does communication too.
* Check comments in sim_util.c
*/
- auto x = statePropagatorData_->positionsView();
- auto& forces = statePropagatorData_->forcesView();
- auto box = statePropagatorData_->constBox();
- history_t* hist = nullptr; // disabled
+ auto x = statePropagatorData_->positionsView();
+ auto& forces = statePropagatorData_->forcesView();
+ const auto* box = statePropagatorData_->constBox();
+ history_t* hist = nullptr; // disabled
tensor force_vir = { { 0 } };
// TODO: Make lambda const (needs some adjustments in lower force routines)
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper gmx_unused* globalCommunicationHelper)
+ GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer* /*observablesReducer*/)
{
const bool isVerbose = legacySimulatorData->mdrunOptions.verbose;
const bool isDynamicBox = inputrecDynamicBox(legacySimulatorData->inputrec);
class MDAtoms;
class MdrunScheduleWorkload;
class ModularSimulatorAlgorithmBuilderHelper;
+class ObservablesReducer;
class StatePropagatorData;
class VirtualSitesHandler;
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
*/
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper);
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer);
private:
//! ITopologyHolderClient implementation
/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2019,2020, by the GROMACS development team, led by
+ * Copyright (c) 2019,2020,2021, 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.
StatePropagatorData gmx_unused* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
- GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer gmx_unused* observablesReducer,
Offset offset,
ScheduleOnInitStep scheduleOnInitStep,
const MttkPropagatorConnectionDetails& mttkPropagatorConnectionDetails)
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
- GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer gmx_unused* observablesReducer,
const MttkPropagatorConnectionDetails& mttkPropagatorConnectionDetails)
{
// Data is now owned by the caller of this method, who will handle lifetime (see ModularSimulatorAlgorithm)
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
* \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param offset The step offset at which the thermostat is applied
* \param scheduleOnInitStep Whether the element is scheduled on the initial step
* \param mttkPropagatorConnectionDetails Reference to the \c MttkPropagatorConnectionDetails object containing propagator tags and offsets
-
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
*/
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
Offset offset,
ScheduleOnInitStep scheduleOnInitStep,
const MttkPropagatorConnectionDetails& mttkPropagatorConnectionDetails);
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param mttkPropagatorConnectionDetails Reference to the \c MttkPropagatorConnectionDetails object containing propagator tags and offsets
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
const MttkPropagatorConnectionDetails& mttkPropagatorConnectionDetails);
private:
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
NhcUsage nhcUsage,
Offset offset,
UseFullStepKE useFullStepKE,
energyData,
freeEnergyPerturbationData,
globalCommunicationHelper,
+ observablesReducer,
nhcUsage,
offset,
useFullStepKE,
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
- NhcUsage nhcUsage,
- Offset offset,
- UseFullStepKE useFullStepKE,
- ScheduleOnInitStep scheduleOnInitStep,
- const PropagatorTag& propagatorTag)
+ ObservablesReducer gmx_unused* observablesReducer,
+ NhcUsage nhcUsage,
+ Offset offset,
+ UseFullStepKE useFullStepKE,
+ ScheduleOnInitStep scheduleOnInitStep,
+ const PropagatorTag& propagatorTag)
{
if (!builderHelper->simulationData<NoseHooverChainsData>(NoseHooverChainsData::dataID(nhcUsage)))
{
struct MttkPropagatorConnectionDetails;
class MttkData;
class NoseHooverGroup;
+class ObservablesReducer;
class StatePropagatorData;
enum class UseFullStepKE;
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param nhcUsage What the NHC is connected to - system or barostat
* \param offset The step offset at which the thermostat is applied
* \param useFullStepKE Whether full step or half step KE is used
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
NhcUsage nhcUsage,
Offset offset,
UseFullStepKE useFullStepKE,
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param nhcUsage What the NHC is connected to - system or barostat
* \param offset The step offset at which the thermostat is applied
* \param useFullStepKE Whether full step or half step KE is used
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
NhcUsage nhcUsage,
Offset offset,
UseFullStepKE useFullStepKE,
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
- Offset offset,
- const PropagatorTag& propagatorTag)
+ ObservablesReducer* /*observablesReducer*/,
+ Offset offset,
+ const PropagatorTag& propagatorTag)
{
auto* element = builderHelper->storeElement(std::make_unique<ParrinelloRahmanBarostat>(
legacySimulatorData->inputrec->nstpcouple,
class EnergyData;
class LegacySimulatorData;
class MDAtoms;
+class ObservablesReducer;
class StatePropagatorData;
/*! \internal
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param propagatorTag Tag of the propagator to connect to
* \param offset The step offset at which the barostat is applied
*
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
Offset offset,
const PropagatorTag& propagatorTag);
return propagator->velocityScalingCallback();
};
}
- if constexpr (hasStartVelocityScaling<integrationStage>())
+ if constexpr (hasStartVelocityScaling<integrationStage>()) // NOLINT(readability-misleading-indentation)
{
propagatorConnection.getViewOnStartVelocityScaling = [propagator]() {
return propagator->viewOnStartVelocityScaling();
};
}
- if constexpr (hasEndVelocityScaling<integrationStage>())
+ if constexpr (hasEndVelocityScaling<integrationStage>()) // NOLINT(readability-misleading-indentation)
{
propagatorConnection.getViewOnEndVelocityScaling = [propagator]() {
return propagator->viewOnEndVelocityScaling();
};
}
- if constexpr (hasPositionScaling<integrationStage>())
+ if constexpr (hasPositionScaling<integrationStage>()) // NOLINT(readability-misleading-indentation)
{
propagatorConnection.setNumPositionScalingVariables = [propagator](int num) {
propagator->setNumPositionScalingVariables(num);
return propagator->positionScalingCallback();
};
}
- if constexpr (hasParrinelloRahmanScaling<integrationStage>())
+ if constexpr (hasParrinelloRahmanScaling<integrationStage>()) // NOLINT(readability-misleading-indentation)
{
propagatorConnection.getViewOnPRScalingMatrix = [propagator]() {
return propagator->viewOnPRScalingMatrix();
};
}
- return propagatorConnection;
+ return propagatorConnection; // NOLINT(readability-misleading-indentation)
}
// doxygen is confused by the two definitions
EnergyData gmx_unused* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
- const PropagatorTag& propagatorTag,
- TimeStep timestep)
+ ObservablesReducer* /* observablesReducer */,
+ const PropagatorTag& propagatorTag,
+ TimeStep timestep)
{
GMX_RELEASE_ASSERT(!(integrationStage == IntegrationStage::ScaleVelocities
|| integrationStage == IntegrationStage::ScalePositions)
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
const PropagatorTag& propagatorTag)
{
GMX_RELEASE_ASSERT(
energyData,
freeEnergyPerturbationData,
globalCommunicationHelper,
+ observablesReducer,
propagatorTag,
TimeStep(0.0));
}
class LegacySimulatorData;
class MDAtoms;
class ModularSimulatorAlgorithmBuilderHelper;
+class ObservablesReducer;
class StatePropagatorData;
//! \addtogroup module_modularsimulator
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param propagatorTag The name of the propagator to simplify connection
* \param timestep The time step the propagator uses
*
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
const PropagatorTag& propagatorTag,
TimeStep timestep);
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param propagatorTag The name of the propagator to simplify connection
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
const PropagatorTag& propagatorTag);
private:
legacySimulatorData->inputrec,
legacySimulatorData->cr),
signals_.get()),
+ observablesReducer_(legacySimulatorData->observablesReducerBuilder->build()),
checkpointHelperBuilder_(std::move(checkpointDataHolder),
legacySimulatorData->startingBehavior,
legacySimulatorData->cr)
#include <typeinfo>
#include "gromacs/mdrun/isimulator.h"
+#include "gromacs/mdtypes/observablesreducer.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/utility/exceptions.h"
*
* This includes data that needs to be shared between elements involved in
* global communication. This will become obsolete as soon as global
- * communication is moved to a client system (#3421).
+ * communication is moved to a client system (#3421 and #3887).
*/
class GlobalCommunicationHelper
{
std::unique_ptr<SimulationSignals> signals_;
//! Helper object passed to element factory functions
ModularSimulatorAlgorithmBuilderHelper elementAdditionHelper_;
- //! Container for global computation data
+ //! Container for minor aspects of global computation data
GlobalCommunicationHelper globalCommunicationHelper_;
+ //! Coordinates reduction for observables
+ ObservablesReducer observablesReducer_;
/*! \brief Set arbitrary data in the ModularSimulatorAlgorithm
*
* StatePropagatorData* statePropagatorData,
* EnergyData* energyData,
* FreeEnergyPerturbationData* freeEnergyPerturbationData,
- * GlobalCommunicationHelper* globalCommunicationHelper)
+ * GlobalCommunicationHelper* globalCommunicationHelper,
+ * ObservablesReducer* observablesReducer)
*
* This function may also accept additional parameters which are passed using the variadic
* template parameter pack forwarded in getElementPointer.
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param args Variable number of additional parameters to be forwarded
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
Args&&... args)
{
return Element::getElementPointerImpl(legacySimulatorData,
energyData,
freeEnergyPerturbationData,
globalCommunicationHelper,
+ observablesReducer,
std::forward<Args>(args)...);
}
energyData_.get(),
freeEnergyPerturbationData_.get(),
&globalCommunicationHelper_,
+ &observablesReducer_,
std::forward<Args>(args)...));
// Make sure returned element pointer is owned by *this
StatePropagatorData* statePropagatorData,
EnergyData gmx_unused* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper gmx_unused* globalCommunicationHelper)
+ GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
+ ObservablesReducer* /*observablesReducer*/)
{
statePropagatorData->element()->setFreeEnergyPerturbationData(freeEnergyPerturbationData);
return statePropagatorData->element();
class GlobalCommunicationHelper;
class LegacySimulatorData;
class ModularSimulatorAlgorithmBuilderHelper;
+class ObservablesReducer;
/*! \internal
* \ingroup module_modularsimulator
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
*
* \return Pointer to the element to be added. Element needs to have been stored using \c storeElement
*/
StatePropagatorData* statePropagatorData,
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
- GlobalCommunicationHelper* globalCommunicationHelper);
+ GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer);
private:
//! Pointer to the associated StatePropagatorData
EnergyData* energyData,
FreeEnergyPerturbationData gmx_unused* freeEnergyPerturbationData,
GlobalCommunicationHelper gmx_unused* globalCommunicationHelper,
- Offset offset,
- UseFullStepKE useFullStepKE,
- ReportPreviousStepConservedEnergy reportPreviousStepConservedEnergy,
- const PropagatorTag& propagatorTag)
+ ObservablesReducer* /*observablesReducer*/,
+ Offset offset,
+ UseFullStepKE useFullStepKE,
+ ReportPreviousStepConservedEnergy reportPreviousStepConservedEnergy,
+ const PropagatorTag& propagatorTag)
{
// Element is now owned by the caller of this method, who will handle lifetime (see ModularSimulatorAlgorithm)
auto* element = builderHelper->storeElement(std::make_unique<VelocityScalingTemperatureCoupling>(
{
class ITemperatureCouplingImpl;
class LegacySimulatorData;
+class ObservablesReducer;
struct TemperatureCouplingData;
//! Enum describing whether the thermostat is using full or half step kinetic energy
* \param statePropagatorData Pointer to the \c StatePropagatorData object
* \param energyData Pointer to the \c EnergyData object
* \param freeEnergyPerturbationData Pointer to the \c FreeEnergyPerturbationData object
- * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param globalCommunicationHelper Pointer to the \c GlobalCommunicationHelper object
+ * \param observablesReducer Pointer to the \c ObservablesReducer object
* \param propagatorTag Tag of the propagator to connect to
* \param offset The step offset at which the thermostat is applied
* \param useFullStepKE Whether full step or half step KE is used
EnergyData* energyData,
FreeEnergyPerturbationData* freeEnergyPerturbationData,
GlobalCommunicationHelper* globalCommunicationHelper,
+ ObservablesReducer* observablesReducer,
Offset offset,
UseFullStepKE useFullStepKE,
ReportPreviousStepConservedEnergy reportPreviousStepConservedEnergy,
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff