164 {
166 if (
step ==
"newton" ||
step ==
"rfo") {
168 }
169 double H0 =
m_optConfig.opts.lbfgs.inverse_curvature;
170 Eigen::VectorXd r =
m_objf->getPositions();
171 Eigen::VectorXd f = a_f;
172 maybeProjectRigid(f, r,
m_optConfig.opts.lbfgs.project_rigid);
173
176 const Eigen::VectorXd y =
m_fPrev - f;
181 if (C < 0) {
182 QUILL_LOG_DEBUG(
183 m_log,
"[LBFGS] Negative curvature: {:.4f} eV/A^2 take max move step",
184 C);
187 }
189 }
190
191 if (
m_optConfig.opts.lbfgs.auto_scale && sy > 0.0 && yy > 0.0) {
192 const double g_syyy = sy / yy;
193 const double g_sssy = ss / sy;
195 if (h0 == "ss_sy") {
196 H0 = g_sssy;
197 } else if (h0 == "adaptive") {
198 H0 = std::min(g_syyy, g_sssy);
199 } else {
200 H0 = g_syyy;
201 }
202 if (
m_optConfig.opts.lbfgs.max_inverse_curvature > 0.0) {
203 H0 = std::min(H0,
m_optConfig.opts.lbfgs.max_inverse_curvature);
204 }
205 QUILL_LOG_DEBUG(
m_log,
"[LBFGS] H0={:.4e} ({} scale)", H0, h0);
206 }
207 }
208
209 const std::optional<double> known =
211 ?
m_objf->knownCurvature()
212 : std::nullopt;
213
214
215
216
217
218
219
220 constexpr double kSteepMode = 30.0;
221 bool knownFits = false;
222 if (known && std::isfinite(*known) && *known > 0.0) {
223 double hKnown = 1.0 / *known;
224 if (
m_optConfig.opts.lbfgs.max_inverse_curvature > 0.0) {
225 hKnown = std::min(hKnown,
m_optConfig.opts.lbfgs.max_inverse_curvature);
226 }
228 if (knownMotion < a_maxMove || *known < kSteepMode) {
229 H0 = hKnown;
230 knownFits = true;
231 QUILL_LOG_DEBUG(
m_log,
"[LBFGS] H0={:.4e} (known curvature)", H0);
232 }
233 }
235 m_objf->supportsFiniteDifferenceCurvature()) {
238 Eigen::VectorXd dg =
m_objf->getGradient(
true) + a_f;
242 if (H0 < 0) {
243 QUILL_LOG_WARNING(
m_log,
244 "[LBFGS] Negative curvature calculated via FD: {:.4e} "
245 "eV/A^2, take max move step",
246 C);
249 }
250 QUILL_LOG_DEBUG(
m_log,
"[LBFGS] Curvature calculated via FD: {:.4e} eV/A^2",
251 C);
252 }
253
254 const auto idx =
255 twoLoopIndex(
static_cast<int>(
m_s.size()),
256 static_cast<int>(
m_optConfig.opts.lbfgs.extra_updates));
257 const int loopmax = static_cast<int>(idx.size());
258 std::vector<double> a(static_cast<size_t>(loopmax));
259
260 Eigen::VectorXd q = -f;
261
262 for (int k = loopmax - 1; k >= 0; k--) {
263 const int i = idx[static_cast<size_t>(k)];
264 a[static_cast<size_t>(k)] =
265 m_rho[
static_cast<size_t>(i)] *
267 mulAddInto(q, -a[
static_cast<size_t>(k)],
m_y[
static_cast<size_t>(i)]);
268 }
269
270 Eigen::VectorXd z =
applyH0(q, H0, r);
271
272 for (int k = 0; k < loopmax; k++) {
273 const int i = idx[static_cast<size_t>(k)];
274 const double b =
m_rho[
static_cast<size_t>(i)] *
276 mulAddInto(z, a[
static_cast<size_t>(k)] - b,
m_s[
static_cast<size_t>(i)]);
277 }
278
279 Eigen::VectorXd d = -z;
280
282 if (distance >= a_maxMove &&
m_optConfig.opts.lbfgs.distance_reset) {
283 QUILL_LOG_DEBUG(
m_log,
284 "[LBFGS] reset memory, proposed step too large: {:.4f}",
285 distance);
288 }
289
290 double vd =
292 if (vd > 1.0)
293 vd = 1.0;
294 if (vd < -1.0)
295 vd = -1.0;
297 if (angle > 90.0 &&
m_optConfig.opts.lbfgs.angle_reset) {
298 QUILL_LOG_DEBUG(
m_log,
299 "[LBFGS] reset memory, angle between LBFGS angle and "
300 "force too large: {:.4f}",
301 angle);
304 }
305
306 maybeProjectRigid(d, r,
m_optConfig.opts.lbfgs.project_rigid);
308}
std::deque< double > m_rho
std::deque< Eigen::VectorXd > m_y
std::deque< Eigen::VectorXd > m_s
int step(double a_maxMove) override
Eigen::VectorXd hessianStep(double a_maxMove, const Eigen::VectorXd &a_f)
Eigen::VectorXd applyH0(const Eigen::VectorXd &q, double H0, const Eigen::VectorXd &pos) const
double squaredNorm(const Eigen::MatrixBase< A > &x)
A::PlainObject normalized(const Eigen::MatrixBase< A > &x, double min_norm=1e-300)
x / norm(x), or zero below min_norm (the safemath convention).
double dot(const double *x, const double *y, std::size_t n)
Round-to-nearest-even value of the exact sum of x[i] * y[i].
double orderedDot(const double *x, const double *y, std::size_t n)
A fixed summation tree: four lanes (term i goes to lane i mod 4, each lane a left-to-right sum of rou...
VectorXd maxAtomMotionAppliedV(const VectorXd v1, double maxMotion)
double maxAtomMotionV(const VectorXd v1)
constexpr double safe_div(double num, double denom, double fallback=0.0)
double safe_acos(double x)
constexpr double safe_recip(double x, double fallback=0.0)