mlmm-toolkit 0.2.2.dev0__py3-none-any.whl

pysisyphus/modefollow/davidson.py

@@ -0,0 +1,199 @@
+# [1] https://aip.scitation.org/doi/pdf/10.1063/1.1523908
+#     Neugebauer, Reiher 2002
+# [2] https://reiher.ethz.ch/software/akira.html
+
+
+from collections import namedtuple
+import sys
+
+import numpy as np
+
+from pysisyphus.helpers_pure import eigval_to_wavenumber
+from pysisyphus.Geometry import get_trans_rot_projector
+from pysisyphus.modefollow.NormalMode import NormalMode
+from pysisyphus.TablePrinter import TablePrinter
+
+
+DavidsonResult = namedtuple(
+    "DavidsonResult",
+    "cur_cycle converged final_modes qs nus mode_inds res_rms",
+)
+
+
+def forces_fin_diff(forces_getter, coords, b, step_size):
+    plus = forces_getter(coords + b)
+    minus = forces_getter(coords - b)
+    fd = (minus - plus) / (2 * step_size)
+    return fd
+
+
+def block_davidson(
+    cart_coords,
+    masses,
+    forces_getter,
+    guess_modes,
+    lowest=None,
+    trial_step_size=0.01,
+    hessian_precon=None,
+    max_cycles=25,
+    res_rms_thresh=1e-4,
+    start_precon=5,
+    remove_trans_rot=True,
+    print_level=1,
+):
+    num = len(guess_modes)
+    B_full = np.zeros((len(guess_modes[0]), num * max_cycles))
+    S_full = np.zeros_like(B_full)
+    I = np.eye(cart_coords.size)
+    masses_rep = np.repeat(masses, 3)
+    msqrt = np.sqrt(masses_rep)
+
+    # Projector to remove translation and rotation
+    P = get_trans_rot_projector(cart_coords, masses, full=True)
+    guess_modes = [
+        NormalMode(P.dot(mode.l_mw) / msqrt, masses_rep) for mode in guess_modes
+    ]
+
+    col_fmts = "int int int float_short float str".split()
+    header = ("#", "subspace size", "mode", "ṽ / cm⁻¹", "rms(r)", "Conv")
+    fmts_update = {"float_short": "{: >11.2f}"}
+    table = TablePrinter(header, col_fmts, width=11, fmts_update=fmts_update)
+    if print_level == 1:
+        table.print_header()
+
+    b_prev = np.array([mode.l_mw for mode in guess_modes]).T
+    for i in range(max_cycles):
+        # Add new basis vectors to B matrix
+        b = np.array([mode.l_mw for mode in guess_modes]).T
+        from_ = i * num
+        to_ = (i + 1) * num
+        B_full[:, from_:to_] = b
+
+        # Estimate action of Hessian by finite differences.
+        for j in range(num):
+            mode = guess_modes[j]
+            # Get a step size in mass-weighted coordinates that results
+            # in the desired 'trial_step_size' in not-mass-weighted coordinates.
+            mw_step_size = mode.mw_norm_for_norm(trial_step_size)
+            # Actual step in non-mass-weighted coordinates
+            step = trial_step_size * mode.l
+            S_full[:, from_ + j] = (
+                # Convert to mass-weighted coordinates
+                forces_fin_diff(forces_getter, cart_coords, step, mw_step_size)
+                / msqrt
+            )
+
+        # Views on columns that are actually set
+        B = B_full[:, :to_]
+        S = S_full[:, :to_]
+
+        # Calculate and symmetrize approximate hessian
+        Hm = B.T.dot(S)
+        Hm = (Hm + Hm.T) / 2
+        # Diagonalize small Hessian
+        w, v = np.linalg.eigh(Hm)
+
+        # Approximations to exact eigenvectors in current cycle
+        approx_modes = (v * B[:, :, None]).sum(axis=1).T
+        # Calculate overlaps between previous root and the new approximate
+        # normal modes for root following.
+        if lowest is None:
+            # 2D overlap array. approx_modes in row, b_prev in columns.
+            overlaps = np.einsum("ij,jk->ik", approx_modes, b_prev)
+            mode_inds = np.abs(overlaps).argmax(axis=0)
+        else:
+            mode_inds = np.arange(lowest)
+        b_prev = approx_modes[mode_inds].T
+
+        # Eq. (7) in [1]
+        residues = (v * (S[:, :, None] - w * B[:, :, None])).sum(axis=1)
+
+        # Determine preconditioner matrix
+        #
+        # Use supplied matrix
+        if hessian_precon is not None:
+            precon_mat = hessian_precon
+        # Reconstruct Hessian, but only start after some cycles
+        elif i >= start_precon:
+            precon_mat = B.dot(Hm).dot(B.T)
+        # No preconditioning if no matrix was supplied or we are in an early cycle.
+        else:
+            precon_mat = None
+
+        # Construct new basis vector from residuum of selected mode
+        b = np.zeros_like(b_prev)
+        for j, mode_ind in enumerate(mode_inds):
+            r = residues[:, mode_ind]
+            if precon_mat is not None:
+                # Construct actual preconditioner X
+                X = np.linalg.pinv(precon_mat - w[mode_ind] * I, rcond=1e-8)
+                b[:, j] = X.dot(r)
+            else:
+                b[:, j] = r
+
+        # Project out translation and rotation from new mode guess
+        if remove_trans_rot:
+            b = P.dot(b)
+        # Orthogonalize new vectors against preset vectors
+        b = np.linalg.qr(np.concatenate((B, b), axis=1))[0][:, -num:]
+
+        # New NormalMode from non-mass-weighted displacements
+        guess_modes = [NormalMode(b_ / msqrt, masses_rep) for b_ in b.T]
+
+        # Calculate wavenumbers
+        nus = eigval_to_wavenumber(w)
+
+        # Check convergence criteria
+        max_res = np.abs(residues).max(axis=0)
+        res_rms = np.sqrt(np.mean(residues ** 2, axis=0))
+
+        converged = res_rms < res_rms_thresh
+        # Print progress if requested
+        if print_level == 2:
+            print(f"Cycle {i:02d}")
+            print("\t #  |    ṽ / cm⁻¹|   rms(r)   | max(|r|) ")
+            print("\t------------------------------------------")
+            for j, (nu, rms, mr) in enumerate(zip(nus, res_rms, max_res)):
+                sel_str = "*" if (j in mode_inds) else " "
+                conv_str = "✓" if converged[j] else ""
+                print(
+                    f"\t{j:02d}{sel_str} | {nu:> 10.2f} | {rms:.8f} | {mr:.8f} {conv_str}"
+                )
+            print()
+        elif print_level == 1:
+            for j in mode_inds:
+                conv_str = "✓" if converged[j] else "✗"
+                table.print_row((i, B.shape[1], j, nus[j], res_rms[j], conv_str))
+
+        # Convergence is signalled using only the roots we are actually interested in
+        modes_converged = all(converged[mode_inds])
+        if modes_converged:
+            if print_level > 0:
+                print(f"\tDavidson procedure converged in {i+1} cycles!")
+                if lowest is not None:
+                    nus_str = np.array2string(nus[mode_inds], precision=2)
+                    print(f"\tLowest {lowest} wavenumbers: {nus_str} cm⁻¹")
+                    neg_nus = sum(nus[mode_inds] < 0)
+                    type_ = "minimum" if (neg_nus == 0) else f"saddle point of index {neg_nus}"
+                    print(f"\tThis geometry seems to be a {type_} on the PES.")
+            break
+        sys.stdout.flush()
+
+    result = DavidsonResult(
+        cur_cycle=i,
+        converged=modes_converged,
+        final_modes=guess_modes,
+        qs=approx_modes,
+        nus=nus,
+        mode_inds=mode_inds,
+        res_rms=res_rms,
+    )
+
+    return result
+
+
+def geom_davidson(geom, *args, **kwargs):
+    def forces_getter(cart_coords):
+        return geom.get_energy_and_cart_forces_at(cart_coords)["forces"]
+
+    return block_davidson(geom.cart_coords, geom.masses, forces_getter, *args, **kwargs)

pysisyphus/modefollow/lanczos.py

@@ -0,0 +1,95 @@
+import numpy as np
+
+
+# [1]  https://doi.org/10.1063/1.1809574
+
+
+def lanczos(coords, grad_getter, dx=5e-3, dl=1e-2, guess=None, max_cycles=25,
+            reortho=True, logger=None):
+    """Lanczos method to determine smallest eigenvalue & -vector.
+
+    See [1] for description of algorithm.
+    """
+
+    def log(msg):
+        if logger is not None:
+            logger.debug(msg)
+
+    log("Lanczos Algorithm")
+    r_prev = guess
+    if r_prev is None:
+        r_prev = np.random.rand(coords.size)
+    beta_prev = np.linalg.norm(r_prev)
+    q_prev = np.zeros_like(r_prev)
+
+    alphas = list()
+    betas = list()
+    w_mins = list()
+    Q = np.zeros((coords.size, max_cycles))
+    qs = list()
+    # Gradient at current coordinates; does not change.
+    grad_l = grad_getter(coords)
+    for i in range(max_cycles):
+        # Normalize q
+        q = r_prev / beta_prev
+        Q[:,i] = q
+        qs.append(q.copy())
+        # Approximate action of Hessian on q (u = Hq) by finite differences.
+        #
+        # Gradient at perturbed coordinates
+        grad_k = grad_getter(coords + dx*q)
+        u = (grad_k - grad_l) / dx
+        # Residue
+        r = u - beta_prev*q_prev
+        alpha = q.dot(r)
+        r -= alpha*q
+        # Reorthogonalization of r against the present Lanczos vectors in Q
+        if reortho:
+            r -= Q.dot(Q.T.dot(r))
+        beta = np.linalg.norm(r)
+
+        alphas.append(alpha)
+        betas.append(beta)
+        size = len(alphas)
+        # Construct tri-diagonal matrix T
+        T = np.zeros((size, size))
+        diag_inds = np.diag_indices(size)
+        T[diag_inds] = alphas
+        if len(alphas) > 1:
+            for j, b in enumerate(betas[:-1], 1):
+                k = j-1
+                T[j,k] = b
+                T[k,j] = b
+
+        # Values for next cycle
+        beta_prev = beta
+        q_prev = q
+        r_prev = r
+        # Diagonalize T
+        w, v = np.linalg.eigh(T)
+        w_min = w[0]
+        log(f"Cycle {i: >3d}: w_min={w_min: .6f}")
+
+        # Check eigenvalue convergence
+        if (i > 0) and (abs((w_min - w_mins[-1])/w_mins[-1]) < dl):
+            log("Converged")
+            break
+
+        w_mins.append(w_min)
+    v_min = v[:,0]
+
+    # Form eigenvector from linear combination of Lanczos vectors
+    eigenvector = (v_min[:,None] * qs).sum(axis=0)
+    eigenvector /= np.linalg.norm(eigenvector)
+    return w_min, eigenvector
+
+
+def geom_lanczos(geom, *args, **kwargs):
+    """Wraps Lanczos algorithm for use with Geometry objects."""
+    coords = geom.coords.copy()
+
+    def grad_getter(coords):
+        results = geom.get_energy_and_forces_at(coords)
+        return -results["forces"]
+
+    return lanczos(coords, grad_getter, *args, **kwargs)

pysisyphus/optimizers/BFGS.py

@@ -0,0 +1,99 @@
+import numpy as np
+
+from pysisyphus.optimizers.Optimizer import Optimizer
+from pysisyphus.optimizers.hessian_updates import double_damp
+from pysisyphus.optimizers.restrict_step import scale_by_max_step
+
+
+# [1] Nocedal, Wright - Numerical Optimization, 2006
+# [2] http://dx.doi.org/10.1016/j.jcp.2013.08.044
+#     Badreddine, 2013
+# [3] https://arxiv.org/abs/2006.08877
+#     Goldfarb, 2020
+
+
+class BFGS(Optimizer):
+
+    def __init__(self, geometry, *args, update="bfgs", **kwargs):
+        super().__init__(geometry, *args, **kwargs)
+
+        assert self.align == False, \
+            "align=True does not work with this optimizer! Consider using LBFGS."
+
+        self.update = update
+
+        update_funcs = {
+            "bfgs": self.bfgs_update,
+            "damped": self.damped_bfgs_update,
+            "double": self.double_damped_bfgs_update,
+        }
+        self.update_func = update_funcs[self.update]
+
+    def prepare_opt(self):
+        # Inverse Hessian
+        self.H = self.eye
+
+    @property
+    def eye(self):
+        size = self.geometry.coords.size
+        if not hasattr(self, '_eye_cache') or self._eye_cache.shape[0] != size:
+            self._eye_cache = np.eye(size)
+        return self._eye_cache
+
+    def bfgs_update(self, s, y):
+        rho = 1 / s.dot(y)
+        V = self.eye - rho*np.outer(s, y)
+        self.H = V.dot(self.H).dot(V.T) + rho*np.outer(s, s)
+
+    def double_damped_bfgs_update(self, s, y, mu_1=0.2, mu_2=0.2):
+        """Double damped BFGS update of inverse Hessian.
+
+        See [3]. Potentially updates s and y."""
+
+        # Call using the inverse Hessian 'H'
+        s, y = double_damp(s, y, H=self.H, mu_1=mu_1, mu_2=mu_2,
+                           logger=self.logger)
+        self.log(f"s·y={s.dot(y):.6f} (damped)")
+        self.bfgs_update(s, y)
+
+    def damped_bfgs_update(self, s, y, mu_1=0.2):
+        """Damped BFGS update of inverse Hessian.
+
+        Potentially updates s.
+        See Section 3.2 of [2], Eq. (30) - (33). There is a typo ;)
+        It should be
+            H_{k+1} = V_k H_k V_k^T + ...
+        instead of
+            H_{k+1} = V_k^T H_k V_k + ...
+        """
+        self.double_damped_bfgs_update(s, y, mu_2=None)
+
+    def optimize(self):
+        forces = self.geometry.forces
+        energy = self.geometry.energy
+        self.forces.append(forces)
+        self.energies.append(energy)
+
+        if self.cur_cycle > 0:
+            # Gradient difference
+            y = self.forces[-2] - forces
+            # Coordinate difference / step
+            s = self.steps[-1]
+            # Curvature condition
+            sy = s.dot(y)
+            self.log(f"s·y={sy:.6f} (undamped)")
+            # Hessian update
+            self.update_func(s, y)
+
+        # Results in simple SD step in the first cycle
+        step = self.H.dot(forces)
+        self.log(f"Calcualted {self.update} step")
+
+        # Step restriction
+        unscaled_norm = np.linalg.norm(step)
+        step = scale_by_max_step(step, self.max_step)
+        scaled_norm = np.linalg.norm(step)
+        self.log(f"Unscaled norm(step)={unscaled_norm:.4f}")
+        self.log(f"  Scaled norm(step)={scaled_norm:.4f}")
+
+        return step

pysisyphus/optimizers/BacktrackingOptimizer.py

@@ -0,0 +1,113 @@
+import numpy as np
+
+from pysisyphus.optimizers.Optimizer import Optimizer
+
+class BacktrackingOptimizer(Optimizer):
+
+    def __init__(self, geometry, alpha, bt_force=5,
+                 dont_skip_after=2, bt_max_scale=4,
+                 bt_disable=False, **kwargs):
+        # Setting some default values
+        self.alpha = alpha
+        assert(self.alpha > 0), "Alpha must be positive!"
+        self.bt_force = bt_force
+        self.dont_skip_after = dont_skip_after
+        self.bt_max_scale = bt_max_scale
+        self.bt_disable = bt_disable
+        assert(self.dont_skip_after >= 1)
+        self.cycles_since_backtrack = self.bt_force
+        self.scale_factor = 0.5
+
+        super(BacktrackingOptimizer, self).__init__(geometry, **kwargs)
+
+        self.alpha0 = self.alpha
+        self.alpha_max = self.bt_max_scale * self.alpha0
+
+        # Keep the skipping history to avoid infinite skipping, e.g. always
+        # return skip = False if we already skipped in the last n iterations.
+        self.skip_log = list()
+
+    def _get_opt_restart_info(self):
+        opt_restart_info = {
+            "alpha": self.alpha,
+            "cycles_since_backtrack": self.cycles_since_backtrack,
+        }
+        return opt_restart_info
+
+    def _set_opt_restart_info(self, opt_restart_info):
+        self.alpha = opt_restart_info["alpha"]
+        self.cycles_since_backtrack = opt_restart_info["cycles_since_backtrack"]
+
+    def reset(self):
+        if self.alpha > self.alpha0:
+            self.alpha = self.alpha0
+            self.log(f"Resetting! Current alpha is {self.alpha}. Lowering "
+                     f"it to {self.alpha0}.")
+
+    def backtrack(self, cur_forces, prev_forces, reset_hessian=None):
+        """Accelerated backtracking line search."""
+        if self.bt_disable:
+            return False
+
+        epsilon = 1e-3
+
+        rms = lambda f: np.sqrt(np.mean(np.square(f)))
+        cur_rms_force = rms(cur_forces)
+        prev_rms_force = rms(prev_forces)
+
+        rms_diff = (
+            (cur_rms_force - prev_rms_force) /
+            np.abs(cur_rms_force + prev_rms_force)
+        )
+
+        # Skip tells us if we overshot
+        skip = False
+
+        # When the optimiziation is converging cur_forces will
+        # be smaller than prev_forces, so rms_diff will be negative
+        # and hence smaller than epsilon, which is a positive number.
+
+        # We went uphill, slow alpha
+        self.log(f"Backtracking: rms_diff = {rms_diff:.03f}")
+        if rms_diff > epsilon:
+            self.log(f"Scaling alpha with {self.scale_factor:.03f}")
+            # self.alpha = max(self.alpha0*.5, self.alpha*self.scale_factor)
+            self.alpha *= self.scale_factor
+            skip = True
+            self.cycles_since_backtrack = self.bt_force
+        # We continnue going downhill, rms_diff is smaller than epsilon
+        else:
+            self.cycles_since_backtrack -= 1
+            # Check if we didn't accelerate in the previous cycles
+            if self.cycles_since_backtrack < 0:
+                self.cycles_since_backtrack = self.bt_force
+                if self.alpha < self.alpha0:
+                    # Reset alpha
+                    self.alpha = self.alpha0
+                    skip = True
+                    self.log(f"Reset alpha to alpha0 = {self.alpha0:.4f}")
+                else:
+                    # Accelerate alpha
+                    self.alpha /= self.scale_factor
+                    self.log(f"Scaled alpha to {self.alpha:.4f}")
+
+        # Avoid huge alphas
+        if self.alpha > self.alpha_max:
+            self.alpha = self.alpha_max
+            self.log("Didn't accelerate as alpha would become too large. "
+                     f"keeping it at {self.alpha}.")
+
+        # Don't skip if we already skipped the previous iterations to
+        # avoid infinite skipping.
+        if ((len(self.skip_log) >= self.dont_skip_after)
+            and all(self.skip_log[-self.dont_skip_after:])):
+            self.log(f"already skipped last {self.dont_skip_after} "
+                      "iterations don't skip now.")
+            skip = False
+            if self.alpha > self.alpha0:
+                self.alpha = self.alpha0
+                self.log("Resetted alpha to alpha0.")
+        self.skip_log.append(skip)
+        self.log(f"alpha = {self.alpha:.4f}, skip = {skip}")
+
+        return skip

pysisyphus/optimizers/ConjugateGradient.py

@@ -0,0 +1,98 @@
+import numpy as np
+
+from pysisyphus.optimizers.BacktrackingOptimizer import BacktrackingOptimizer
+
+# http://ikuz.eu/2015/04/15/the-concept-of-conjugate-gradient-descent-in-python/
+
+
+class ConjugateGradient(BacktrackingOptimizer):
+    def __init__(self, geometry, alpha=0.1, formula="FR", dont_skip=True, **kwargs):
+        super().__init__(geometry, alpha=alpha, **kwargs)
+
+        self.formula = formula
+        self.dont_skip = dont_skip
+
+    def prepare_opt(self):
+        if self.is_cos and self.align:
+            self.procrustes()
+        # Calculate initial forces before the first iteration
+        self.coords.append(self.geometry.coords)
+        self.forces.append(self.geometry.forces)
+
+    def reset(self):
+        super().reset()
+
+        # Check if the number of coordinates changed
+        if self.forces[-1].size != self.geometry.coords.size:
+            new_forces = self.geometry.forces
+            self.forces.append(new_forces)
+        self.resetted = True
+
+    def get_beta(self, cur_forces, prev_forces):
+        # Fletcher-Reeves formula
+        if self.formula == "FR":
+            beta = cur_forces.dot(cur_forces) / prev_forces.dot(prev_forces)
+        # Polak-Ribiere
+        elif self.formula == "PR":
+            beta = -cur_forces.dot(prev_forces - cur_forces) / prev_forces.dot(
+                prev_forces
+            )
+            beta_old = cur_forces.dot(cur_forces - prev_forces) / prev_forces.dot(
+                prev_forces
+            )
+            self.log(f"beta_old={beta_old:.4f}, beta={beta:.4f}")
+            if beta < 0:
+                self.log(f"beta = {beta:.04f} < 0, resetting to 0")
+                # beta = 0 basically restarts CG, as no previous step
+                # information is mixed into the current step.
+                beta = 0
+        return beta
+
+    def optimize(self):
+        cur_forces = self.forces[-1]
+
+        if not self.resetted and self.cur_cycle > 0:
+            prev_forces = self.forces[-2]
+            beta = self.get_beta(cur_forces, prev_forces)
+            self.log(f"beta = {beta:.06f}")
+            if np.isinf(beta):
+                beta = 1.0
+            step = cur_forces + beta * self.steps[-1]
+        else:
+            # Start with steepest descent in the first iteration
+            step = cur_forces
+            self.resetted = False
+
+        step = self.alpha * step
+        step = self.scale_by_max_step(step)
+
+        cur_coords = self.geometry.coords
+        new_coords = cur_coords + step
+        self.geometry.coords = new_coords
+
+        new_forces = self.geometry.forces
+        new_energy = self.geometry.energy
+
+        skip = self.backtrack(new_forces, cur_forces)
+        # Imho backtracking gives bad results here, so only use it if
+        # explicitly requested (self.dont_skip == False).
+        if (not self.dont_skip) and skip:
+            self.geometry.coords = cur_coords
+            return None
+
+        if self.align and self.is_cos:
+            (new_forces, cur_forces, step), _, _ = self.fit_rigid(
+                vectors=(new_forces, cur_forces, step),
+            )
+            # Minus step???
+            new_coords = self.geometry.coords - step
+            self.geometry.coords = new_coords
+            # Set the calculated properties on the rotated geometries
+            self.geometry.energy = new_energy
+            self.geometry.forces = new_forces
+
+        self.forces[-1] = cur_forces
+        self.forces.append(new_forces)
+        self.energies.append(new_energy)
+
+        return step

pysisyphus/optimizers/CubicNewton.py

@@ -0,0 +1,75 @@
+# [1] https://arxiv.org/abs/2112.02089
+#     Regularized Newton Method with Global O(1/k²) Convergence
+#     Konstantin Mishchenko
+
+from math import sqrt
+
+import numpy as np
+
+from pysisyphus.optimizers.HessianOptimizer import HessianOptimizer
+from pysisyphus.optimizers.exceptions import OptimizationError
+
+
+class CubicNewton(HessianOptimizer):
+    def __init__(self, geometry, **kwargs):
+        # Force-disable trust radius update, as this optimizers uses a line search
+        kwargs["trust_update"] = False
+        super().__init__(geometry, **kwargs)
+
+        self.line_search_cycles = 0
+
+    def optimize(self):
+        energy, gradient, hessian, *_ = self.housekeeping()
+
+        if self.cur_cycle == 0:
+            # Initial Lipschitz constant estimate; line 2 in algorithm 2 in [1]
+            trial_step_length = 0.1
+            trial_step = trial_step_length * (-gradient / np.linalg.norm(gradient))
+            trial_coords = self.geometry.coords + trial_step
+            trial_results = self.geometry.get_energy_and_forces_at(trial_coords)
+            trial_gradient = -trial_results["forces"]
+            H = (
+                np.linalg.norm(trial_gradient - gradient - hessian.dot(trial_step))
+                / np.linalg.norm(trial_step) ** 2
+            )
+        else:
+            H = self.H_prev / 4
+        self.log(f"Lipschitz constant in cycle {self.cur_cycle}, H={H:.4f}")
+
+        for i in range(self.max_micro_cycles):
+            self.line_search_cycles += 1
+            H *= 2
+            self.log(f"Adaptive Newton line search, cycle {i} using H={H:.4f}")
+            lambda_ = sqrt(H * np.linalg.norm(gradient))
+            # Instead of solving the linear system we could also use the
+            # eigenvectors/-values from housekeeping(). Currently, they are
+            # gathered in '*_' and not used.
+            trial_step = np.linalg.solve(
+                hessian + lambda_ * np.eye(gradient.size), -gradient
+            )
+            trial_step_norm = np.linalg.norm(trial_step)
+            trial_coords = self.geometry.coords + trial_step
+
+            trial_results = self.geometry.get_energy_and_forces_at(trial_coords)
+            trial_gradient = -trial_results["forces"]
+            trial_energy = trial_results["energy"]
+
+            trial_gradient_small_enough = (
+                np.linalg.norm(trial_gradient) <= 2 * lambda_ * trial_step_norm
+            )
+            sufficient_energy_lowering = (
+                trial_energy <= energy - 2 / 3 * lambda_ * trial_step_norm ** 2
+            )
+
+            if trial_gradient_small_enough and sufficient_energy_lowering:
+                step = trial_step
+                break
+        else:
+            raise OptimizationError("Adaptive Newton line search failed!")
+
+        self.H_prev = H
+
+        return step
+
+    def postprocess_opt(self):
+        self.log(f"Line search cycles: {self.line_search_cycles}")