#include "gromacs/math/vectypes.h"
#include "gromacs/mdtypes/awh_correlation_history.h"
#include "gromacs/mdtypes/awh_history.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/commrec.h"
#include "gromacs/mdtypes/df_history.h"
#include "gromacs/mdtypes/edsamhistory.h"
cptv_Unknown = 17, /**< Version before numbering scheme */
cptv_RemoveBuildMachineInformation, /**< remove functionality that makes mdrun builds non-reproducible */
cptv_ComPrevStepAsPullGroupReference, /**< Allow using COM of previous step as pull group PBC reference */
- cptv_PullAverage, /**< Added possibility to output average pull force and position */
- cptv_MdModules, /**< Added checkpointing for MdModules */
- cptv_Count /**< the total number of cptv versions */
+ cptv_PullAverage, /**< Added possibility to output average pull force and position */
+ cptv_MdModules, /**< Added checkpointing for MdModules */
+ cptv_ModularSimulator, /**< Added checkpointing for modular simulator */
+ cptv_Count /**< the total number of cptv versions */
};
/*! \brief Version number of the file format written to checkpoint
{
contents->flagsPullHistory = 0;
}
+
+ if (contents->file_version >= cptv_ModularSimulator)
+ {
+ do_cpt_bool_err(xd, "Is modular simulator checkpoint",
+ &contents->isModularSimulatorCheckpoint, list);
+ }
+ else
+ {
+ contents->isModularSimulatorCheckpoint = false;
+ }
}
static int do_cpt_footer(XDR* xd, int file_version)
t_state* state,
ObservablesHistory* observablesHistory,
const gmx::MdModulesNotifier& mdModulesNotifier,
- std::vector<gmx_file_position_t>* outputfiles)
+ std::vector<gmx_file_position_t>* outputfiles,
+ gmx::WriteCheckpointDataHolder* modularSimulatorCheckpointData)
{
headerContents.flags_eks = 0;
if (state->ekinstate.bUpToDate)
| (1 << eeksEKINO) | (1 << eeksEKINSCALEF) | (1 << eeksEKINSCALEH)
| (1 << eeksVSCALE) | (1 << eeksDEKINDL) | (1 << eeksMVCOS));
}
+ headerContents.isModularSimulatorCheckpoint = !modularSimulatorCheckpointData->empty();
energyhistory_t* enerhist = observablesHistory->energyHistory.get();
headerContents.flags_enh = 0;
gmx::serializeKeyValueTree(tree, &serializer);
}
+ // Checkpointing modular simulator
+ {
+ gmx::FileIOXdrSerializer serializer(fp);
+ modularSimulatorCheckpointData->serialize(&serializer);
+ }
+
do_cpt_footer(gmx_fio_getxdr(fp), headerContents.file_version);
}
}
}
-static void read_checkpoint(const char* fn,
- t_fileio* logfio,
- const t_commrec* cr,
- const ivec dd_nc,
- int eIntegrator,
- int* init_fep_state,
- CheckpointHeaderContents* headerContents,
- t_state* state,
- ObservablesHistory* observablesHistory,
- gmx_bool reproducibilityRequested,
- const gmx::MdModulesNotifier& mdModulesNotifier)
+static void read_checkpoint(const char* fn,
+ t_fileio* logfio,
+ const t_commrec* cr,
+ const ivec dd_nc,
+ int eIntegrator,
+ int* init_fep_state,
+ CheckpointHeaderContents* headerContents,
+ t_state* state,
+ ObservablesHistory* observablesHistory,
+ gmx_bool reproducibilityRequested,
+ const gmx::MdModulesNotifier& mdModulesNotifier,
+ gmx::ReadCheckpointDataHolder* modularSimulatorCheckpointData,
+ bool useModularSimulator)
{
t_fileio* fp;
char buf[STEPSTRSIZE];
fn);
}
- if (headerContents->flags_state != state->flags)
+ // For modular simulator, no state object is populated, so we cannot do this check here!
+ if (headerContents->flags_state != state->flags && !useModularSimulator)
{
gmx_fatal(FARGS,
"Cannot change a simulation algorithm during a checkpoint restart. Perhaps you "
cp_error();
}
do_cpt_mdmodules(headerContents->file_version, fp, mdModulesNotifier);
+ if (headerContents->file_version >= cptv_ModularSimulator)
+ {
+ gmx::FileIOXdrSerializer serializer(fp);
+ modularSimulatorCheckpointData->deserialize(&serializer);
+ }
ret = do_cpt_footer(gmx_fio_getxdr(fp), headerContents->file_version);
if (ret)
{
}
-void load_checkpoint(const char* fn,
- t_fileio* logfio,
- const t_commrec* cr,
- const ivec dd_nc,
- t_inputrec* ir,
- t_state* state,
- ObservablesHistory* observablesHistory,
- gmx_bool reproducibilityRequested,
- const gmx::MdModulesNotifier& mdModulesNotifier)
+void load_checkpoint(const char* fn,
+ t_fileio* logfio,
+ const t_commrec* cr,
+ const ivec dd_nc,
+ t_inputrec* ir,
+ t_state* state,
+ ObservablesHistory* observablesHistory,
+ gmx_bool reproducibilityRequested,
+ const gmx::MdModulesNotifier& mdModulesNotifier,
+ gmx::ReadCheckpointDataHolder* modularSimulatorCheckpointData,
+ bool useModularSimulator)
{
CheckpointHeaderContents headerContents;
if (SIMMASTER(cr))
{
/* Read the state from the checkpoint file */
- read_checkpoint(fn, logfio, cr, dd_nc, ir->eI, &(ir->fepvals->init_fep_state), &headerContents,
- state, observablesHistory, reproducibilityRequested, mdModulesNotifier);
+ read_checkpoint(fn, logfio, cr, dd_nc, ir->eI, &(ir->fepvals->init_fep_state),
+ &headerContents, state, observablesHistory, reproducibilityRequested,
+ mdModulesNotifier, modularSimulatorCheckpointData, useModularSimulator);
}
if (PAR(cr))
{
}
gmx::MdModulesNotifier mdModuleNotifier;
do_cpt_mdmodules(headerContents.file_version, fp, mdModuleNotifier);
+ if (headerContents.file_version >= cptv_ModularSimulator)
+ {
+ // In the scope of the current function, we can just throw away the content
+ // of the modular checkpoint, but we need to read it to move the file pointer
+ gmx::FileIOXdrSerializer serializer(fp);
+ gmx::ReadCheckpointDataHolder modularSimulatorCheckpointData;
+ modularSimulatorCheckpointData.deserialize(&serializer);
+ }
ret = do_cpt_footer(gmx_fio_getxdr(fp), headerContents.file_version);
if (ret)
{
struct MdModulesNotifier;
class KeyValueTreeObject;
+class ReadCheckpointDataHolder;
+class WriteCheckpointDataHolder;
/*! \brief Read to a key-value-tree value used for checkpointing.
*
int nED;
//! Enum for coordinate swapping.
int eSwapCoords;
+ //! Whether the checkpoint was written by modular simulator.
+ bool isModularSimulatorCheckpoint = false;
};
/*! \brief Low-level checkpoint writing function */
t_state* state,
ObservablesHistory* observablesHistory,
const gmx::MdModulesNotifier& notifier,
- std::vector<gmx_file_position_t>* outputfiles);
+ std::vector<gmx_file_position_t>* outputfiles,
+ gmx::WriteCheckpointDataHolder* modularSimulatorCheckpointData);
/* Loads a checkpoint from fn for run continuation.
* Generates a fatal error on system size mismatch.
* but not the state itself.
* With reproducibilityRequested warns about version, build, #ranks differences.
*/
-void load_checkpoint(const char* fn,
- t_fileio* logfio,
- const t_commrec* cr,
- const ivec dd_nc,
- t_inputrec* ir,
- t_state* state,
- ObservablesHistory* observablesHistory,
- gmx_bool reproducibilityRequested,
- const gmx::MdModulesNotifier& mdModulesNotifier);
+void load_checkpoint(const char* fn,
+ t_fileio* logfio,
+ const t_commrec* cr,
+ const ivec dd_nc,
+ t_inputrec* ir,
+ t_state* state,
+ ObservablesHistory* observablesHistory,
+ gmx_bool reproducibilityRequested,
+ const gmx::MdModulesNotifier& mdModulesNotifier,
+ gmx::ReadCheckpointDataHolder* modularSimulatorCheckpointData,
+ bool useModularSimulator);
/* Read everything that can be stored in t_trxframe from a checkpoint file */
void read_checkpoint_trxframe(struct t_fileio* fp, t_trxframe* fr);
* Appends the _step<step>.cpt with bNumberAndKeep, otherwise moves
* the previous checkpoint filename with suffix _prev.cpt.
*/
-static void write_checkpoint(const char* fn,
- gmx_bool bNumberAndKeep,
- FILE* fplog,
- const t_commrec* cr,
- ivec domdecCells,
- int nppnodes,
- int eIntegrator,
- int simulation_part,
- gmx_bool bExpanded,
- int elamstats,
- int64_t step,
- double t,
- t_state* state,
- ObservablesHistory* observablesHistory,
- const gmx::MdModulesNotifier& mdModulesNotifier,
- bool applyMpiBarrierBeforeRename,
- MPI_Comm mpiBarrierCommunicator)
+static void write_checkpoint(const char* fn,
+ gmx_bool bNumberAndKeep,
+ FILE* fplog,
+ const t_commrec* cr,
+ ivec domdecCells,
+ int nppnodes,
+ int eIntegrator,
+ int simulation_part,
+ gmx_bool bExpanded,
+ int elamstats,
+ int64_t step,
+ double t,
+ t_state* state,
+ ObservablesHistory* observablesHistory,
+ const gmx::MdModulesNotifier& mdModulesNotifier,
+ gmx::WriteCheckpointDataHolder* modularSimulatorCheckpointData,
+ bool applyMpiBarrierBeforeRename,
+ MPI_Comm mpiBarrierCommunicator)
{
t_fileio* fp;
char* fntemp; /* the temporary checkpoint file name */
0,
0,
nED,
- eSwapCoords };
+ eSwapCoords,
+ false };
std::strcpy(headerContents.version, gmx_version());
std::strcpy(headerContents.fprog, gmx::getProgramContext().fullBinaryPath());
std::strcpy(headerContents.ftime, timebuf.c_str());
}
write_checkpoint_data(fp, headerContents, bExpanded, elamstats, state, observablesHistory,
- mdModulesNotifier, &outputfiles);
+ mdModulesNotifier, &outputfiles, modularSimulatorCheckpointData);
/* we really, REALLY, want to make sure to physically write the checkpoint,
and all the files it depends on, out to disk. Because we've
#endif /* end GMX_FAHCORE block */
}
-void mdoutf_write_to_trajectory_files(FILE* fplog,
- const t_commrec* cr,
- gmx_mdoutf_t of,
- int mdof_flags,
- int natoms,
- int64_t step,
- double t,
- t_state* state_local,
- t_state* state_global,
- ObservablesHistory* observablesHistory,
- gmx::ArrayRef<const gmx::RVec> f_local)
+void mdoutf_write_to_trajectory_files(FILE* fplog,
+ const t_commrec* cr,
+ gmx_mdoutf_t of,
+ int mdof_flags,
+ int natoms,
+ int64_t step,
+ double t,
+ t_state* state_local,
+ t_state* state_global,
+ ObservablesHistory* observablesHistory,
+ gmx::ArrayRef<const gmx::RVec> f_local,
+ gmx::WriteCheckpointDataHolder* modularSimulatorCheckpointData)
{
const rvec* f_global;
DOMAINDECOMP(cr) ? cr->dd->nnodes : cr->nnodes, of->eIntegrator,
of->simulation_part, of->bExpanded, of->elamstats, step, t,
state_global, observablesHistory, *(of->mdModulesNotifier),
- of->simulationsShareState, of->mastersComm);
+ modularSimulatorCheckpointData, of->simulationsShareState, of->mastersComm);
}
if (mdof_flags & (MDOF_X | MDOF_V | MDOF_F))
class IMDOutputProvider;
struct MdModulesNotifier;
struct MdrunOptions;
+class WriteCheckpointDataHolder;
} // namespace gmx
typedef struct gmx_mdoutf* gmx_mdoutf_t;
* the master node only when necessary. Without domain decomposition
* only data from state_local is used and state_global is ignored.
*
- * \param[in] fplog File handler to log file.
- * \param[in] cr Communication record.
- * \param[in] of File handler to trajectory file.
- * \param[in] mdof_flags Flags indicating what data is written.
- * \param[in] natoms The total number of atoms in the system.
- * \param[in] step The current time step.
- * \param[in] t The current time.
- * \param[in] state_local Pointer to the local state object.
- * \param[in] state_global Pointer to the global state object.
- * \param[in] observablesHistory Pointer to the ObservableHistory object.
- * \param[in] f_local The local forces.
+ * \param[in] fplog File handler to log file.
+ * \param[in] cr Communication record.
+ * \param[in] of File handler to trajectory file.
+ * \param[in] mdof_flags Flags indicating what data is written.
+ * \param[in] natoms The total number of atoms in the system.
+ * \param[in] step The current time step.
+ * \param[in] t The current time.
+ * \param[in] state_local Pointer to the local state object.
+ * \param[in] state_global Pointer to the global state object.
+ * \param[in] observablesHistory Pointer to the ObservableHistory object.
+ * \param[in] f_local The local forces.
+ * \param[in] modularSimulatorCheckpointData CheckpointData object used by modular simulator.
*/
void mdoutf_write_to_trajectory_files(FILE* fplog,
const t_commrec* cr,
t_state* state_local,
t_state* state_global,
ObservablesHistory* observablesHistory,
- gmx::ArrayRef<const gmx::RVec> f_local);
+ gmx::ArrayRef<const gmx::RVec> f_local,
+ gmx::WriteCheckpointDataHolder* modularSimulatorCheckpointData);
/*! \brief Get the output interval of box size of uncompressed TNG output.
* Returns 0 if no uncompressed TNG file is open.
#include "gromacs/mdlib/mdoutf.h"
#include "gromacs/mdlib/stat.h"
#include "gromacs/mdlib/update.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/commrec.h"
#include "gromacs/mdtypes/forcerec.h"
#include "gromacs/mdtypes/inputrec.h"
energyOutput.fillEnergyHistory(observablesHistory->energyHistory.get());
}
}
+ // The current function is only called by legacy code, while
+ // mdoutf_write_to_trajectory_files is also called from modular simulator. Create a dummy
+ // modular simulator checkpointing object for compatibility.
+ gmx::WriteCheckpointDataHolder checkpointDataHolder;
// Note that part of the following code is duplicated in StatePropagatorData::trajectoryWriterTeardown.
// This duplication is needed while both legacy and modular code paths are in use.
// TODO: Remove duplication asap, make sure to keep in sync in the meantime.
- mdoutf_write_to_trajectory_files(fplog, cr, outf, mdof_flags, top_global->natoms, step, t,
- state, state_global, observablesHistory, f);
+ mdoutf_write_to_trajectory_files(fplog, cr, outf, mdof_flags, top_global->natoms, step, t, state,
+ state_global, observablesHistory, f, &checkpointDataHolder);
if (bLastStep && step_rel == ir->nsteps && bDoConfOut && MASTER(cr) && !bRerunMD)
{
if (fr->bMolPBC && state == state_global)
#include "gromacs/mdlib/vsite.h"
#include "gromacs/mdrunutility/handlerestart.h"
#include "gromacs/mdrunutility/printtime.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/commrec.h"
#include "gromacs/mdtypes/forcebuffers.h"
#include "gromacs/mdtypes/forcerec.h"
mdof_flags |= MDOF_IMD;
}
+ gmx::WriteCheckpointDataHolder checkpointDataHolder;
mdoutf_write_to_trajectory_files(fplog, cr, outf, mdof_flags, top_global->natoms, step,
static_cast<double>(step), &state->s, state_global,
- observablesHistory, state->f.view().force());
+ observablesHistory, state->f.view().force(), &checkpointDataHolder);
if (confout != nullptr)
{
mdof_flags |= MDOF_IMD;
}
+ gmx::WriteCheckpointDataHolder checkpointDataHolder;
mdoutf_write_to_trajectory_files(fplog, cr, outf, mdof_flags, top_global->natoms, step,
- static_cast<real>(step), &ems.s, state_global,
- observablesHistory, ems.f.view().force());
+ static_cast<real>(step), &ems.s, state_global, observablesHistory,
+ ems.f.view().force(), &checkpointDataHolder);
/* Do the linesearching in the direction dx[point][0..(n-1)] */
#include "gromacs/mdrunutility/multisim.h"
#include "gromacs/mdrunutility/printtime.h"
#include "gromacs/mdrunutility/threadaffinity.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/commrec.h"
#include "gromacs/mdtypes/enerdata.h"
#include "gromacs/mdtypes/fcdata.h"
ObservablesHistory observablesHistory = {};
+ auto modularSimulatorCheckpointData = std::make_unique<ReadCheckpointDataHolder>();
if (startingBehavior != StartingBehavior::NewSimulation)
{
/* Check if checkpoint file exists before doing continuation.
load_checkpoint(opt2fn_master("-cpi", filenames.size(), filenames.data(), cr),
logFileHandle, cr, domdecOptions.numCells, inputrec.get(), globalState.get(),
- &observablesHistory, mdrunOptions.reproducible, mdModules_->notifier());
+ &observablesHistory, mdrunOptions.reproducible, mdModules_->notifier(),
+ modularSimulatorCheckpointData.get(), useModularSimulator);
if (startingBehavior == StartingBehavior::RestartWithAppending && logFileHandle)
{
simulatorBuilder.add(IonSwapping(swap));
simulatorBuilder.add(TopologyData(&mtop, mdAtoms.get()));
simulatorBuilder.add(BoxDeformationHandle(deform.get()));
+ simulatorBuilder.add(std::move(modularSimulatorCheckpointData));
// build and run simulator object based on user-input
auto simulator = simulatorBuilder.build(useModularSimulator);
#include <memory>
#include "gromacs/mdlib/vsite.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/mdrunoptions.h"
#include "gromacs/mdtypes/state.h"
#include "gromacs/modularsimulator/modularsimulator.h"
if (useModularSimulator)
{
// NOLINTNEXTLINE(modernize-make-unique): make_unique does not work with private constructor
- return std::unique_ptr<ModularSimulator>(new ModularSimulator(std::make_unique<LegacySimulatorData>(
- simulatorEnv_->fplog_, simulatorEnv_->commRec_, simulatorEnv_->multisimCommRec_,
- simulatorEnv_->logger_, legacyInput_->numFile, legacyInput_->filenames,
- simulatorEnv_->outputEnv_, simulatorConfig_->mdrunOptions_,
- simulatorConfig_->startingBehavior_, constraintsParam_->vsite,
- constraintsParam_->constr, constraintsParam_->enforcedRotation, boxDeformation_->deform,
- simulatorModules_->outputProvider, simulatorModules_->mdModulesNotifier,
- legacyInput_->inputrec, interactiveMD_->imdSession, centerOfMassPulling_->pull_work,
- ionSwapping_->ionSwap, topologyData_->top_global, simulatorStateData_->globalState_p,
- simulatorStateData_->observablesHistory_p, topologyData_->mdAtoms, profiling_->nrnb,
- profiling_->wallCycle, legacyInput_->forceRec, simulatorStateData_->enerdata_p,
- simulatorStateData_->ekindata_p, simulatorConfig_->runScheduleWork_,
- *replicaExchangeParameters_, membedHolder_->membed(), profiling_->walltimeAccounting,
- std::move(stopHandlerBuilder_), simulatorConfig_->mdrunOptions_.rerun)));
+ return std::unique_ptr<ModularSimulator>(new ModularSimulator(
+ std::make_unique<LegacySimulatorData>(
+ simulatorEnv_->fplog_, simulatorEnv_->commRec_, simulatorEnv_->multisimCommRec_,
+ simulatorEnv_->logger_, legacyInput_->numFile, legacyInput_->filenames,
+ simulatorEnv_->outputEnv_, simulatorConfig_->mdrunOptions_,
+ simulatorConfig_->startingBehavior_, constraintsParam_->vsite,
+ constraintsParam_->constr, constraintsParam_->enforcedRotation,
+ boxDeformation_->deform, simulatorModules_->outputProvider,
+ simulatorModules_->mdModulesNotifier, legacyInput_->inputrec,
+ interactiveMD_->imdSession, centerOfMassPulling_->pull_work, ionSwapping_->ionSwap,
+ topologyData_->top_global, simulatorStateData_->globalState_p,
+ simulatorStateData_->observablesHistory_p, topologyData_->mdAtoms,
+ profiling_->nrnb, profiling_->wallCycle, legacyInput_->forceRec,
+ simulatorStateData_->enerdata_p, simulatorStateData_->ekindata_p,
+ simulatorConfig_->runScheduleWork_, *replicaExchangeParameters_,
+ membedHolder_->membed(), profiling_->walltimeAccounting,
+ std::move(stopHandlerBuilder_), simulatorConfig_->mdrunOptions_.rerun),
+ std::move(modularSimulatorCheckpointData_)));
}
// NOLINTNEXTLINE(modernize-make-unique): make_unique does not work with private constructor
return std::unique_ptr<LegacySimulator>(new LegacySimulator(
replicaExchangeParameters_ = std::make_unique<ReplicaExchangeParameters>(replicaExchangeParameters);
}
+void SimulatorBuilder::add(std::unique_ptr<ReadCheckpointDataHolder> modularSimulatorCheckpointData)
+{
+ modularSimulatorCheckpointData_ = std::move(modularSimulatorCheckpointData);
+}
+
} // namespace gmx
class MDLogger;
struct MdModulesNotifier;
struct MdrunOptions;
+class ReadCheckpointDataHolder;
enum class StartingBehavior;
class StopHandlerBuilder;
class VirtualSitesHandler;
boxDeformation_ = std::make_unique<BoxDeformationHandle>(boxDeformation);
}
+ //! Pass the read checkpoint data for modular simulator
+ void add(std::unique_ptr<ReadCheckpointDataHolder> modularSimulatorCheckpointData);
+
/*! \brief Build a Simulator object based on input data
*
* Return a pointer to a simulation object. The use of a parameter
std::unique_ptr<IonSwapping> ionSwapping_;
std::unique_ptr<TopologyData> topologyData_;
std::unique_ptr<BoxDeformationHandle> boxDeformation_;
+ //! Contains checkpointing data for the modular simulator
+ std::unique_ptr<ReadCheckpointDataHolder> modularSimulatorCheckpointData_;
};
} // namespace gmx
#include "gromacs/domdec/domdec.h"
#include "gromacs/mdlib/mdoutf.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/commrec.h"
#include "gromacs/mdtypes/state.h"
void CheckpointHelper::writeCheckpoint(Step step, Time time)
{
localStateInstance_->flags = 0;
+
+ WriteCheckpointDataHolder checkpointDataHolder;
for (const auto& client : clients_)
{
client->writeCheckpoint(localStateInstance_, state_global_);
}
mdoutf_write_to_trajectory_files(fplog_, cr_, trajectoryElement_->outf_, MDOF_CPT,
- globalNumAtoms_, step, time, localStateInstance_,
- state_global_, observablesHistory_, ArrayRef<RVec>());
+ globalNumAtoms_, step, time, localStateInstance_, state_global_,
+ observablesHistory_, ArrayRef<RVec>(), &checkpointDataHolder);
}
std::optional<SignallerCallback> CheckpointHelper::registerLastStepCallback()
return isInputCompatible;
}
-ModularSimulator::ModularSimulator(std::unique_ptr<LegacySimulatorData> legacySimulatorData) :
- legacySimulatorData_(std::move(legacySimulatorData))
+ModularSimulator::ModularSimulator(std::unique_ptr<LegacySimulatorData> legacySimulatorData,
+ std::unique_ptr<ReadCheckpointDataHolder> checkpointDataHolder) :
+ legacySimulatorData_(std::move(legacySimulatorData)),
+ checkpointDataHolder_(std::move(checkpointDataHolder))
{
checkInputForDisabledFunctionality();
}
namespace gmx
{
class ModularSimulatorAlgorithmBuilder;
+class ReadCheckpointDataHolder;
/*! \libinternal
* \ingroup module_modularsimulator
private:
//! Constructor
- explicit ModularSimulator(std::unique_ptr<LegacySimulatorData> legacySimulatorData);
+ ModularSimulator(std::unique_ptr<LegacySimulatorData> legacySimulatorData,
+ std::unique_ptr<ReadCheckpointDataHolder> checkpointDataHolder);
//! Populate algorithm builder with elements
void addIntegrationElements(ModularSimulatorAlgorithmBuilder* builder);
//! Check for disabled functionality (during construction time)
void checkInputForDisabledFunctionality();
- //! Pointer to legacy simulator data
+ //! Pointer to legacy simulator data (TODO: Can we avoid using unique_ptr? #3628)
std::unique_ptr<LegacySimulatorData> legacySimulatorData_;
+ //! Input checkpoint data
+ std::unique_ptr<ReadCheckpointDataHolder> checkpointDataHolder_;
};
/*!
#include "gromacs/mdlib/mdoutf.h"
#include "gromacs/mdlib/stat.h"
#include "gromacs/mdlib/update.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/commrec.h"
#include "gromacs/mdtypes/forcebuffers.h"
#include "gromacs/mdtypes/forcerec.h"
// TODO: This is only used for CPT - needs to be filled when we turn CPT back on
ObservablesHistory* observablesHistory = nullptr;
- mdoutf_write_to_trajectory_files(fplog_, cr_, outf, static_cast<int>(mdof_flags),
- statePropagatorData_->totalNumAtoms_, currentStep, currentTime,
- localStateBackup_.get(), statePropagatorData_->globalState_,
- observablesHistory, statePropagatorData_->f_.view().force());
+ mdoutf_write_to_trajectory_files(
+ fplog_, cr_, outf, static_cast<int>(mdof_flags), statePropagatorData_->totalNumAtoms_,
+ currentStep, currentTime, localStateBackup_.get(), statePropagatorData_->globalState_,
+ observablesHistory, statePropagatorData_->f_.view().force(), &dummyCheckpointDataHolder_);
if (currentStep != lastStep_ || !isRegularSimulationEnd_)
{
#include "gromacs/gpu_utils/hostallocator.h"
#include "gromacs/math/paddedvector.h"
#include "gromacs/math/vectypes.h"
+#include "gromacs/mdtypes/checkpointdata.h"
#include "gromacs/mdtypes/forcebuffers.h"
#include "modularsimulatorinterfaces.h"
void trajectoryWriterSetup(gmx_mdoutf gmx_unused* outf) override {}
//! Trajectory writer teardown - write final coordinates
void trajectoryWriterTeardown(gmx_mdoutf* outf) override;
+ //! A dummy CheckpointData - remove when we stop using the legacy trajectory writing function
+ WriteCheckpointDataHolder dummyCheckpointDataHolder_;
//! Whether planned total number of steps was reached (used for final output only)
bool isRegularSimulationEnd_;
biod.pnpi.spb.ru / alexxy / gromacs.git / commitdiff