callback to the propagator to update the velocity scaling factor, and
scales the box and the positions of the system.
-#### `FreeEnergyPerturbationElement`
-The `FreeEnergyPerturbationElement` holds the lambda vector and the
-current FEP state, offering access to its values via getter
-functions. The FreeEnergyPerturbationElement does update the lambda
+#### `FreeEnergyPerturbationData::Element`
+The `FreeEnergyPerturbationData::Element` is a member class of
+`FreeEnergyPerturbationData` that updates the lambda
values during the simulation run if lambda is non-static. It
-implements the checkpointing client interface to save its current
-state for restart.
+implements the checkpointing client interface to save the current
+state of `FreeEnergyPerturbationData` for restart.
## Data structures
but also allows access to the raw pointers to tensor data, the
dipole vector, and the legacy energy data structures.
+### `FreeEnergyPerturbationData`
+The `FreeEnergyPerturbationData` holds the lambda vector and the
+current FEP state, offering access to its values via getter
+functions.
+
### `TopologyHolder`
The topology object owns the local topology and holds a constant reference
to the global topology owned by the ISimulator.
#include "gromacs/mdtypes/mdatom.h"
#include "gromacs/topology/topology.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
namespace gmx
{
template<ComputeGlobalsAlgorithm algorithm>
ComputeGlobalsElement<algorithm>::ComputeGlobalsElement(StatePropagatorData* statePropagatorData,
EnergyData* energyData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
SimulationSignals* signals,
int nstglobalcomm,
FILE* fplog,
statePropagatorData_(statePropagatorData),
energyData_(energyData),
localTopology_(nullptr),
- freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
+ freeEnergyPerturbationData_(freeEnergyPerturbationData),
vcm_(global_top->groups, *inputrec),
signals_(signals),
fplog_(fplog),
namespace gmx
{
-class FreeEnergyPerturbationElement;
+class FreeEnergyPerturbationData;
class MDAtoms;
class MDLogger;
{
public:
//! Constructor
- ComputeGlobalsElement(StatePropagatorData* statePropagatorData,
- EnergyData* energyData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- 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,
- bool hasReadEkinState);
+ 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,
+ bool hasReadEkinState);
//! Destructor
~ComputeGlobalsElement() override;
EnergyData* energyData_;
//! Pointer to the local topology (only needed for checkNumberOfBondedInteractions)
const gmx_localtop_t* localTopology_;
- //! Pointer to the free energy perturbation element
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement_;
+ //! Pointer to the free energy perturbation data
+ FreeEnergyPerturbationData* freeEnergyPerturbationData_;
//! Center of mass motion removal
t_vcm vcm_;
#include "gromacs/utility/fatalerror.h"
#include "energydata.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
#include "statepropagatordata.h"
namespace gmx
{
template<ConstraintVariable variable>
-ConstraintsElement<variable>::ConstraintsElement(Constraints* constr,
- StatePropagatorData* statePropagatorData,
- EnergyData* energyData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- bool isMaster,
- FILE* fplog,
- const t_inputrec* inputrec,
- const t_mdatoms* mdAtoms) :
+ConstraintsElement<variable>::ConstraintsElement(Constraints* constr,
+ StatePropagatorData* statePropagatorData,
+ EnergyData* energyData,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ bool isMaster,
+ FILE* fplog,
+ const t_inputrec* inputrec,
+ const t_mdatoms* mdAtoms) :
nextVirialCalculationStep_(-1),
nextEnergyWritingStep_(-1),
nextLogWritingStep_(-1),
isMasterRank_(isMaster),
statePropagatorData_(statePropagatorData),
energyData_(energyData),
- freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
+ freeEnergyPerturbationData_(freeEnergyPerturbationData),
constr_(constr),
fplog_(fplog),
inputrec_(inputrec),
&& ((variable == ConstraintVariable::Positions && inputrec_->eI == eiMD)
|| (variable == ConstraintVariable::Velocities && inputrec_->eI == eiVV)))
{
- const real lambdaBonded = freeEnergyPerturbationElement_
- ? freeEnergyPerturbationElement_->constLambdaView()[efptBONDED]
+ const real lambdaBonded = freeEnergyPerturbationData_
+ ? freeEnergyPerturbationData_->constLambdaView()[efptBONDED]
: 0;
// Constrain the initial coordinates and velocities
do_constrain_first(
ArrayRef<RVec> min_proj;
ArrayRefWithPadding<RVec> v;
- const real lambdaBonded = freeEnergyPerturbationElement_
- ? freeEnergyPerturbationElement_->constLambdaView()[efptBONDED]
- : 0;
+ const real lambdaBonded =
+ freeEnergyPerturbationData_ ? freeEnergyPerturbationData_->constLambdaView()[efptBONDED] : 0;
real dvdlambda = 0;
switch (variable)
{
class Constraints;
class EnergyData;
-class FreeEnergyPerturbationElement;
+class FreeEnergyPerturbationData;
class StatePropagatorData;
/*! \internal
{
public:
//! Constructor
- ConstraintsElement(Constraints* constr,
- StatePropagatorData* statePropagatorData,
- EnergyData* energyData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- bool isMaster,
- FILE* fplog,
- const t_inputrec* inputrec,
- const t_mdatoms* mdAtoms);
+ ConstraintsElement(Constraints* constr,
+ StatePropagatorData* statePropagatorData,
+ EnergyData* energyData,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ bool isMaster,
+ FILE* fplog,
+ const t_inputrec* inputrec,
+ const t_mdatoms* mdAtoms);
/*! \brief Register constraining function for step / time
*
StatePropagatorData* statePropagatorData_;
//! Pointer to the energy data
EnergyData* energyData_;
- //! Pointer to the free energy perturbation element
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement_;
+ //! Pointer to the free energy perturbation data
+ FreeEnergyPerturbationData* freeEnergyPerturbationData_;
// Access to ISimulator data
//! Handles constraints.
#include "gromacs/mdtypes/state.h"
#include "gromacs/topology/topology.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
#include "parrinellorahmanbarostat.h"
#include "statepropagatordata.h"
#include "vrescalethermostat.h"
{
class Awh;
-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) :
+EnergyData::EnergyData(StatePropagatorData* statePropagatorData,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ 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),
forceVirialStep_(-1),
needToSumEkinhOld_(false),
startingBehavior_(startingBehavior),
statePropagatorData_(statePropagatorData),
- freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
+ freeEnergyPerturbationData_(freeEnergyPerturbationData),
vRescaleThermostat_(nullptr),
parrinelloRahmanBarostat_(nullptr),
inputrec_(inputrec),
clear_mat(pressure_);
clear_rvec(muTot_);
- if (freeEnergyPerturbationElement_)
+ if (freeEnergyPerturbationData_)
{
dummyLegacyState_.flags = (1U << estFEPSTATE);
}
{
dummyLegacyState_.therm_integral = vRescaleThermostat_->thermostatIntegral();
}
- if (freeEnergyPerturbationElement_)
+ if (freeEnergyPerturbationData_)
{
- accumulateKineticLambdaComponents(enerd_, freeEnergyPerturbationElement_->constLambdaView(),
+ accumulateKineticLambdaComponents(enerd_, freeEnergyPerturbationData_->constLambdaView(),
*inputrec_->fepvals);
- dummyLegacyState_.fep_state = freeEnergyPerturbationElement_->currentFEPState();
+ dummyLegacyState_.fep_state = freeEnergyPerturbationData_->currentFEPState();
}
if (parrinelloRahmanBarostat_)
{
enum class StartingBehavior;
class Constraints;
class EnergyOutput;
-class FreeEnergyPerturbationElement;
+class FreeEnergyPerturbationData;
class MDAtoms;
class ParrinelloRahmanBarostat;
class StatePropagatorData;
{
public:
//! Constructor
- 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);
+ EnergyData(StatePropagatorData* statePropagatorData,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ 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
*
// 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
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement_;
+ //! Pointer to the free energy perturbation data
+ FreeEnergyPerturbationData* freeEnergyPerturbationData_;
//! Pointer to the vrescale thermostat
const VRescaleThermostat* vRescaleThermostat_;
//! Pointer to the Parrinello-Rahman barostat
#include "gromacs/pbcutil/pbc.h"
#include "energydata.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
#include "statepropagatordata.h"
struct gmx_edsam;
namespace gmx
{
-ForceElement::ForceElement(StatePropagatorData* statePropagatorData,
- EnergyData* energyData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- bool isVerbose,
- bool isDynamicBox,
- FILE* fplog,
- const t_commrec* cr,
- const t_inputrec* inputrec,
- const MDAtoms* mdAtoms,
- t_nrnb* nrnb,
- t_forcerec* fr,
- gmx_wallcycle* wcycle,
- MdrunScheduleWorkload* runScheduleWork,
- VirtualSitesHandler* vsite,
- ImdSession* imdSession,
- pull_t* pull_work,
- Constraints* constr,
- const gmx_mtop_t* globalTopology,
- gmx_enfrot* enforcedRotation) :
+ForceElement::ForceElement(StatePropagatorData* statePropagatorData,
+ EnergyData* energyData,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ bool isVerbose,
+ bool isDynamicBox,
+ FILE* fplog,
+ const t_commrec* cr,
+ const t_inputrec* inputrec,
+ const MDAtoms* mdAtoms,
+ t_nrnb* nrnb,
+ t_forcerec* fr,
+
+ gmx_wallcycle* wcycle,
+ MdrunScheduleWorkload* runScheduleWork,
+ VirtualSitesHandler* vsite,
+ ImdSession* imdSession,
+ pull_t* pull_work,
+ Constraints* constr,
+ const gmx_mtop_t* globalTopology,
+ gmx_enfrot* enforcedRotation) :
shellfc_(init_shell_flexcon(fplog,
globalTopology,
constr ? constr->numFlexibleConstraints() : 0,
nextFreeEnergyCalculationStep_(-1),
statePropagatorData_(statePropagatorData),
energyData_(energyData),
- freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
+ freeEnergyPerturbationData_(freeEnergyPerturbationData),
localTopology_(nullptr),
isDynamicBox_(isDynamicBox),
isVerbose_(isVerbose),
tensor force_vir = { { 0 } };
// TODO: Make lambda const (needs some adjustments in lower force routines)
ArrayRef<real> lambda =
- freeEnergyPerturbationElement_ ? freeEnergyPerturbationElement_->lambdaView() : lambda_;
+ freeEnergyPerturbationData_ ? freeEnergyPerturbationData_->lambdaView() : lambda_;
if (doShellFC)
{
{
class Awh;
class EnergyData;
-class FreeEnergyPerturbationElement;
+class FreeEnergyPerturbationData;
class ImdSession;
class MDAtoms;
class MdrunScheduleWorkload;
{
public:
//! Constructor
- ForceElement(StatePropagatorData* statePropagatorData,
- EnergyData* energyData,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- bool isVerbose,
- bool isDynamicBox,
- FILE* fplog,
- const t_commrec* cr,
- const t_inputrec* inputrec,
- const MDAtoms* mdAtoms,
- t_nrnb* nrnb,
- t_forcerec* fr,
- gmx_wallcycle* wcycle,
- MdrunScheduleWorkload* runScheduleWork,
- VirtualSitesHandler* vsite,
- ImdSession* imdSession,
- pull_t* pull_work,
- Constraints* constr,
- const gmx_mtop_t* globalTopology,
- gmx_enfrot* enforcedRotation);
+ ForceElement(StatePropagatorData* statePropagatorData,
+ EnergyData* energyData,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ bool isVerbose,
+ bool isDynamicBox,
+ FILE* fplog,
+ const t_commrec* cr,
+ const t_inputrec* inputrec,
+ const MDAtoms* mdAtoms,
+ t_nrnb* nrnb,
+ t_forcerec* fr,
+
+ gmx_wallcycle* wcycle,
+ MdrunScheduleWorkload* runScheduleWork,
+ VirtualSitesHandler* vsite,
+ ImdSession* imdSession,
+ pull_t* pull_work,
+ Constraints* constr,
+ const gmx_mtop_t* globalTopology,
+ gmx_enfrot* enforcedRotation);
/*! \brief Register force calculation for step / time
*
StatePropagatorData* statePropagatorData_;
//! Pointer to the energy data
EnergyData* energyData_;
- //! Pointer to the free energy perturbation element
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement_;
+ //! Pointer to the free energy perturbation data
+ FreeEnergyPerturbationData* freeEnergyPerturbationData_;
//! The local topology - updated by Topology via Client system
const gmx_localtop_t* localTopology_;
#include "gmxpre.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
#include "gromacs/mdlib/md_support.h"
#include "gromacs/mdlib/mdatoms.h"
namespace gmx
{
-FreeEnergyPerturbationElement::FreeEnergyPerturbationElement(FILE* fplog,
- const t_inputrec* inputrec,
- MDAtoms* mdAtoms) :
+FreeEnergyPerturbationData::FreeEnergyPerturbationData(FILE* fplog, const t_inputrec* inputrec, MDAtoms* mdAtoms) :
+ element_(std::make_unique<Element>(this, inputrec->fepvals->delta_lambda)),
lambda_(),
lambda0_(),
currentFEPState_(0),
- lambdasChange_(inputrec->fepvals->delta_lambda != 0),
fplog_(fplog),
inputrec_(inputrec),
mdAtoms_(mdAtoms)
update_mdatoms(mdAtoms_->mdatoms(), lambda_[efptMASS]);
}
-void FreeEnergyPerturbationElement::scheduleTask(Step step,
- Time gmx_unused time,
- const RegisterRunFunctionPtr& registerRunFunction)
+void FreeEnergyPerturbationData::Element::scheduleTask(Step step,
+ Time gmx_unused time,
+ const RegisterRunFunctionPtr& registerRunFunction)
{
if (lambdasChange_)
{
- (*registerRunFunction)(
- std::make_unique<SimulatorRunFunction>([this, step]() { updateLambdas(step); }));
+ (*registerRunFunction)(std::make_unique<SimulatorRunFunction>(
+ [this, step]() { freeEnergyPerturbationData_->updateLambdas(step); }));
}
}
-void FreeEnergyPerturbationElement::updateLambdas(Step step)
+void FreeEnergyPerturbationData::updateLambdas(Step step)
{
// at beginning of step (if lambdas change...)
setCurrentLambdasLocal(step, inputrec_->fepvals, lambda0_.data(), lambda_, currentFEPState_);
update_mdatoms(mdAtoms_->mdatoms(), lambda_[efptMASS]);
}
-ArrayRef<real> FreeEnergyPerturbationElement::lambdaView()
+ArrayRef<real> FreeEnergyPerturbationData::lambdaView()
{
return lambda_;
}
-ArrayRef<const real> FreeEnergyPerturbationElement::constLambdaView()
+ArrayRef<const real> FreeEnergyPerturbationData::constLambdaView()
{
return lambda_;
}
-int FreeEnergyPerturbationElement::currentFEPState()
+int FreeEnergyPerturbationData::currentFEPState()
{
return currentFEPState_;
}
-void FreeEnergyPerturbationElement::writeCheckpoint(t_state* localState, t_state gmx_unused* globalState)
+void FreeEnergyPerturbationData::Element::writeCheckpoint(t_state* localState, t_state gmx_unused* globalState)
{
- localState->fep_state = currentFEPState_;
- localState->lambda = lambda_;
+ localState->fep_state = freeEnergyPerturbationData_->currentFEPState_;
+ localState->lambda = freeEnergyPerturbationData_->lambda_;
localState->flags |= (1U << estLAMBDA) | (1U << estFEPSTATE);
}
+FreeEnergyPerturbationData::Element::Element(FreeEnergyPerturbationData* freeEnergyPerturbationElement,
+ double deltaLambda) :
+ freeEnergyPerturbationData_(freeEnergyPerturbationElement),
+ lambdasChange_(deltaLambda != 0)
+{
+}
+
+FreeEnergyPerturbationData::Element* FreeEnergyPerturbationData::element()
+{
+ return element_.get();
+}
+
} // namespace gmx
/*! \internal
* \ingroup module_modularsimulator
- * \brief The free energy perturbation element
+ * \brief The free energy perturbation data
*
* The lambda vector and the current FEP state are held by the
- * FreeEnergyPerturbationElement, offering access to its values via getter
- * functions. The FreeEnergyPerturbationElement does update the lambda
- * values during the simulation run if lambda is non-static. It does
- * implement the checkpointing client interface to save its current
- * state for restart.
+ * FreeEnergyPerturbationData, offering access to its values via getter
+ * functions. The FreeEnergyPerturbationData::Element is responsible for
+ * lambda update (if applicable) and checkpointing.
*/
-class FreeEnergyPerturbationElement final : public ISimulatorElement, public ICheckpointHelperClient
+class FreeEnergyPerturbationData final
{
public:
//! Constructor
- FreeEnergyPerturbationElement(FILE* fplog, const t_inputrec* inputrec, MDAtoms* mdAtoms);
+ FreeEnergyPerturbationData(FILE* fplog, const t_inputrec* inputrec, MDAtoms* mdAtoms);
//! Get a view of the current lambda vector
ArrayRef<real> lambdaView();
//! Get the current FEP state
int currentFEPState();
- //! Update lambda and mdatoms
- void scheduleTask(Step step, Time time, const RegisterRunFunctionPtr& registerRunFunction) override;
-
- //! No setup needed
- void elementSetup() override{};
-
- //! No teardown needed
- void elementTeardown() override{};
+ //! The element taking part in the simulator loop
+ class Element;
+ //! Get pointer to element (whose lifetime is managed by this)
+ Element* element();
private:
- //! ICheckpointHelperClient implementation
- void writeCheckpoint(t_state* localState, t_state* globalState) override;
//! Update the lambda values
void updateLambdas(Step step);
+ //! The element
+ std::unique_ptr<Element> element_;
+
//! The lambda vector
std::array<real, efptNR> lambda_;
//! The starting lambda vector
//! The current free energy state
int currentFEPState_;
- //! Whether lambda values are non-static
- const bool lambdasChange_;
-
//! Handles logging.
FILE* fplog_;
//! Contains user input mdp options.
MDAtoms* mdAtoms_;
};
+
+/*! \internal
+ * \ingroup module_modularsimulator
+ * \brief The free energy perturbation data element
+ *
+ * The FreeEnergyPerturbationData::Element does update the lambda
+ * values during the simulation run if lambda is non-static. It does
+ * implement the checkpointing client interface to save its current
+ * state for restart.
+ */
+class FreeEnergyPerturbationData::Element final : public ISimulatorElement, public ICheckpointHelperClient
+{
+public:
+ //! Constructor
+ explicit Element(FreeEnergyPerturbationData* freeEnergyPerturbationElement, double deltaLambda);
+
+ //! Update lambda and mdatoms
+ void scheduleTask(Step step, Time time, const RegisterRunFunctionPtr& registerRunFunction) override;
+
+ //! No setup needed
+ void elementSetup() override{};
+
+ //! No teardown needed
+ void elementTeardown() override{};
+
+private:
+ //! The free energy data
+ FreeEnergyPerturbationData* freeEnergyPerturbationData_;
+ //! Whether lambda values are non-static
+ const bool lambdasChange_;
+
+ //! ICheckpointHelperClient implementation
+ void writeCheckpoint(t_state* localState, t_state* globalState) override;
+};
+
} // namespace gmx
#endif // GMX_MODULARSIMULATOR_FREEENERGYPERTURBATIONELEMENT_H
#include "constraintelement.h"
#include "energydata.h"
#include "forceelement.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
#include "parrinellorahmanbarostat.h"
#include "propagator.h"
#include "signallers.h"
SignallerBuilder<EnergySignaller>* energySignallerBuilder,
StatePropagatorData* statePropagatorDataPtr,
EnergyData* energyDataPtr,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
+ FreeEnergyPerturbationData* freeEnergyPerturbationDataPtr,
TopologyHolder* topologyHolder)
{
const bool isVerbose = mdrunOptions.verbose;
const bool isDynamicBox = inputrecDynamicBox(inputrec);
auto forceElement = std::make_unique<ForceElement>(
- statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElement, isVerbose,
+ statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationDataPtr, isVerbose,
isDynamicBox, fplog, cr, inputrec, mdAtoms, nrnb, fr, wcycle, runScheduleWork, vsite,
imdSession, pull_work, constr, top_global, enforcedRotation);
topologyHolder->registerClient(forceElement.get());
CheckBondedInteractionsCallbackPtr* checkBondedInteractionsCallback,
compat::not_null<StatePropagatorData*> statePropagatorDataPtr,
compat::not_null<EnergyData*> energyDataPtr,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElementPtr,
+ FreeEnergyPerturbationData* freeEnergyPerturbationDataPtr,
bool hasReadEkinState,
TopologyHolder* topologyHolder,
SimulationSignals* signals)
{
auto forceElement = buildForces(neighborSearchSignallerBuilder, energySignallerBuilder,
statePropagatorDataPtr, energyDataPtr,
- freeEnergyPerturbationElementPtr, topologyHolder);
+ freeEnergyPerturbationDataPtr, topologyHolder);
// list of elements owned by the simulator composite object
std::vector<std::unique_ptr<ISimulatorElement>> elementsOwnershipList;
{
auto computeGlobalsElement =
std::make_unique<ComputeGlobalsElement<ComputeGlobalsAlgorithm::LeapFrog>>(
- statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
+ statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationDataPtr,
signals, nstglobalcomm_, fplog, mdlog, cr, inputrec, mdAtoms, nrnb, wcycle,
fr, top_global, constr, hasReadEkinState);
topologyHolder->registerClient(computeGlobalsElement.get());
addToCallListAndMove(std::move(forceElement), elementCallList, elementsOwnershipList);
auto stateElement = compat::make_not_null(statePropagatorDataPtr->element(
fplog, cr, inputrec->nstxout, inputrec->nstvout, inputrec->nstfout,
- inputrec->nstxout_compressed, freeEnergyPerturbationElementPtr, fr->bMolPBC,
+ inputrec->nstxout_compressed, freeEnergyPerturbationDataPtr, fr->bMolPBC,
mdrunOptions.writeConfout, opt2fn("-c", nfile, fnm), inputrec, top_global));
trajectoryElementBuilder->registerWriterClient(stateElement);
trajectorySignallerBuilder->registerSignallerClient(stateElement);
if (constr)
{
auto constraintElement = std::make_unique<ConstraintsElement<ConstraintVariable::Positions>>(
- constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
+ constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationDataPtr,
MASTER(cr), fplog, inputrec, mdAtoms->mdatoms());
auto constraintElementPtr = compat::make_not_null(constraintElement.get());
energySignallerBuilder->registerSignallerClient(constraintElementPtr);
{
auto computeGlobalsElement =
std::make_unique<ComputeGlobalsElement<ComputeGlobalsAlgorithm::VelocityVerlet>>(
- statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
+ statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationDataPtr,
signals, nstglobalcomm_, fplog, mdlog, cr, inputrec, mdAtoms, nrnb, wcycle,
fr, &topologyHolder->globalTopology(), constr, hasReadEkinState);
topologyHolder->registerClient(computeGlobalsElement.get());
if (constr)
{
auto constraintElement = std::make_unique<ConstraintsElement<ConstraintVariable::Velocities>>(
- constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
+ constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationDataPtr,
MASTER(cr), fplog, inputrec, mdAtoms->mdatoms());
energySignallerBuilder->registerSignallerClient(compat::make_not_null(constraintElement.get()));
trajectorySignallerBuilder->registerSignallerClient(
addToCallList(compat::make_not_null(computeGlobalsElement.get()), elementCallList);
auto stateElement = compat::make_not_null(statePropagatorDataPtr->element(
fplog, cr, inputrec->nstxout, inputrec->nstvout, inputrec->nstfout,
- inputrec->nstxout_compressed, freeEnergyPerturbationElementPtr, fr->bMolPBC,
+ inputrec->nstxout_compressed, freeEnergyPerturbationDataPtr, fr->bMolPBC,
mdrunOptions.writeConfout, opt2fn("-c", nfile, fnm), inputrec, top_global));
trajectoryElementBuilder->registerWriterClient(stateElement);
trajectorySignallerBuilder->registerSignallerClient(stateElement);
if (constr)
{
auto constraintElement = std::make_unique<ConstraintsElement<ConstraintVariable::Positions>>(
- constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationElementPtr,
+ constr, statePropagatorDataPtr, energyDataPtr, freeEnergyPerturbationDataPtr,
MASTER(cr), fplog, inputrec, mdAtoms->mdatoms());
energySignallerBuilder->registerSignallerClient(compat::make_not_null(constraintElement.get()));
trajectorySignallerBuilder->registerSignallerClient(
#include "gromacs/utility/fatalerror.h"
#include "domdechelper.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
#include "modularsimulator.h"
#include "parrinellorahmanbarostat.h"
#include "signallers.h"
taskIterator_(taskQueue_.end()),
statePropagatorData_(nullptr),
energyData_(nullptr),
+ freeEnergyPerturbationData_(nullptr),
step_(-1),
runFinished_(false),
topologyName_(std::move(topologyName)),
algorithm.topologyHolder_ =
std::make_unique<TopologyHolder>(*top_global, cr, inputrec, fr, mdAtoms, constr, vsite);
- std::unique_ptr<FreeEnergyPerturbationElement> freeEnergyPerturbationElement = nullptr;
- FreeEnergyPerturbationElement* freeEnergyPerturbationElementPtr = nullptr;
if (inputrec->efep != efepNO)
{
- freeEnergyPerturbationElement =
- std::make_unique<FreeEnergyPerturbationElement>(fplog, inputrec, mdAtoms);
- freeEnergyPerturbationElementPtr = freeEnergyPerturbationElement.get();
+ algorithm.freeEnergyPerturbationData_ =
+ std::make_unique<FreeEnergyPerturbationData>(fplog, inputrec, mdAtoms);
}
+ FreeEnergyPerturbationData* freeEnergyPerturbationDataPtr =
+ algorithm.freeEnergyPerturbationData_.get();
algorithm.statePropagatorData_ = std::make_unique<StatePropagatorData>(
top_global->natoms, cr, state_global, fr->nbv->useGpu(), inputrec, mdAtoms->mdatoms());
auto statePropagatorDataPtr = compat::make_not_null(algorithm.statePropagatorData_.get());
algorithm.energyData_ = std::make_unique<EnergyData>(
- statePropagatorDataPtr, freeEnergyPerturbationElementPtr, top_global, inputrec, mdAtoms,
+ statePropagatorDataPtr, freeEnergyPerturbationDataPtr, top_global, inputrec, mdAtoms,
enerd, ekind, constr, fplog, &fr->listedForces->fcdata(), mdModulesNotifier, MASTER(cr),
observablesHistory, startingBehavior);
auto energyDataPtr = compat::make_not_null(algorithm.energyData_.get());
* have a full timestep state.
*/
// TODO: Make a CheckpointHelperBuilder
- std::vector<ICheckpointHelperClient*> checkpointClients = { freeEnergyPerturbationElementPtr };
+ std::vector<ICheckpointHelperClient*> checkpointClients;
CheckBondedInteractionsCallbackPtr checkBondedInteractionsCallback = nullptr;
auto integrator = buildIntegrator(
&neighborSearchSignallerBuilder, &lastStepSignallerBuilder, &energySignallerBuilder,
&loggingSignallerBuilder, &trajectorySignallerBuilder, &trajectoryElementBuilder,
&checkpointClients, &checkBondedInteractionsCallback, statePropagatorDataPtr,
- energyDataPtr, freeEnergyPerturbationElementPtr, hasReadEkinState,
+ energyDataPtr, freeEnergyPerturbationDataPtr, hasReadEkinState,
algorithm.topologyHolder_.get(), &algorithm.signals_);
+ FreeEnergyPerturbationData::Element* freeEnergyPerturbationElement = nullptr;
+ if (algorithm.freeEnergyPerturbationData_)
+ {
+ freeEnergyPerturbationElement = algorithm.freeEnergyPerturbationData_->element();
+ checkpointClients.emplace_back(freeEnergyPerturbationElement);
+ }
+
/*
* Build infrastructure elements
*/
addToCallList(algorithm.checkpointHelper_, algorithm.elementCallList_);
if (freeEnergyPerturbationElement)
{
- addToCallListAndMove(std::move(freeEnergyPerturbationElement), algorithm.elementCallList_,
- algorithm.elementsOwnershipList_);
+ addToCallList(freeEnergyPerturbationElement, algorithm.elementCallList_);
}
addToCallListAndMove(std::move(integrator), algorithm.elementCallList_, algorithm.elementsOwnershipList_);
addToCallListAndMove(std::move(trajectoryElement), algorithm.elementCallList_,
#include "checkpointhelper.h"
#include "computeglobalselement.h"
#include "domdechelper.h"
+#include "freeenergyperturbationdata.h"
#include "modularsimulatorinterfaces.h"
#include "pmeloadbalancehelper.h"
{
class EnergyData;
class EnergySignaller;
-class FreeEnergyPerturbationElement;
class LoggingSignaller;
class ModularSimulator;
class NeighborSearchSignaller;
std::unique_ptr<StatePropagatorData> statePropagatorData_;
//! The energy data
std::unique_ptr<EnergyData> energyData_;
+ //! The free energy data
+ std::unique_ptr<FreeEnergyPerturbationData> freeEnergyPerturbationData_;
//! The current step
Step step_;
CheckBondedInteractionsCallbackPtr* checkBondedInteractionsCallback,
compat::not_null<StatePropagatorData*> statePropagatorDataPtr,
compat::not_null<EnergyData*> energyDataPtr,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElementPtr,
+ FreeEnergyPerturbationData* freeEnergyPerturbationDataPtr,
bool hasReadEkinState,
TopologyHolder* topologyHolder,
SimulationSignals* signals);
SignallerBuilder<EnergySignaller>* energySignallerBuilder,
StatePropagatorData* statePropagatorDataPtr,
EnergyData* energyDataPtr,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
+ FreeEnergyPerturbationData* freeEnergyPerturbationDataPtr,
TopologyHolder* topologyHolder);
//! \cond
#include "gromacs/topology/atoms.h"
#include "gromacs/topology/topology.h"
-#include "freeenergyperturbationelement.h"
+#include "freeenergyperturbationdata.h"
namespace gmx
{
int nstvout,
int nstfout,
int nstxout_compressed,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
bool canMoleculesBeDistributedOverPBC,
bool writeFinalConfiguration,
std::string finalConfigurationFilename,
{
element_ = std::make_unique<Element>(
this, fplog, cr, nstxout, nstvout, nstfout, nstxout_compressed,
- freeEnergyPerturbationElement, canMoleculesBeDistributedOverPBC,
+ freeEnergyPerturbationData, canMoleculesBeDistributedOverPBC,
writeFinalConfiguration, std::move(finalConfigurationFilename), inputrec, globalTop);
}
else
{
- GMX_THROW(InconsistentInputError("Attempted to build StatePropagatorData::Element more than once."));
+ GMX_THROW(InconsistentInputError(
+ "Attempted to build StatePropagatorData::Element more than once."));
}
return element_.get();
}
{
GMX_ASSERT(!localStateBackup_, "Save state called again before previous state was written.");
localStateBackup_ = statePropagatorData_->localState();
- if (freeEnergyPerturbationElement_)
+ if (freeEnergyPerturbationData_)
{
- localStateBackup_->fep_state = freeEnergyPerturbationElement_->currentFEPState();
+ localStateBackup_->fep_state = freeEnergyPerturbationData_->currentFEPState();
for (unsigned long i = 0; i < localStateBackup_->lambda.size(); ++i)
{
- localStateBackup_->lambda[i] = freeEnergyPerturbationElement_->constLambdaView()[i];
+ localStateBackup_->lambda[i] = freeEnergyPerturbationData_->constLambdaView()[i];
}
localStateBackup_->flags |= (1U << estLAMBDA) | (1U << estFEPSTATE);
}
});
}
-StatePropagatorData::Element::Element(StatePropagatorData* statePropagatorData,
- FILE* fplog,
- const t_commrec* cr,
- int nstxout,
- int nstvout,
- int nstfout,
- int nstxout_compressed,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- bool canMoleculesBeDistributedOverPBC,
- bool writeFinalConfiguration,
- std::string finalConfigurationFilename,
- const t_inputrec* inputrec,
- const gmx_mtop_t* globalTop) :
+StatePropagatorData::Element::Element(StatePropagatorData* statePropagatorData,
+ FILE* fplog,
+ const t_commrec* cr,
+ int nstxout,
+ int nstvout,
+ int nstfout,
+ int nstxout_compressed,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ bool canMoleculesBeDistributedOverPBC,
+ bool writeFinalConfiguration,
+ std::string finalConfigurationFilename,
+ const t_inputrec* inputrec,
+ const gmx_mtop_t* globalTop) :
statePropagatorData_(statePropagatorData),
nstxout_(nstxout),
nstvout_(nstvout),
nstfout_(nstfout),
nstxout_compressed_(nstxout_compressed),
writeOutStep_(-1),
- freeEnergyPerturbationElement_(freeEnergyPerturbationElement),
+ freeEnergyPerturbationData_(freeEnergyPerturbationData),
isRegularSimulationEnd_(false),
lastStep_(-1),
canMoleculesBeDistributedOverPBC_(canMoleculesBeDistributedOverPBC),
namespace gmx
{
enum class ConstraintVariable;
-class FreeEnergyPerturbationElement;
+class FreeEnergyPerturbationData;
/*! \internal
* \ingroup module_modularsimulator
//! The element taking part in the simulator loop
class Element;
//! Get pointer to element (whose lifetime is managed by this)
- Element* element(FILE* fplog,
- const t_commrec* cr,
- int nstxout,
- int nstvout,
- int nstfout,
- int nstxout_compressed,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- bool canMoleculesBeDistributedOverPBC,
- bool writeFinalConfiguration,
- std::string finalConfigurationFilename,
- const t_inputrec* inputrec,
- const gmx_mtop_t* globalTop);
+ Element* element(FILE* fplog,
+ const t_commrec* cr,
+ int nstxout,
+ int nstvout,
+ int nstfout,
+ int nstxout_compressed,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ bool canMoleculesBeDistributedOverPBC,
+ bool writeFinalConfiguration,
+ std::string finalConfigurationFilename,
+ const t_inputrec* inputrec,
+ const gmx_mtop_t* globalTop);
//! Initial set up for the associated element
void setup();
{
public:
//! Constructor
- Element(StatePropagatorData* statePropagatorData,
- FILE* fplog,
- const t_commrec* cr,
- int nstxout,
- int nstvout,
- int nstfout,
- int nstxout_compressed,
- FreeEnergyPerturbationElement* freeEnergyPerturbationElement,
- bool canMoleculesBeDistributedOverPBC,
- bool writeFinalConfiguration,
- std::string finalConfigurationFilename,
- const t_inputrec* inputrec,
- const gmx_mtop_t* globalTop);
+ Element(StatePropagatorData* statePropagatorData,
+ FILE* fplog,
+ const t_commrec* cr,
+ int nstxout,
+ int nstvout,
+ int nstfout,
+ int nstxout_compressed,
+ FreeEnergyPerturbationData* freeEnergyPerturbationData,
+ bool canMoleculesBeDistributedOverPBC,
+ bool writeFinalConfiguration,
+ std::string finalConfigurationFilename,
+ const t_inputrec* inputrec,
+ const gmx_mtop_t* globalTop);
/*! \brief Register run function for step / time
*
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_;
+ //! Pointer to the free energy perturbation data (for trajectory writing only)
+ FreeEnergyPerturbationData* freeEnergyPerturbationData_;
//! No trajectory writer setup needed
void trajectoryWriterSetup(gmx_mdoutf gmx_unused* outf) override {}
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff