Steps the conjugate gradient.
127 {
128 Eigen::VectorXd pos;
129 Eigen::VectorXd posStep;
130 Eigen::VectorXd forceAfterStep;
131
133 pos =
m_objf->getPositions();
134 const Eigen::VectorXd posBefore = pos;
136
137 if (!
m_objf->reuseDisplacementCurvature()) {
138
139
141 m_objf->setPositions(posStep);
142 forceAfterStep = -
m_objf->getGradient(
true);
143
147 projectedForce1 - projectedForce2,
m_optConfig.finiteDifference, 0.0);
148
149 double stepSize = a_maxMove;
150 if (curvature > 0.0) {
151 stepSize =
153 }
155 stepSize = -a_maxMove;
156 a_maxMove = -a_maxMove;
157 }
161 a_maxMove);
162 } else {
164 a_maxMove);
165 }
166 m_objf->setPositions(pos);
167 } else {
168 double passedMinimum = -1.;
169 double forceChange = 0.;
170 while (passedMinimum < 0.0 &&
171 0.1 * std::abs(projectedForce1) < std::abs(projectedForce2)) {
174 m_objf->setPositions(posStep);
175 forceAfterStep = -
m_objf->getGradient(
true);
177 passedMinimum = projectedForce1 * projectedForce2;
178 if (passedMinimum < 0.0 &&
179 0.1 * std::abs(projectedForce1) < std::abs(projectedForce2)) {
180 forceChange = (projectedForce1 - projectedForce2);
181 stepSize =
183 stepSize;
184 QUILL_LOG_DEBUG(
m_log,
"Force changed {}, step size adjusted to {}",
185 forceChange, stepSize);
186 }
187 }
188 }
190 if (stepSize >= a_maxMove) {
193 QUILL_LOG_DEBUG(
m_log,
"Resetting the old search direction");
194 }
195 }
196 return m_objf->isConverged() ? 1 : 0;
197 }
198
199 const double maxMove = std::fabs(a_maxMove);
202
205 }
206 double stepSize = maxMove;
207
209
211 m_objf->setPositions(posStep);
212 forceAfterStep = -
m_objf->getGradient(
true);
215 projectedForce1 - projectedForce2,
m_optConfig.finiteDifference, 0.0);
216 if (curvature > 0.0) {
217 stepSize =
219 }
221 stepSize = -a_maxMove;
222 a_maxMove = -a_maxMove;
223 }
224 double passedMinimum = -1.;
225 double forceChange = 0.;
226 while (passedMinimum < 0.0 &&
227 0.1 * std::abs(projectedForce1) < std::abs(projectedForce2)) {
230 m_objf->setPositions(posStep);
231 forceAfterStep = -
m_objf->getGradient(
true);
233
234 passedMinimum = projectedForce1 * projectedForce2;
235 if (passedMinimum < 0.0 &&
236 0.1 * std::abs(projectedForce1) < std::abs(projectedForce2)) {
237 forceChange = (projectedForce1 - projectedForce2);
239 stepSize;
240 QUILL_LOG_DEBUG(
m_log,
"Force changed {}, step size adjusted to {}",
241 forceChange, stepSize);
242 }
243 }
244 } else {
245
246
247
248
249
250 double trust = maxMove;
254 m_objf->setPositions(posStep);
255 forceAfterStep = -
m_objf->getGradient(
true);
256 const double projectedForce2 =
258 const double curvature = (projectedForce1 - projectedForce2) / fd;
259 m_objf->setPositions(pos);
260 if (curvature > 0.0 && projectedForce1 > 0.0) {
261 stepSize = projectedForce1 / curvature;
262 } else {
263 stepSize = 0.25 * maxMove;
264 }
268 if (std::abs(ds) > 1e-14) {
271 if (curvature > 0.0 && projectedForce1 > 0.0) {
272 stepSize = projectedForce1 / curvature;
273 } else {
274 stepSize = 0.25 * maxMove;
275 }
276 }
279 const long nAtoms =
m_force.size() / 3;
280 if (
static_cast<long>(
m_atomCurv.size()) != nAtoms) {
281 m_atomCurv.assign(
static_cast<size_t>(nAtoms), 0.0);
282 }
283 for (long a = 0; a < nAtoms; ++a) {
284 const auto dsAtom = disp.segment(3 * a, 3);
285 const double dsn = dsAtom.squaredNorm();
286 if (dsn < 1e-12) {
287 continue;
288 }
289 const auto df =
291 const double c = df.dot(dsAtom) / dsn;
292 if (c > 0.05) {
294 }
295 }
296 }
299
300
303 }
304 }
305
308 stepSize = maxMove;
309 a_maxMove = maxMove;
310 trust = maxMove;
311 delta *= stepSize;
312 } else {
313 delta *= stepSize;
314 }
315
319 static_cast<long>(
m_atomCurv.size()) * 3 == delta.size()) {
320
321
322 const long nAtoms =
static_cast<long>(
m_atomCurv.size());
323 for (long a = 0; a < nAtoms; ++a) {
324 const double c =
m_atomCurv[
static_cast<size_t>(a)];
325 auto seg = delta.segment(3 * a, 3);
326 const double motion = seg.norm();
327 if (!(c > 0.0) || motion < 1e-14) {
328 continue;
329 }
330 const double newton =
m_force.segment(3 * a, 3).norm() / c;
331 const double target = std::min(trust, std::max(newton, 0.0));
332 const double scale = std::min(4.0, target / motion);
333 if (scale > 0.0 && std::abs(scale - 1.0) > 1e-6) {
334 seg *= scale;
335 }
336 const double capped = seg.norm();
337 if (capped > trust) {
338 seg *= trust / capped;
339 }
340 }
341 pos += delta;
342 } else {
344 }
345 m_objf->setPositions(pos);
354 }
356 if (stepSize >= a_maxMove) {
357
362 QUILL_LOG_DEBUG(
m_log,
"Resetting the old search direction");
363 }
364 }
365
366 return m_objf->isConverged() ? 1 : 0;
367}
std::vector< double > m_atomCurv
Eigen::VectorXd m_secantForce
eonc::log::FileScoped m_log
VectorXd maxMotionAppliedV(const VectorXd v1, double maxMotion)
VectorXd maxAtomMotionAppliedV(const VectorXd v1, double maxMotion)
double maxAtomMotionV(const VectorXd v1)