70 Eigen::VectorXd posStep;
71 Eigen::VectorXd forceBeforeStep;
73 double projectedForce;
74 double projectedForceBeforeStep;
77 forceBeforeStep = -
m_objf->getGradient();
80 pos =
m_objf->getPositions();
86 m_objf->setPositions(posStep);
95 projectedForceBeforeStep - projectedForce, stepSize, 0.0));
97 const double maxMove = std::fabs(a_maxMove);
100 if (maxMove < std::fabs(stepSize)) {
102 stepSize = ((stepSize > 0) - (stepSize < 0)) * maxMove;
106 projectedForceBeforeStep = projectedForce;
109 m_objf->setPositions(pos);
118 std::abs(projectedForce) /
121 line_i <
m_optConfig.opts.cg.line_search_max_iter);
122 if (
m_objf->isConverged())
129 Eigen::VectorXd posStep;
130 Eigen::VectorXd forceAfterStep;
133 pos =
m_objf->getPositions();
134 const Eigen::VectorXd posBefore = pos;
137 if (!
m_objf->reuseDisplacementCurvature()) {
141 m_objf->setPositions(posStep);
142 forceAfterStep = -
m_objf->getGradient(
true);
147 projectedForce1 - projectedForce2,
m_optConfig.finiteDifference, 0.0);
149 double stepSize = a_maxMove;
150 if (curvature > 0.0) {
155 stepSize = -a_maxMove;
156 a_maxMove = -a_maxMove;
166 m_objf->setPositions(pos);
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);
184 QUILL_LOG_DEBUG(
m_log,
"Force changed {}, step size adjusted to {}",
185 forceChange, stepSize);
190 if (stepSize >= a_maxMove) {
193 QUILL_LOG_DEBUG(
m_log,
"Resetting the old search direction");
196 return m_objf->isConverged() ? 1 : 0;
199 const double maxMove = std::fabs(a_maxMove);
206 double stepSize = maxMove;
211 m_objf->setPositions(posStep);
212 forceAfterStep = -
m_objf->getGradient(
true);
215 projectedForce1 - projectedForce2,
m_optConfig.finiteDifference, 0.0);
216 if (curvature > 0.0) {
221 stepSize = -a_maxMove;
222 a_maxMove = -a_maxMove;
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);
234 passedMinimum = projectedForce1 * projectedForce2;
235 if (passedMinimum < 0.0 &&
236 0.1 * std::abs(projectedForce1) < std::abs(projectedForce2)) {
237 forceChange = (projectedForce1 - projectedForce2);
240 QUILL_LOG_DEBUG(
m_log,
"Force changed {}, step size adjusted to {}",
241 forceChange, stepSize);
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;
263 stepSize = 0.25 * maxMove;
268 if (std::abs(ds) > 1e-14) {
271 if (curvature > 0.0 && projectedForce1 > 0.0) {
272 stepSize = projectedForce1 / curvature;
274 stepSize = 0.25 * maxMove;
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);
283 for (
long a = 0; a < nAtoms; ++a) {
284 const auto dsAtom = disp.segment(3 * a, 3);
285 const double dsn = dsAtom.squaredNorm();
291 const double c = df.dot(dsAtom) / dsn;
319 static_cast<long>(
m_atomCurv.size()) * 3 == delta.size()) {
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) {
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) {
336 const double capped = seg.norm();
337 if (capped > trust) {
338 seg *= trust / capped;
345 m_objf->setPositions(pos);
356 if (stepSize >= a_maxMove) {
362 QUILL_LOG_DEBUG(
m_log,
"Resetting the old search direction");
366 return m_objf->isConverged() ? 1 : 0;