The accelerated dynamics loop. Returns status (1 = transition, 0 = none).
33 {
34 bool transitionFlag = false, recordFlag = true, stopFlag = false,
35 firstTransitFlag = false;
36 long nFreeCoord =
reactant->numberOfFreeAtoms() * 3;
37 long mdBufferLength;
38 long step = 0, refineStep, newStateStep = 0;
39 long nCheck = 0, nRecord = 0, nBoost = 0, nState = 0;
40 long StateCheckInterval, RecordInterval;
41 double kinE, kinT, avgT, varT;
42 double kB =
params.constants().kB;
43 double correctedTime = 0.0, sumCorrectedTime = 0.0, firstTransitionTime = 0.0;
44 double Temp = 0.0, sumT = 0.0, sumT2 = 0.0;
45 double sumboost = 0.0, boost = 1.0, boostPotential = 0.0;
46 double transitionTime_current = 0.0, transitionTime_pre = 0.0;
48
51 StateCheckInterval = clock.state_check;
52 RecordInterval = clock.record;
53 Temp =
params.main_options().temperature;
55
56 mdBufferLength = clock.buffer;
57 std::vector<std::shared_ptr<Matter>> mdBuffer(mdBufferLength);
58 for (long i = 0; i < mdBufferLength; i++) {
59 mdBuffer[i] = std::make_shared<Matter>(
pot,
params);
60 }
63
66
67 if (
params.hyperdynamics_options().bias_potential ==
69 bondBoost.initialize();
70 current->setBiasPotential(&bondBoost);
71 }
72
73 safeHyper.setThermalVelocity();
74
75 {
78 }
79
80 QUILL_LOG_DEBUG(
82 "Starting MD run\nTemperature: {:.2f} Kelvin\n"
83 "Total Simulation Time: {:.2f} fs\nTime Step: {:.2f} fs\nTotal Steps: {}",
84 Temp,
85 params.dynamics_options().steps *
params.dynamics_options().time_step *
86 params.constants().timeUnit,
87 params.dynamics_options().time_step *
params.constants().timeUnit,
88 params.dynamics_options().steps);
89 QUILL_LOG_DEBUG(
log,
"MD buffer length: {}", mdBufferLength);
90
91 long tenthSteps =
params.dynamics_options().steps / 10;
92 if (tenthSteps == 0) {
93 tenthSteps =
params.dynamics_options().steps;
94 }
95
96 while (!stopFlag) {
97 boost = 1.0;
98 boostPotential = 0.0;
99 if ((
params.hyperdynamics_options().bias_potential ==
102 bondBoost.advance();
103 boostPotential = bondBoost.boost();
104 QUILL_LOG_TRACE_L1(
log,
"step= {} , boost = {:.5f}", step,
105 boostPotential);
106 if (Temp > 0.0 && kB > 0.0) {
107 boost = std::exp(boostPotential / kB / Temp);
108 } else {
109 boost = 1.0;
110 }
111 if (boost > 1.0) {
112 sumboost += boost;
113 nBoost++;
114 }
115 }
116 time +=
params.dynamics_options().time_step * boost;
117
118 kinE =
current->getKineticEnergy();
119 kinT = (2.0 * kinE / nFreeCoord / kB);
120 sumT += kinT;
121 sumT2 += kinT * kinT;
122 QUILL_LOG_TRACE_L1(
log,
"steps = {:10} temp = {:10.5f}", step, kinT);
123
124 safeHyper.oneStep();
126
127 nCheck++;
128 step++;
129 QUILL_LOG_TRACE_L1(
log,
"step = {:4}, time = {:10.4f}", step,
time);
130
131 if (
params.parallel_replica_options().refine_transition && recordFlag &&
133 if (nCheck % RecordInterval == 0) {
137 nRecord++;
138 }
139 }
140
141
142
143 long recordedThisInterval = 0;
145 recordedThisInterval = nRecord;
146 nCheck = 0;
147 nRecord = 0;
148 {
151 }
152 if (transitionFlag) {
153 nState++;
154 QUILL_LOG_DEBUG(
log,
"New State {}: ", nState);
157 newStateStep = step;
159 firstTransitFlag = 1;
160 }
161 }
162
163 if (transitionFlag) {
164 QUILL_LOG_TRACE_L1(
log,
"Refining transition time.");
165 const bool can_refine =
166 params.parallel_replica_options().refine_transition &&
167 recordedThisInterval >= 2;
168 if (can_refine) {
172 newStateStep - StateCheckInterval + refineStep * RecordInterval;
173 transitionTime_current =
timeBuffer[
static_cast<size_t>(refineStep)];
175 const long prev = refineStep > 0 ? refineStep - 1 : 0;
176
177
178
179 current->assignKeepingBias(*mdBuffer[
static_cast<size_t>(prev)]);
180 } else {
181 refineStep = 0;
182 transitionTime_current =
time;
184 }
186 transitionTime_pre = transitionTime_current;
187 correctedTime =
188 (Temp > 0.0 && kB > 0.0)
191 sumCorrectedTime += correctedTime;
192 if (nState == 1) {
194 }
195 velocity =
current->getVelocities();
196 velocity = velocity * (-1);
197 current->setVelocities(velocity);
198
201 if (can_refine) {
202 *
saddle = *mdBuffer[
static_cast<size_t>(refineStep)];
203 } else {
205 }
207 }
209 "tranisitonTime= {:.3e} s, biasPot= {:.3f} eV, "
210 "correctedTime= {:.3e} s, "
211 "sumCorrectedTime= {:.3e} s, minCorTime= {:.3e} s",
214 correctedTime * 1e-15 *
params.constants().timeUnit,
215 sumCorrectedTime * 1e-15 *
params.constants().timeUnit,
217
218 transitionFlag = false;
219 }
220
221 if (firstTransitFlag && sumCorrectedTime > firstTransitionTime) {
222 stopFlag = true;
224 }
225
226 if ((step % tenthSteps == 0) || (step ==
params.dynamics_options().steps)) {
228 QUILL_LOG_DEBUG(
229 log,
"progress: {:.0f}%, max displacement: {:.3f}, step {} / {}",
230 static_cast<double>(100.0 * step /
params.dynamics_options().steps),
231 maxAtomDistance, step,
params.dynamics_options().steps);
232 }
233
234
235
236 if (step >=
params.dynamics_options().steps) {
237 stopFlag = true;
238 }
239 }
240
241 avgT = sumT / step;
242 varT = sumT2 / step - avgT * avgT;
243
244 if (nBoost > 0) {
246 "Temperature : Average = {:.6f} ; Stddev = {:.6f} ; "
247 "Factor = {:.6f}; Boost = {:.6f}",
248 avgT, std::sqrt(varT), varT / avgT / avgT * nFreeCoord / 2,
249 sumboost / nBoost);
250 } else {
251 QUILL_LOG_DEBUG(
253 "Temperature : Average = {:.6f} ; Stddev = {:.6f} ; Factor = {:.6f}",
254 avgT, std::sqrt(varT), varT / avgT / avgT * nFreeCoord / 2);
255 }
256 if (std::isfinite(avgT) == 0) {
257 QUILL_LOG_DEBUG(
log,
"Infinite average temperature, something went wrong!");
259 }
260
261
262 current->setBiasPotential(
nullptr);
263
268 }
269
271 return 1;
272 } else {
273 return 0;
274 }
275}
Eigen::Matrix< double, Eigen::Dynamic, 3, eOnStorageOrder > AtomMatrix
static const char BOND_BOOST[]
std::shared_ptr< Potential > pot
Set when one Potential is shared across Matters, images, or a caller.
long refine(const std::vector< std::shared_ptr< Matter > > &buff, Matter *reactant)
Binary search for the transition frame in a snapshot buffer.
PrdClock prdClock() const
std::shared_ptr< Matter > saddle
std::shared_ptr< Matter > product
std::shared_ptr< Matter > finalState
std::shared_ptr< Matter > reactant
bool checkState(Matter *current, Matter *reactant)
Minimize a copy of current and compare to reactant.
std::shared_ptr< Matter > current
void dephase()
Dephase the trajectory to ensure thermal independence.
std::shared_ptr< Matter > finalStateTmp
std::vector< double > timeBuffer
std::vector< double > biasBuffer