to inform clients about trajectory steps, and providing a valid
file pointer to the objects that need to write to trajectory.
-#### `StatePropagatorData`
-The `StatePropagatorData` takes part in the simulator run, as it might
+#### `StatePropagatorData::Element`
+The `StatePropagatorData::Element` takes part in the simulator run, as it might
have to save a valid state at the right moment during the
integration. Placing the StatePropagatorData correctly is for now the
duty of the simulator builder - this might be automated later
if we have enough meta-data of the variables (i.e., if
`StatePropagatorData` knows at which time the variables currently are,
and can decide when a valid state (full-time step of all
-variables) is reached. The `StatePropagatorData` is also a client of
+variables) is reached. The `StatePropagatorData::Element` is also a client of
both the trajectory signaller and writer - it will save a
state for later writeout during the simulator step if it
knows that trajectory writing will occur later in the step,
and it knows how to write to file given a file pointer by
the `TrajectoryElement`.
-#### `EnergyElement`
-The `EnergyElement` takes part in the simulator run, as it
+#### `EnergyData::Element`
+The `EnergyData::Element` takes part in the simulator run, as it
does either add data (at energy calculation steps), or
record a non-calculation step (all other steps). It is the
responsibility of the simulator builder to ensure that the
-`EnergyElement` is called at a point of the simulator run
+`EnergyData::Element` is called at a point of the simulator run
at which it has access to a valid energy state.
#### `ComputeGlobalsElement`
domain decomposition, PME load balancing, and the initial
constraining are using this.
-### `EnergyElement`
-The EnergyElement owns the EnergyObject, and is hence responsible
+### `EnergyData`
+The EnergyData owns the EnergyObject, and is hence responsible
for saving energy data and writing it to trajectory. It also owns
the tensors for the different virials and the pressure as well as
the total dipole vector.
and the logging signaller to know when an energy calculation is
needed and when a non-recording step is enough. The simulator
builder is responsible to place the element in a location at
-which a valid energy state is available. The EnergyElement is
+which a valid energy state is available. The EnergyData is
also a subscriber to the trajectory writer element, as it is
responsible to write energy data to trajectory.
-The EnergyElement offers an interface to add virial contributions,
+The EnergyData offers an interface to add virial contributions,
but also allows access to the raw pointers to tensor data, the
dipole vector, and the legacy energy data structures.
#include "gromacs/mdtypes/simulation_workload.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/mdtypes/state_propagator_data_gpu.h"
-#include "gromacs/modularsimulator/energyelement.h"
+#include "gromacs/modularsimulator/energydata.h"
#include "gromacs/nbnxm/gpu_data_mgmt.h"
#include "gromacs/nbnxm/nbnxm.h"
#include "gromacs/pbcutil/pbc.h"
if (MASTER(cr))
{
- EnergyElement::initializeEnergyHistory(startingBehavior, observablesHistory, &energyOutput);
+ EnergyData::initializeEnergyHistory(startingBehavior, observablesHistory, &energyOutput);
}
preparePrevStepPullCom(ir, pull_work, mdatoms->massT, state, state_global, cr,
{
template<ComputeGlobalsAlgorithm algorithm>
ComputeGlobalsElement<algorithm>::ComputeGlobalsElement(StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
SimulationSignals* signals,
int nstglobalcomm,
totalNumberOfBondedInteractions_(0),
shouldCheckNumberOfBondedInteractions_(false),
statePropagatorData_(statePropagatorData),
- energyElement_(energyElement),
+ energyData_(energyData),
localTopology_(nullptr),
freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
vcm_(global_top->groups, *inputrec),
// Calculate the initial half step temperature, and save the ekinh_old
for (int i = 0; (i < inputrec_->opts.ngtc); i++)
{
- copy_mat(energyElement_->ekindata()->tcstat[i].ekinh,
- energyElement_->ekindata()->tcstat[i].ekinh_old);
+ copy_mat(energyData_->ekindata()->tcstat[i].ekinh, energyData_->ekindata()->tcstat[i].ekinh_old);
}
}
: statePropagatorData_->constBox();
compute_globals(
- gstat_, cr_, inputrec_, fr_, energyElement_->ekindata(), x, v, box, mdAtoms_->mdatoms(),
- nrnb_, &vcm_, step != -1 ? wcycle_ : nullptr, energyElement_->enerdata(),
- energyElement_->forceVirial(step), energyElement_->constraintVirial(step),
- energyElement_->totalVirial(step), energyElement_->pressure(step), constr_, signaller,
- lastbox, &totalNumberOfBondedInteractions_, energyElement_->needToSumEkinhOld(),
+ gstat_, cr_, inputrec_, fr_, energyData_->ekindata(), x, v, box, mdAtoms_->mdatoms(),
+ nrnb_, &vcm_, step != -1 ? wcycle_ : nullptr, energyData_->enerdata(),
+ energyData_->forceVirial(step), energyData_->constraintVirial(step),
+ energyData_->totalVirial(step), energyData_->pressure(step), constr_, signaller,
+ lastbox, &totalNumberOfBondedInteractions_, energyData_->needToSumEkinhOld(),
flags | (shouldCheckNumberOfBondedInteractions_ ? CGLO_CHECK_NUMBER_OF_BONDED_INTERACTIONS : 0));
checkNumberOfBondedInteractions(mdlog_, cr_, totalNumberOfBondedInteractions_, top_global_,
localTopology_, x, box, &shouldCheckNumberOfBondedInteractions_);
#include "gromacs/mdlib/simulationsignal.h"
#include "gromacs/mdlib/vcm.h"
-#include "energyelement.h"
+#include "energydata.h"
#include "modularsimulatorinterfaces.h"
#include "statepropagatordata.h"
#include "topologyholder.h"
public:
//! Constructor
ComputeGlobalsElement(StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
SimulationSignals* signals,
int nstglobalcomm,
//! Global reduction struct
gmx_global_stat* gstat_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the microstate
StatePropagatorData* statePropagatorData_;
- //! Pointer to the energy element (needed for the tensors and mu_tot)
- EnergyElement* energyElement_;
+ //! Pointer to the energy data (needed for the tensors and mu_tot)
+ EnergyData* energyData_;
//! Pointer to the local topology (only needed for checkNumberOfBondedInteractions)
const gmx_localtop_t* localTopology_;
//! Pointer to the free energy perturbation element
#include "gromacs/mdtypes/state.h"
#include "gromacs/utility/fatalerror.h"
-#include "energyelement.h"
+#include "energydata.h"
#include "freeenergyperturbationelement.h"
#include "statepropagatordata.h"
template<ConstraintVariable variable>
ConstraintsElement<variable>::ConstraintsElement(Constraints* constr,
StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
bool isMaster,
FILE* fplog,
nextLogWritingStep_(-1),
isMasterRank_(isMaster),
statePropagatorData_(statePropagatorData),
- energyElement_(energyElement),
+ energyData_(energyData),
freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
constr_(constr),
fplog_(fplog),
// For some reason, the shake virial in VV is reset twice a step.
// Energy element will only do this once per step.
// TODO: Investigate this
- clear_mat(energyElement_->constraintVirial(step));
+ clear_mat(energyData_->constraintVirial(step));
}
- energyElement_->addToConstraintVirial(vir_con, step);
+ energyData_->addToConstraintVirial(vir_con, step);
}
/* The factor of 2 correction is necessary because half of the constraint
* Cf. Issue #1255
*/
const real c_dvdlConstraintCorrectionFactor = EI_VV(inputrec_->eI) ? 2.0 : 1.0;
- energyElement_->enerdata()->term[F_DVDL_CONSTR] += c_dvdlConstraintCorrectionFactor * dvdlambda;
+ energyData_->enerdata()->term[F_DVDL_CONSTR] += c_dvdlConstraintCorrectionFactor * dvdlambda;
}
template<ConstraintVariable variable>
namespace gmx
{
class Constraints;
-class EnergyElement;
+class EnergyData;
class FreeEnergyPerturbationElement;
class StatePropagatorData;
//! Constructor
ConstraintsElement(Constraints* constr,
StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
bool isMaster,
FILE* fplog,
//! Whether we're master rank
const bool isMasterRank_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the micro state
StatePropagatorData* statePropagatorData_;
- //! Pointer to the energy element
- EnergyElement* energyElement_;
+ //! Pointer to the energy data
+ EnergyData* energyData_;
//! Pointer to the free energy perturbation element
FreeEnergyPerturbationElement* freeEnergyPerturbationElement_;
//! The global communication frequency
const int nstglobalcomm_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the micro state
StatePropagatorData* statePropagatorData_;
//! Pointer to the topology
#include "gmxpre.h"
-#include "energyelement.h"
+#include "energydata.h"
#include "gromacs/math/vec.h"
#include "gromacs/mdlib/compute_io.h"
{
class Awh;
-EnergyElement::EnergyElement(StatePropagatorData* statePropagatorData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- const gmx_mtop_t* globalTopology,
- const t_inputrec* inputrec,
- const MDAtoms* mdAtoms,
- gmx_enerdata_t* enerd,
- gmx_ekindata_t* ekind,
- const Constraints* constr,
- FILE* fplog,
- t_fcdata* fcd,
- const MdModulesNotifier& mdModulesNotifier,
- bool isMasterRank,
- ObservablesHistory* observablesHistory,
- StartingBehavior startingBehavior) :
+EnergyData::EnergyData(StatePropagatorData* statePropagatorData,
+ FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
+ const gmx_mtop_t* globalTopology,
+ const t_inputrec* inputrec,
+ const MDAtoms* mdAtoms,
+ gmx_enerdata_t* enerd,
+ gmx_ekindata_t* ekind,
+ const Constraints* constr,
+ FILE* fplog,
+ t_fcdata* fcd,
+ const MdModulesNotifier& mdModulesNotifier,
+ bool isMasterRank,
+ ObservablesHistory* observablesHistory,
+ StartingBehavior startingBehavior) :
+ element_(std::make_unique<Element>(this, isMasterRank)),
isMasterRank_(isMasterRank),
- energyWritingStep_(-1),
- energyCalculationStep_(-1),
- freeEnergyCalculationStep_(-1),
forceVirialStep_(-1),
shakeVirialStep_(-1),
totalVirialStep_(-1),
}
}
-void EnergyElement::scheduleTask(Step step, Time time, const RegisterRunFunctionPtr& registerRunFunction)
+void EnergyData::Element::scheduleTask(Step step, Time time, const RegisterRunFunctionPtr& registerRunFunction)
{
if (!isMasterRank_)
{
{
(*registerRunFunction)(std::make_unique<SimulatorRunFunction>(
[this, time, isEnergyCalculationStep, isFreeEnergyCalculationStep]() {
- doStep(time, isEnergyCalculationStep, isFreeEnergyCalculationStep);
+ energyData_->doStep(time, isEnergyCalculationStep, isFreeEnergyCalculationStep);
}));
}
else
{
(*registerRunFunction)(std::make_unique<SimulatorRunFunction>(
- [this]() { energyOutput_->recordNonEnergyStep(); }));
+ [this]() { energyData_->energyOutput_->recordNonEnergyStep(); }));
}
}
-void EnergyElement::elementTeardown()
+void EnergyData::teardown()
{
if (inputrec_->nstcalcenergy > 0 && isMasterRank_)
{
}
}
-void EnergyElement::trajectoryWriterSetup(gmx_mdoutf* outf)
+void EnergyData::Element::trajectoryWriterSetup(gmx_mdoutf* outf)
+{
+ energyData_->setup(outf);
+}
+
+void EnergyData::setup(gmx_mdoutf* outf)
{
pull_t* pull_work = nullptr;
energyOutput_ = std::make_unique<EnergyOutput>(mdoutf_get_fp_ene(outf), top_global_, inputrec_,
}
}
-ITrajectoryWriterCallbackPtr EnergyElement::registerTrajectoryWriterCallback(TrajectoryEvent event)
+ITrajectoryWriterCallbackPtr EnergyData::Element::registerTrajectoryWriterCallback(TrajectoryEvent event)
{
if (event == TrajectoryEvent::EnergyWritingStep && isMasterRank_)
{
return std::make_unique<ITrajectoryWriterCallback>(
- [this](gmx_mdoutf* mdoutf, Step step, Time time, bool writeTrajectory,
- bool writeLog) { write(mdoutf, step, time, writeTrajectory, writeLog); });
+ [this](gmx_mdoutf* mdoutf, Step step, Time time, bool writeTrajectory, bool writeLog) {
+ energyData_->write(mdoutf, step, time, writeTrajectory, writeLog);
+ });
}
return nullptr;
}
-SignallerCallbackPtr EnergyElement::registerTrajectorySignallerCallback(gmx::TrajectoryEvent event)
+SignallerCallbackPtr EnergyData::Element::registerTrajectorySignallerCallback(gmx::TrajectoryEvent event)
{
if (event == TrajectoryEvent::EnergyWritingStep && isMasterRank_)
{
return nullptr;
}
-SignallerCallbackPtr EnergyElement::registerEnergyCallback(EnergySignallerEvent event)
+SignallerCallbackPtr EnergyData::Element::registerEnergyCallback(EnergySignallerEvent event)
{
if (event == EnergySignallerEvent::EnergyCalculationStep && isMasterRank_)
{
return nullptr;
}
-void EnergyElement::doStep(Time time, bool isEnergyCalculationStep, bool isFreeEnergyCalculationStep)
+void EnergyData::doStep(Time time, bool isEnergyCalculationStep, bool isFreeEnergyCalculationStep)
{
enerd_->term[F_ETOT] = enerd_->term[F_EPOT] + enerd_->term[F_EKIN];
if (vRescaleThermostat_)
forceVirial_, totalVirial_, pressure_, ekind_, muTot_, constr_);
}
-void EnergyElement::write(gmx_mdoutf* outf, Step step, Time time, bool writeTrajectory, bool writeLog)
+void EnergyData::write(gmx_mdoutf* outf, Step step, Time time, bool writeTrajectory, bool writeLog)
{
if (writeLog)
{
writeLog ? fplog_ : nullptr, step, time, fcd_, awh);
}
-void EnergyElement::addToForceVirial(const tensor virial, Step step)
+void EnergyData::addToForceVirial(const tensor virial, Step step)
{
if (step > forceVirialStep_)
{
m_add(forceVirial_, virial, forceVirial_);
}
-void EnergyElement::addToConstraintVirial(const tensor virial, Step step)
+void EnergyData::addToConstraintVirial(const tensor virial, Step step)
{
if (step > shakeVirialStep_)
{
m_add(shakeVirial_, virial, shakeVirial_);
}
-rvec* EnergyElement::forceVirial(Step gmx_unused step)
+rvec* EnergyData::forceVirial(Step gmx_unused step)
{
if (step > forceVirialStep_)
{
return forceVirial_;
}
-rvec* EnergyElement::constraintVirial(Step gmx_unused step)
+rvec* EnergyData::constraintVirial(Step gmx_unused step)
{
if (step > shakeVirialStep_)
{
return shakeVirial_;
}
-rvec* EnergyElement::totalVirial(Step gmx_unused step)
+rvec* EnergyData::totalVirial(Step gmx_unused step)
{
if (step > totalVirialStep_)
{
return totalVirial_;
}
-rvec* EnergyElement::pressure(Step gmx_unused step)
+rvec* EnergyData::pressure(Step gmx_unused step)
{
if (step > pressureStep_)
{
return pressure_;
}
-real* EnergyElement::muTot()
+real* EnergyData::muTot()
{
return muTot_;
}
-gmx_enerdata_t* EnergyElement::enerdata()
+gmx_enerdata_t* EnergyData::enerdata()
{
return enerd_;
}
-gmx_ekindata_t* EnergyElement::ekindata()
+gmx_ekindata_t* EnergyData::ekindata()
{
return ekind_;
}
-bool* EnergyElement::needToSumEkinhOld()
+bool* EnergyData::needToSumEkinhOld()
{
return &needToSumEkinhOld_;
}
-void EnergyElement::writeCheckpoint(t_state gmx_unused* localState, t_state* globalState)
+void EnergyData::Element::writeCheckpoint(t_state gmx_unused* localState, t_state* globalState)
{
if (isMasterRank_)
{
- if (needToSumEkinhOld_)
+ if (energyData_->needToSumEkinhOld_)
{
globalState->ekinstate.bUpToDate = false;
}
else
{
- update_ekinstate(&globalState->ekinstate, ekind_);
+ update_ekinstate(&globalState->ekinstate, energyData_->ekind_);
globalState->ekinstate.bUpToDate = true;
}
- energyOutput_->fillEnergyHistory(observablesHistory_->energyHistory.get());
+ energyData_->energyOutput_->fillEnergyHistory(
+ energyData_->observablesHistory_->energyHistory.get());
}
}
-void EnergyElement::initializeEnergyHistory(StartingBehavior startingBehavior,
- ObservablesHistory* observablesHistory,
- EnergyOutput* energyOutput)
+void EnergyData::initializeEnergyHistory(StartingBehavior startingBehavior,
+ ObservablesHistory* observablesHistory,
+ EnergyOutput* energyOutput)
{
if (startingBehavior != StartingBehavior::NewSimulation)
{
energyOutput->fillEnergyHistory(observablesHistory->energyHistory.get());
}
-void EnergyElement::setVRescaleThermostat(const gmx::VRescaleThermostat* vRescaleThermostat)
+void EnergyData::setVRescaleThermostat(const gmx::VRescaleThermostat* vRescaleThermostat)
{
vRescaleThermostat_ = vRescaleThermostat;
if (vRescaleThermostat_)
}
}
-void EnergyElement::setParrinelloRahamnBarostat(const gmx::ParrinelloRahmanBarostat* parrinelloRahmanBarostat)
+void EnergyData::setParrinelloRahamnBarostat(const gmx::ParrinelloRahmanBarostat* parrinelloRahmanBarostat)
{
parrinelloRahmanBarostat_ = parrinelloRahmanBarostat;
if (parrinelloRahmanBarostat_)
}
}
+EnergyData::Element* EnergyData::element()
+{
+ return element_.get();
+}
+
+EnergyData::Element::Element(EnergyData* energyData, bool isMasterRank) :
+ energyData_(energyData),
+ isMasterRank_(isMasterRank),
+ energyWritingStep_(-1),
+ energyCalculationStep_(-1),
+ freeEnergyCalculationStep_(-1)
+{
+}
+
} // namespace gmx
/*! \internal
* \ingroup module_modularsimulator
- * \brief Element managing energies
+ * \brief Data class managing energies
*
- * The EnergyElement owns the EnergyObject, and is hence responsible
- * for saving energy data and writing it to trajectory. It also owns
+ * The EnergyData owns the EnergyObject,
* the tensors for the different virials and the pressure as well as
- * the total dipole vector.
+ * the total dipole vector. It has a member class which is part of the
+ * simulator loop and and is responsible
+ * for saving energy data and writing it to trajectory.
*
- * It subscribes to the trajectory signaller, the energy signaller,
- * and the logging signaller to know when an energy calculation is
- * needed and when a non-recording step is enough. The simulator
- * builder is responsible to place the element in a location at
- * which a valid energy state is available. The EnergyElement is
- * also a subscriber to the trajectory writer element, as it is
- * responsible to write energy data to trajectory.
- *
- * The EnergyElement offers an interface to add virial contributions,
+ * The EnergyData offers an interface to add virial contributions,
* but also allows access to the raw pointers to tensor data, the
* dipole vector, and the legacy energy data structures.
+ *
+ * The EnergyData owns an object of type EnergyData::Element,
+ * which takes part in the simulation loop, allowing to record
+ * and output energies during the simulation.
*/
-class EnergyElement final :
- public ISimulatorElement,
- public ITrajectoryWriterClient,
- public ITrajectorySignallerClient,
- public IEnergySignallerClient,
- public ICheckpointHelperClient
+class EnergyData final
{
public:
//! Constructor
- EnergyElement(StatePropagatorData* statePropagatorData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- const gmx_mtop_t* globalTopology,
- const t_inputrec* inputrec,
- const MDAtoms* mdAtoms,
- gmx_enerdata_t* enerd,
- gmx_ekindata_t* ekind,
- const Constraints* constr,
- FILE* fplog,
- t_fcdata* fcd,
- const MdModulesNotifier& mdModulesNotifier,
- bool isMasterRank,
- ObservablesHistory* observablesHistory,
- StartingBehavior startingBehavior);
-
- /*! \brief Register run function for step / time
- *
- * This needs to be called when the energies are at a full time step.
- * Positioning this element is the responsibility of the programmer.
- *
- * This is also the place at which the current state becomes the previous
- * state.
- *
- * @param step The step number
- * @param time The time
- * @param registerRunFunction Function allowing to register a run function
- */
- void scheduleTask(Step step, Time time, const RegisterRunFunctionPtr& registerRunFunction) override;
-
- //! No element setup needed
- void elementSetup() override {}
+ EnergyData(StatePropagatorData* statePropagatorData,
+ FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
+ const gmx_mtop_t* globalTopology,
+ const t_inputrec* inputrec,
+ const MDAtoms* mdAtoms,
+ gmx_enerdata_t* enerd,
+ gmx_ekindata_t* ekind,
+ const Constraints* constr,
+ FILE* fplog,
+ t_fcdata* fcd,
+ const MdModulesNotifier& mdModulesNotifier,
+ bool isMasterRank,
+ ObservablesHistory* observablesHistory,
+ StartingBehavior startingBehavior);
/*! \brief Final output
*
- * Prints the averages to log.
+ * Prints the averages to log. This is called from ModularSimulatorAlgorithm.
+ *
+ * \see ModularSimulatorAlgorithm::teardown
*/
- void elementTeardown() override;
+ void teardown();
/*! \brief Add contribution to force virial
*
ObservablesHistory* observablesHistory,
EnergyOutput* energyOutput);
+ //! The element taking part in the simulator loop
+ class Element;
+ //! Get pointer to element (whose lifetime is managed by this)
+ Element* element();
+
private:
/*! \brief Setup (needs file pointer)
- *
- * ITrajectoryWriterClient implementation.
*
* Initializes the EnergyOutput object, and does some logging output.
*
* @param mdoutf File pointer
*/
- void trajectoryWriterSetup(gmx_mdoutf* mdoutf) override;
- //! No trajectory writer teardown needed
- void trajectoryWriterTeardown(gmx_mdoutf gmx_unused* outf) override {}
-
- //! ITrajectoryWriterClient implementation.
- SignallerCallbackPtr registerTrajectorySignallerCallback(TrajectoryEvent event) override;
- //! ITrajectorySignallerClient implementation
- ITrajectoryWriterCallbackPtr registerTrajectoryWriterCallback(TrajectoryEvent event) override;
- //! IEnergySignallerClient implementation
- SignallerCallbackPtr registerEnergyCallback(EnergySignallerEvent event) override;
+ void setup(gmx_mdoutf* mdoutf);
/*! \brief Save data at energy steps
*
*/
void write(gmx_mdoutf* outf, Step step, Time time, bool writeTrajectory, bool writeLog);
- //! ICheckpointHelperClient implementation
- void writeCheckpoint(t_state* localState, t_state* globalState) override;
-
/*
- * Data owned by EnergyElement
+ * Data owned by EnergyData
*/
+ //! The element
+ std::unique_ptr<Element> element_;
//! The energy output object
std::unique_ptr<EnergyOutput> energyOutput_;
//! Whether this is the master rank
const bool isMasterRank_;
- //! The next communicated energy writing step
- Step energyWritingStep_;
- //! The next communicated energy calculation step
- Step energyCalculationStep_;
- //! The next communicated free energy calculation step
- Step freeEnergyCalculationStep_;
//! The force virial tensor
tensor forceVirial_;
/*
* Pointers to Simulator data
*/
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the state propagator data
StatePropagatorData* statePropagatorData_;
//! Pointer to the free energy perturbation element
ObservablesHistory* observablesHistory_;
};
+/*! \internal
+ * \ingroup module_modularsimulator
+ * \brief Element for EnergyData
+ *
+ * This member class allows EnergyData to take part in the simulator
+ * loop.
+ *
+ * It subscribes to the trajectory signaller, the energy signaller,
+ * and the logging signaller to know when an energy calculation is
+ * needed and when a non-recording step is enough. The simulator
+ * builder is responsible to place the element in a location at
+ * which a valid energy state is available. The EnergyData::Element is
+ * also a subscriber to the trajectory writer element, as it is
+ * responsible to write energy data to trajectory.
+ */
+class EnergyData::Element final :
+ public ISimulatorElement,
+ public ITrajectoryWriterClient,
+ public ITrajectorySignallerClient,
+ public IEnergySignallerClient,
+ public ICheckpointHelperClient
+{
+public:
+ //! Constructor
+ Element(EnergyData* energyData, bool isMasterRank);
+
+ /*! \brief Register run function for step / time
+ *
+ * This needs to be called when the energies are at a full time step.
+ * Positioning this element is the responsibility of the programmer.
+ *
+ * This is also the place at which the current state becomes the previous
+ * state.
+ *
+ * @param step The step number
+ * @param time The time
+ * @param registerRunFunction Function allowing to register a run function
+ */
+ void scheduleTask(Step step, Time time, const RegisterRunFunctionPtr& registerRunFunction) override;
+
+ //! No element setup needed
+ void elementSetup() override {}
+
+ //! No element teardown needed
+ void elementTeardown() override {}
+
+private:
+ EnergyData* energyData_;
+
+ /*! \brief Setup (needs file pointer)
+ *
+ * ITrajectoryWriterClient implementation.
+ *
+ * Initializes the EnergyOutput object, and does some logging output.
+ *
+ * @param mdoutf File pointer
+ */
+ void trajectoryWriterSetup(gmx_mdoutf* mdoutf) override;
+ //! No trajectory writer teardown needed
+ void trajectoryWriterTeardown(gmx_mdoutf gmx_unused* outf) override {}
+
+ //! ITrajectoryWriterClient implementation.
+ SignallerCallbackPtr registerTrajectorySignallerCallback(TrajectoryEvent event) override;
+ //! ITrajectorySignallerClient implementation
+ ITrajectoryWriterCallbackPtr registerTrajectoryWriterCallback(TrajectoryEvent event) override;
+ //! IEnergySignallerClient implementation
+ SignallerCallbackPtr registerEnergyCallback(EnergySignallerEvent event) override;
+
+ //! ICheckpointHelperClient implementation
+ void writeCheckpoint(t_state* localState, t_state* globalState) override;
+
+ //! Whether this is the master rank
+ const bool isMasterRank_;
+ //! The next communicated energy writing step
+ Step energyWritingStep_;
+ //! The next communicated energy calculation step
+ Step energyCalculationStep_;
+ //! The next communicated free energy calculation step
+ Step freeEnergyCalculationStep_;
+};
+
} // namespace gmx
#endif // GMX_ENERGYELEMENT_MICROSTATE_H
#include "gromacs/mdtypes/mdatom.h"
#include "gromacs/pbcutil/pbc.h"
-#include "energyelement.h"
+#include "energydata.h"
#include "freeenergyperturbationelement.h"
#include "statepropagatordata.h"
namespace gmx
{
ForceElement::ForceElement(StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
bool isVerbose,
bool isDynamicBox,
nextVirialCalculationStep_(-1),
nextFreeEnergyCalculationStep_(-1),
statePropagatorData_(statePropagatorData),
- energyElement_(energyElement),
+ energyData_(energyData),
freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
localTopology_(nullptr),
isDynamicBox_(isDynamicBox),
relax_shell_flexcon(
fplog_, cr_, ms, isVerbose_, enforcedRotation_, step, inputrec_, imdSession_,
pull_work_, step == nextNSStep_, static_cast<int>(flags), localTopology_, constr_,
- energyElement_->enerdata(), statePropagatorData_->localNumAtoms(), x, v, box,
- lambda, hist, forces, force_vir, mdAtoms_->mdatoms(), nrnb_, wcycle_, shellfc_, fr_,
- runScheduleWork_, time, energyElement_->muTot(), vsite_, ddBalanceRegionHandler_);
+ energyData_->enerdata(), statePropagatorData_->localNumAtoms(), x, v, box, lambda,
+ hist, forces, force_vir, mdAtoms_->mdatoms(), nrnb_, wcycle_, shellfc_, fr_,
+ runScheduleWork_, time, energyData_->muTot(), vsite_, ddBalanceRegionHandler_);
nShellRelaxationSteps_++;
}
else
gmx_edsam* ed = nullptr;
do_force(fplog_, cr_, ms, inputrec_, awh, enforcedRotation_, imdSession_, pull_work_, step,
- nrnb_, wcycle_, localTopology_, box, x, hist, forces, force_vir, mdAtoms_->mdatoms(),
- energyElement_->enerdata(), lambda, fr_, runScheduleWork_, vsite_,
- energyElement_->muTot(), time, ed, static_cast<int>(flags), ddBalanceRegionHandler_);
+ nrnb_, wcycle_, localTopology_, box, x, hist, forces, force_vir,
+ mdAtoms_->mdatoms(), energyData_->enerdata(), lambda, fr_, runScheduleWork_, vsite_,
+ energyData_->muTot(), time, ed, static_cast<int>(flags), ddBalanceRegionHandler_);
}
- energyElement_->addToForceVirial(force_vir, step);
+ energyData_->addToForceVirial(force_vir, step);
}
void ForceElement::elementTeardown()
namespace gmx
{
class Awh;
-class EnergyElement;
+class EnergyData;
class FreeEnergyPerturbationElement;
class ImdSession;
class MDAtoms;
public:
//! Constructor
ForceElement(StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
bool isVerbose,
bool isDynamicBox,
//! The next free energy calculation step
Step nextFreeEnergyCalculationStep_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the micro state
StatePropagatorData* statePropagatorData_;
- //! Pointer to the energy element
- EnergyElement* energyElement_;
+ //! Pointer to the energy data
+ EnergyData* energyData_;
//! Pointer to the free energy perturbation element
FreeEnergyPerturbationElement* freeEnergyPerturbationElement_;
#include "compositesimulatorelement.h"
#include "computeglobalselement.h"
#include "constraintelement.h"
-#include "energyelement.h"
+#include "energydata.h"
#include "forceelement.h"
#include "freeenergyperturbationelement.h"
#include "parrinellorahmanbarostat.h"
SignallerBuilder<NeighborSearchSignaller>* neighborSearchSignallerBuilder,
SignallerBuilder<EnergySignaller>* energySignallerBuilder,
StatePropagatorData* statePropagatorDataPtr,
- EnergyElement* energyElementPtr,
+ EnergyData* energyDataPtr,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
TopologyHolder* topologyHolder)
{
const bool isDynamicBox = inputrecDynamicBox(inputrec);
auto forceElement = std::make_unique<ForceElement>(
- statePropagatorDataPtr, energyElementPtr, freeEnergyPerturbationElement, isVerbose,
+ statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElement, isVerbose,
isDynamicBox, fplog, cr, inputrec, mdAtoms, nrnb, fr, wcycle, runScheduleWork, vsite,
imdSession, pull_work, constr, top_global, enforcedRotation);
topologyHolder->registerClient(forceElement.get());
std::vector<ICheckpointHelperClient*>* checkpointClients,
CheckBondedInteractionsCallbackPtr* checkBondedInteractionsCallback,
compat::not_null<StatePropagatorData*> statePropagatorDataPtr,
- compat::not_null<EnergyElement*> energyElementPtr,
+ compat::not_null<EnergyData*> energyDataPtr,
FreeEnergyPerturbationElement* freeEnergyPerturbationElementPtr,
bool hasReadEkinState,
TopologyHolder* topologyHolder,
SimulationSignals* signals)
{
auto forceElement = buildForces(neighborSearchSignallerBuilder, energySignallerBuilder,
- statePropagatorDataPtr, energyElementPtr,
+ statePropagatorDataPtr, energyDataPtr,
freeEnergyPerturbationElementPtr, topologyHolder);
// list of elements owned by the simulator composite object
{
auto computeGlobalsElement =
std::make_unique<ComputeGlobalsElement<ComputeGlobalsAlgorithm::LeapFrog>>(
- statePropagatorDataPtr, energyElementPtr, freeEnergyPerturbationElementPtr,
+ statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
signals, nstglobalcomm_, fplog, mdlog, cr, inputrec, mdAtoms, nrnb, wcycle,
fr, top_global, constr, hasReadEkinState);
topologyHolder->registerClient(computeGlobalsElement.get());
auto thermostat = std::make_unique<VRescaleThermostat>(
inputrec->nsttcouple, -1, false, inputrec->ld_seed, inputrec->opts.ngtc,
inputrec->delta_t * inputrec->nsttcouple, inputrec->opts.ref_t, inputrec->opts.tau_t,
- inputrec->opts.nrdf, energyElementPtr, propagator->viewOnVelocityScaling(),
+ inputrec->opts.nrdf, energyDataPtr, propagator->viewOnVelocityScaling(),
propagator->velocityScalingCallback(), state_global, cr, inputrec->bContinuation);
checkpointClients->emplace_back(thermostat.get());
- energyElementPtr->setVRescaleThermostat(thermostat.get());
+ energyDataPtr->setVRescaleThermostat(thermostat.get());
addToCallListAndMove(std::move(thermostat), elementCallList, elementsOwnershipList);
}
prBarostat = std::make_unique<ParrinelloRahmanBarostat>(
inputrec->nstpcouple, -1, inputrec->delta_t * inputrec->nstpcouple,
inputrec->init_step, propagator->viewOnPRScalingMatrix(),
- propagator->prScalingCallback(), statePropagatorDataPtr, energyElementPtr,
- fplog, inputrec, mdAtoms, state_global, cr, inputrec->bContinuation);
- energyElementPtr->setParrinelloRahamnBarostat(prBarostat.get());
+ propagator->prScalingCallback(), statePropagatorDataPtr, energyDataPtr, fplog,
+ inputrec, mdAtoms, state_global, cr, inputrec->bContinuation);
+ energyDataPtr->setParrinelloRahamnBarostat(prBarostat.get());
checkpointClients->emplace_back(prBarostat.get());
}
addToCallListAndMove(std::move(propagator), elementCallList, elementsOwnershipList);
if (constr)
{
auto constraintElement = std::make_unique<ConstraintsElement<ConstraintVariable::Positions>>(
- constr, statePropagatorDataPtr, energyElementPtr, freeEnergyPerturbationElementPtr,
+ constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
MASTER(cr), fplog, inputrec, mdAtoms->mdatoms());
auto constraintElementPtr = compat::make_not_null(constraintElement.get());
energySignallerBuilder->registerSignallerClient(constraintElementPtr);
}
addToCallListAndMove(std::move(computeGlobalsElement), elementCallList, elementsOwnershipList);
- addToCallList(energyElementPtr, elementCallList); // we have the energies at time t here!
+ auto energyElement = compat::make_not_null(energyDataPtr->element());
+ trajectoryElementBuilder->registerWriterClient(energyElement);
+ trajectorySignallerBuilder->registerSignallerClient(energyElement);
+ energySignallerBuilder->registerSignallerClient(energyElement);
+ checkpointClients->emplace_back(energyElement);
+ // we have the energies at time t here!
+ addToCallList(energyElement, elementCallList);
if (prBarostat)
{
addToCallListAndMove(std::move(prBarostat), elementCallList, elementsOwnershipList);
{
auto computeGlobalsElement =
std::make_unique<ComputeGlobalsElement<ComputeGlobalsAlgorithm::VelocityVerlet>>(
- statePropagatorDataPtr, energyElementPtr, freeEnergyPerturbationElementPtr,
+ statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
signals, nstglobalcomm_, fplog, mdlog, cr, inputrec, mdAtoms, nrnb, wcycle,
fr, &topologyHolder->globalTopology(), constr, hasReadEkinState);
topologyHolder->registerClient(computeGlobalsElement.get());
prBarostat = std::make_unique<ParrinelloRahmanBarostat>(
inputrec->nstpcouple, -1, inputrec->delta_t * inputrec->nstpcouple,
inputrec->init_step, propagatorVelocities->viewOnPRScalingMatrix(),
- propagatorVelocities->prScalingCallback(), statePropagatorDataPtr, energyElementPtr,
+ propagatorVelocities->prScalingCallback(), statePropagatorDataPtr, energyDataPtr,
fplog, inputrec, mdAtoms, state_global, cr, inputrec->bContinuation);
- energyElementPtr->setParrinelloRahamnBarostat(prBarostat.get());
+ energyDataPtr->setParrinelloRahamnBarostat(prBarostat.get());
checkpointClients->emplace_back(prBarostat.get());
}
addToCallListAndMove(std::move(propagatorVelocities), elementCallList, elementsOwnershipList);
if (constr)
{
auto constraintElement = std::make_unique<ConstraintsElement<ConstraintVariable::Velocities>>(
- constr, statePropagatorDataPtr, energyElementPtr, freeEnergyPerturbationElementPtr,
+ constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
MASTER(cr), fplog, inputrec, mdAtoms->mdatoms());
energySignallerBuilder->registerSignallerClient(compat::make_not_null(constraintElement.get()));
trajectorySignallerBuilder->registerSignallerClient(
auto thermostat = std::make_unique<VRescaleThermostat>(
inputrec->nsttcouple, 0, true, inputrec->ld_seed, inputrec->opts.ngtc,
inputrec->delta_t * inputrec->nsttcouple, inputrec->opts.ref_t,
- inputrec->opts.tau_t, inputrec->opts.nrdf, energyElementPtr,
+ inputrec->opts.tau_t, inputrec->opts.nrdf, energyDataPtr,
propagatorVelocitiesAndPositions->viewOnVelocityScaling(),
propagatorVelocitiesAndPositions->velocityScalingCallback(), state_global, cr,
inputrec->bContinuation);
checkpointClients->emplace_back(thermostat.get());
- energyElementPtr->setVRescaleThermostat(thermostat.get());
+ energyDataPtr->setVRescaleThermostat(thermostat.get());
addToCallListAndMove(std::move(thermostat), elementCallList, elementsOwnershipList);
}
addToCallListAndMove(std::move(propagatorVelocitiesAndPositions), elementCallList,
if (constr)
{
auto constraintElement = std::make_unique<ConstraintsElement<ConstraintVariable::Positions>>(
- constr, statePropagatorDataPtr, energyElementPtr, freeEnergyPerturbationElementPtr,
+ constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
MASTER(cr), fplog, inputrec, mdAtoms->mdatoms());
energySignallerBuilder->registerSignallerClient(compat::make_not_null(constraintElement.get()));
trajectorySignallerBuilder->registerSignallerClient(
addToCallListAndMove(std::move(constraintElement), elementCallList, elementsOwnershipList);
}
addToCallListAndMove(std::move(computeGlobalsElement), elementCallList, elementsOwnershipList);
- addToCallList(energyElementPtr, elementCallList); // we have the energies at time t here!
+ auto energyElement = compat::make_not_null(energyDataPtr->element());
+ trajectoryElementBuilder->registerWriterClient(energyElement);
+ trajectorySignallerBuilder->registerSignallerClient(energyElement);
+ energySignallerBuilder->registerSignallerClient(energyElement);
+ checkpointClients->emplace_back(energyElement);
+ // we have the energies at time t here!
+ addToCallList(energyElement, elementCallList);
if (prBarostat)
{
addToCallListAndMove(std::move(prBarostat), elementCallList, elementsOwnershipList);
#include "gromacs/mdtypes/state.h"
#include "gromacs/pbcutil/boxutilities.h"
-#include "energyelement.h"
+#include "energydata.h"
#include "statepropagatordata.h"
namespace gmx
ArrayRef<rvec> scalingTensor,
PropagatorCallbackPtr propagatorCallback,
StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FILE* fplog,
const t_inputrec* inputrec,
const MDAtoms* mdAtoms,
scalingTensor_(scalingTensor),
propagatorCallback_(std::move(propagatorCallback)),
statePropagatorData_(statePropagatorData),
- energyElement_(energyElement),
+ energyData_(energyData),
fplog_(fplog),
inputrec_(inputrec),
mdAtoms_(mdAtoms)
void ParrinelloRahmanBarostat::integrateBoxVelocityEquations(Step step)
{
auto box = statePropagatorData_->constBox();
- parrinellorahman_pcoupl(fplog_, step, inputrec_, couplingTimeStep_, energyElement_->pressure(step),
+ parrinellorahman_pcoupl(fplog_, step, inputrec_, couplingTimeStep_, energyData_->pressure(step),
box, boxRel_, boxVelocity_, scalingTensor_.data(), mu_, false);
// multiply matrix by the coupling time step to avoid having the propagator needing to know about that
msmul(scalingTensor_.data(), couplingTimeStep_, scalingTensor_.data());
namespace gmx
{
-class EnergyElement;
+class EnergyData;
class MDAtoms;
class StatePropagatorData;
ArrayRef<rvec> scalingTensor,
PropagatorCallbackPtr propagatorCallback,
StatePropagatorData* statePropagatorData,
- EnergyElement* energyElement,
+ EnergyData* energyData,
FILE* fplog,
const t_inputrec* inputrec,
const MDAtoms* mdAtoms,
//! Box velocity
tensor boxVelocity_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the micro state
StatePropagatorData* statePropagatorData_;
- //! Pointer to the energy element
- EnergyElement* energyElement_;
+ //! Pointer to the energy data
+ EnergyData* energyData_;
//! Integrate the PR box vector equations of motion - does not alter state
void integrateBoxVelocityEquations(Step step);
//! Whether PME load balancing printing is active \todo Check this!
bool bPMETunePrinting_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the micro state
StatePropagatorData* statePropagatorData_;
//! The time step
const real timestep_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the micro state
StatePropagatorData* statePropagatorData_;
gmx_walltime_accounting* walltime_accounting) :
taskIterator_(taskQueue_.end()),
statePropagatorData_(nullptr),
+ energyData_(nullptr),
step_(-1),
runFinished_(false),
topologyName_(std::move(topologyName)),
{
element->elementTeardown();
}
+ energyData_->teardown();
if (pmeLoadBalanceHelper_)
{
pmeLoadBalanceHelper_->teardown();
top_global->natoms, cr, state_global, fr->nbv->useGpu(), inputrec, mdAtoms->mdatoms());
auto statePropagatorDataPtr = compat::make_not_null(algorithm.statePropagatorData_.get());
- auto energyElement = std::make_unique<EnergyElement>(
+ algorithm.energyData_ = std::make_unique<EnergyData>(
statePropagatorDataPtr, freeEnergyPerturbationElementPtr, top_global, inputrec, mdAtoms,
enerd, ekind, constr, fplog, &fr->listedForces->fcdata(), mdModulesNotifier, MASTER(cr),
observablesHistory, startingBehavior);
- auto energyElementPtr = compat::make_not_null(energyElement.get());
+ auto energyDataPtr = compat::make_not_null(algorithm.energyData_.get());
/*
* Build stop handler
SignallerBuilder<TrajectorySignaller> trajectorySignallerBuilder;
TrajectoryElementBuilder trajectoryElementBuilder;
- /*
- * Register data structures to signallers
- */
-
- trajectoryElementBuilder.registerWriterClient(energyElementPtr);
- trajectorySignallerBuilder.registerSignallerClient(energyElementPtr);
- energySignallerBuilder.registerSignallerClient(energyElementPtr);
-
// Register the simulator itself to the neighbor search / last step signaller
neighborSearchSignallerBuilder.registerSignallerClient(
compat::make_not_null(algorithm.signalHelper_.get()));
* have a full timestep state.
*/
// TODO: Make a CheckpointHelperBuilder
- std::vector<ICheckpointHelperClient*> checkpointClients = { energyElementPtr,
- freeEnergyPerturbationElementPtr };
+ std::vector<ICheckpointHelperClient*> checkpointClients = { freeEnergyPerturbationElementPtr };
CheckBondedInteractionsCallbackPtr checkBondedInteractionsCallback = nullptr;
auto integrator = buildIntegrator(
&neighborSearchSignallerBuilder, &lastStepSignallerBuilder, &energySignallerBuilder,
&loggingSignallerBuilder, &trajectorySignallerBuilder, &trajectoryElementBuilder,
&checkpointClients, &checkBondedInteractionsCallback, statePropagatorDataPtr,
- energyElementPtr, freeEnergyPerturbationElementPtr, hasReadEkinState,
+ energyDataPtr, freeEnergyPerturbationElementPtr, hasReadEkinState,
algorithm.topologyHolder_.get(), &algorithm.signals_);
/*
addToCallListAndMove(std::move(integrator), algorithm.elementCallList_, algorithm.elementsOwnershipList_);
addToCallListAndMove(std::move(trajectoryElement), algorithm.elementCallList_,
algorithm.elementsOwnershipList_);
- algorithm.elementsOwnershipList_.emplace_back(std::move(energyElement));
return algorithm;
}
namespace gmx
{
-class EnergyElement;
+class EnergyData;
class EnergySignaller;
class FreeEnergyPerturbationElement;
class LoggingSignaller;
// Data structures
//! The state propagator data
std::unique_ptr<StatePropagatorData> statePropagatorData_;
+ //! The energy data
+ std::unique_ptr<EnergyData> energyData_;
//! The current step
Step step_;
std::vector<ICheckpointHelperClient*>* checkpointClients,
CheckBondedInteractionsCallbackPtr* checkBondedInteractionsCallback,
compat::not_null<StatePropagatorData*> statePropagatorDataPtr,
- compat::not_null<EnergyElement*> energyElementPtr,
+ compat::not_null<EnergyData*> energyDataPtr,
FreeEnergyPerturbationElement* freeEnergyPerturbationElementPtr,
bool hasReadEkinState,
TopologyHolder* topologyHolder,
buildForces(SignallerBuilder<NeighborSearchSignaller>* neighborSearchSignallerBuilder,
SignallerBuilder<EnergySignaller>* energySignallerBuilder,
StatePropagatorData* statePropagatorDataPtr,
- EnergyElement* energyElementPtr,
+ EnergyData* energyDataPtr,
FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
TopologyHolder* topologyHolder);
//! Callback writing the state to file
void write(gmx_mdoutf* outf, Step step, Time time);
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
//! Pointer to the free energy perturbation element (for trajectory writing only)
FreeEnergyPerturbationElement* freeEnergyPerturbationElement_;
const real* referenceTemperature,
const real* couplingTime,
const real* numDegreesOfFreedom,
- EnergyElement* energyElement,
+ EnergyData* energyData,
ArrayRef<real> lambdaView,
PropagatorCallbackPtr propagatorCallback,
const t_state* globalState,
couplingTime_(couplingTime, couplingTime + numTemperatureGroups),
numDegreesOfFreedom_(numDegreesOfFreedom, numDegreesOfFreedom + numTemperatureGroups),
thermostatIntegral_(numTemperatureGroups, 0.0),
- energyElement_(energyElement),
+ energyData_(energyData),
lambda_(lambdaView),
propagatorCallback_(std::move(propagatorCallback))
{
{
real currentKineticEnergy, referenceKineticEnergy, newKineticEnergy;
- auto ekind = energyElement_->ekindata();
+ auto ekind = energyData_->ekindata();
for (int i = 0; (i < numTemperatureGroups_); i++)
{
#include "gromacs/utility/arrayref.h"
-#include "energyelement.h"
+#include "energydata.h"
#include "modularsimulatorinterfaces.h"
#include "propagator.h"
const real* referenceTemperature,
const real* couplingTime,
const real* numDegreesOfFreedom,
- EnergyElement* energyElement,
+ EnergyData* energyData,
ArrayRef<real> lambdaView,
PropagatorCallbackPtr propagatorCallback,
const t_state* globalState,
//! Work exerted by thermostat
std::vector<double> thermostatIntegral_;
- //! Pointer to the energy element (for ekindata)
- EnergyElement* energyElement_;
+ // TODO: Clarify relationship to data objects and find a more robust alternative to raw pointers (#3583)
+ //! Pointer to the energy data (for ekindata)
+ EnergyData* energyData_;
//! View on the scaling factor of the propagator
ArrayRef<real> lambda_;
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff