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

pysisyphus/irc/initial_displ.py

@@ -0,0 +1,219 @@
+# [1] https://pubs.acs.org/doi/10.1021/j100338a027
+#     Koeski, Gordon, 1989
+# [2] https://aip.scitation.org/doi/abs/10.1063/1.459634
+#     Page, Doubleday, McIver, 1990
+
+from collections import namedtuple
+
+import h5py
+import numpy as np
+from scipy.optimize import bisect
+
+from pysisyphus.constants import AU2KJPERMOL
+
+
+def get_curv_vec(H, Gv, v0, w0):
+    v0 = v0[:, None]
+    I = np.eye(v0.size)
+    first = np.linalg.pinv(2 * w0 * I - H, rcond=1e-8)
+    second = Gv.dot(v0) - v0.T.dot(Gv).dot(v0) * v0
+    v1 = first.dot(second)
+    return v1.flatten()
+
+
+def taylor_closure(H, Gv, v0, v1, w0):
+    """Taylor expansion of energy to 3rd order.
+
+    dx(ds) = ds*v0 + ds**2*v1 / 2
+    dE(ds) = dx^T H dx / 2 + dx^T [Gv] dx / 6
+
+    H = Hessian
+    Gv = 3rd derivative of energy along v0
+    v0 = Transition vector
+    v1 = Curvature vector
+    w0 = Eigenvalue belonging to v0
+    """
+
+    # Precontract some values that will be reused
+    v0v1 = v0.dot(v1)
+    v1Hv1 = v1.dot(H).dot(v1)
+    v0Gvv0 = v0.dot(Gv).dot(v0)
+    v0Gvv1 = v0.dot(Gv).dot(v1)
+    v1Gvv1 = v1.dot(Gv).dot(v1)
+
+    def dE(ds):
+        ds2 = ds ** 2
+        ds3 = ds2 * ds
+        ds4 = ds2 * ds2
+
+        # Δx^T H Δx / 2
+        quad = (w0 * ds2 + ds3 * w0 ** 2 * v0v1 + (ds4 * v1Hv1) / 4) / 2
+        # Δx^T [Gv] Δx / 6
+        cubic = (ds2 * v0Gvv0 + ds3 * v0Gvv1 + ds4 * v1Gvv1 / 4) / 6
+        return quad + cubic
+
+    return dE
+
+
+ThirdDerivResult = namedtuple(
+    "ThirdDerivResult",
+    "coords_plus energy_plus H_plus coords_minus energy_minus H_minus G_vec vec ds",
+)
+
+
+def third_deriv_fd(geom, vec, ds=0.001):
+    """Third derivative of the energy in direction 'vec'."""
+
+    def get_H(geom, coords):
+        results = geom.get_energy_and_cart_hessian_at(coords)
+        energy = results["energy"]
+        H = results["hessian"]
+        H_mw = geom.mass_weigh_hessian(H)
+        # Only project for multi-atomic geometries.
+        if geom.coords.size > 3:
+            H_mw = geom.eckart_projection(H_mw)
+        return H_mw, H, energy
+
+    delta = ds * vec
+    plus = geom.coords + delta
+    minus = geom.coords - delta
+    H_mw_plus, H_plus, energy_plus = get_H(geom, plus)
+    H_mw_minus, H_minus, energy_minus = get_H(geom, minus)
+    G_vec = (H_mw_plus - H_mw_minus) / (2 * ds)
+
+    third_deriv_res = ThirdDerivResult(
+        coords_plus=plus,
+        energy_plus=energy_plus,
+        H_plus=H_plus,
+        coords_minus=minus,
+        energy_minus=energy_minus,
+        H_minus=H_minus,
+        G_vec=G_vec,
+        vec=vec,
+        ds=ds,
+    )
+    return G_vec, third_deriv_res
+
+
+def cubic_displ(H, v0, w0, Gv, dE):
+    """
+    According to Eq. (26) in [2] v1 does not depend on the sign of v0.
+        v1 = (F0 - 2v0^T F0 v0 I)⁻¹ x ([G0v0] - v0^T [G0v0] v0 I) v0
+    The first term is obviously independent of v0's sign. Using v0' = -v0 the
+    second term becomes
+        ([G0v0'] - v0'^T [G0v0'] v0' I) v0'
+        (-[G0v0] - v0^T [G0v0'] v0 I) v0'
+        (-[G0v0] + v0^T [G0v0] v0 I) v0'
+        -(-[G0v0] + v0^T [G0v0] v0 I) v0
+        ([G0v0] - v0^T [G0v0] v0 I) v0
+    Strictly speaking the contraction [G0v0] should depend on the sign of v0.
+    In the current implementation, the direction of v0 is not taken into account,
+    but
+        get_curv_vec(H, Gv, v0, w0) == get_curv_vec(H, -Gv, -v0, w0) .
+    But somehow the Taylor expansion gives bogus results when called with -Gv and -v0...
+    """
+
+    assert dE < 0.0, f"Supplied dE={dE:.6f} is positive but it must be negative!"
+    assert w0 < 0.0, f"Expected first eigenvalue to be negative but it is w0={w0:.6e}!"
+
+    v1 = get_curv_vec(H, Gv, v0, w0)
+    E_taylor = taylor_closure(H, Gv, v0, v1, w0)
+
+    def func(ds):
+        return E_taylor(ds) - dE
+
+    def prepare_bisect(x0, theta=1.25, max_cycles=20):
+        """Determine (lower) upper bound for scipy.optimize.bisect."""
+        assert theta > 1.0
+
+        ds = x0
+        dE_min = func(0.0)
+        dE_prev = dE_min
+        ds_min = ds
+        # Grow until we find an upper (lower) bound of the interval
+        for _ in range(max_cycles):
+            dE = func(ds)
+            # print(
+                # f"ds={ds:.4f} dE={dE*AU2KJPERMOL:.3f} dE_min={dE_min*AU2KJPERMOL:.3f}"
+            # )
+
+            if dE <= 0.0:
+                break
+            # Keep best guess
+            elif dE <= dE_min:
+                dE_min = dE
+                ds_min = ds
+            # Return (yet) best guess when function value grows again
+            elif dE >= dE_prev:
+                ds = ds_min
+                break
+
+            dE_prev = dE
+            ds *= theta  # Grow ds
+        return ds
+
+    def bisect_(ds0):
+        try:
+            ds_, rr = bisect(func, a=0.0, b=ds0, full_output=True)
+        # Will be raised when f(a) and f(b) have the same sign.
+        except ValueError:
+            ds_ = ds0
+        return ds_
+
+    plus_bound = prepare_bisect(0.1)
+    ds_plus = bisect_(plus_bound)
+
+    minus_bound = prepare_bisect(-0.1)
+    ds_minus = bisect_(minus_bound)
+
+    # import matplotlib.pyplot as plt
+    # dss = np.linspace(-1, 1, num=51)
+    # # dss = np.linspace(-6, 6, num=200)
+    # E0 = E_taylor(0.0)
+    # Es = E_taylor(dss) - E0
+    # Es *= AU2KJPERMOL
+    # Emp = (np.array((E_taylor(ds_minus), E_taylor(ds_plus))) - E0) * AU2KJPERMOL
+    # _, ax = plt.subplots()
+    # ax.plot(dss, Es, "o-")
+    # ax.axvline(0.0, c="k", ls="--")
+    # ax.axhline(dE*AU2KJPERMOL, c="k", ls=":")
+    # ax.scatter((ds_minus, ds_plus), Emp, s=75, marker="x", c="r", zorder=3)
+    # ax.set_xlabel("ds")
+    # ax.set_ylabel("dE / kJ mol⁻¹")
+    # plt.show()
+
+    def step(ds):
+        return ds * v0 + ds ** 2 * v1 / 2
+
+    step_plus = step(ds_plus)
+    step_minus = step(ds_minus)
+    return step_plus, step_minus
+
+
+def cubic_displ_for_h5(h5_fn="third_deriv.h5", dE=-5e-4):
+    with h5py.File(h5_fn, "r") as handle:
+        coords3d = handle["coords3d"][:]
+        if coords3d.size > 3:
+            H = handle["H_proj"][:]
+        else:
+            H = handle["H_mw"][:]
+        Gv = handle["G_vec"][:]
+
+    w, v = np.linalg.eigh(H)
+    w0 = w[0]
+    v0 = v[:, 0]
+    return cubic_displ(H, v0, w0, Gv, dE)
+
+
+def cubic_displ_for_geom(geom, dE=-5e-4):
+    H = geom.mw_hessian
+    # Only project for multi-atomic geometries.
+    if geom.coords.size > 3:
+        H = geom.eckart_projection(H)
+    w, v = np.linalg.eigh(H)
+    # Transition vector (imaginary mode) and corresponding eigenvalue
+    v0 = v[:, 0]
+    w0 = w[0]
+    Gv, third_deriv_res = third_deriv_fd(geom, v0)
+    step_plus, step_minus = cubic_displ(H, v0, w0, Gv, dE=dE)
+    return step_plus, step_minus, third_deriv_res

pysisyphus/linalg.py

@@ -0,0 +1,411 @@
+from math import cos, sin, sqrt
+from typing import Callable, Literal, Optional, Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.spatial.transform import Rotation
+from scipy.linalg.lapack import dpstrf
+
+
+def gram_schmidt(vecs, thresh=1e-8):
+    def proj(v1, v2):
+        return v1.dot(v2) / v1.dot(v1)
+
+    ortho = [
+        vecs[0],
+    ]
+    for v1 in vecs[1:]:
+        tmp = v1.copy()
+        for v2 in ortho:
+            tmp -= proj(v2, v1) * v2
+        norm = np.linalg.norm(tmp)
+        # Don't append linear dependent vectors, as their norm will be
+        # near zero. Renormalizing them to unity would lead to numerical
+        # garbage and to erronous results later on, when we orthgonalize
+        # against this 'arbitrary' vector.
+        if norm <= thresh:
+            continue
+        ortho.append(tmp / norm)
+    return np.array(ortho)
+
+
+def orthogonalize_against(mat, vecs, max_cycles=5, thresh=1e-10):
+    """Orthogonalize rows of 'mat' against rows in 'vecs'
+
+    Returns a (modified) copy of mat.
+    """
+
+    omat = mat.copy()
+    for _ in range(max_cycles):
+        max_overlap = 0.0
+        for row in omat:
+            for ovec in vecs:
+                row -= ovec.dot(row) * ovec
+
+            # Remaining overlap
+            overlap = np.sum(np.dot(vecs, row))
+            max_overlap = max(overlap, max_overlap)
+
+        if max_overlap < thresh:
+            break
+    else:
+        raise Exception(f"Orthogonalization did not succeed in {max_cycles} cycles!")
+
+    return omat
+
+
+def perp_comp(vec, along):
+    """Return the perpendicular component of vec along along."""
+    return vec - vec.dot(along) * along
+
+
+def make_unit_vec(vec1, vec2):
+    """Return unit vector pointing from vec2 to vec1."""
+    diff = vec1 - vec2
+    return diff / np.linalg.norm(diff)
+
+
+def svd_inv(array, thresh, hermitian=False):
+    U, S, Vt = np.linalg.svd(array, hermitian=hermitian)
+    keep = S > thresh
+    S_inv = np.zeros_like(S)
+    S_inv[keep] = 1 / S[keep]
+    return Vt.T.dot(np.diag(S_inv)).dot(U.T)
+
+
+def get_rot_mat(abc=None):
+    # Euler angles
+    if abc is None:
+        abc = np.random.rand(3) * np.pi * 2
+    a, b, c = abc
+    R = np.array(
+        (
+            (
+                cos(a) * cos(b) * cos(c) - sin(a) * sin(c),
+                -cos(a) * cos(b) * sin(c) - sin(a) * cos(c),
+                cos(a) * sin(b),
+            ),
+            (
+                sin(a) * cos(b) * cos(c) + cos(a) * sin(c),
+                -sin(a) * cos(b) * sin(c) + cos(a) * cos(c),
+                sin(a) * sin(b),
+            ),
+            (-sin(b) * cos(c), sin(b) * sin(c), cos(b)),
+        )
+    )
+    return R
+
+
+def get_rot_mat_for_coords(coords3d_1, coords3d_2):
+    coords3d_1 = coords3d_1.copy()
+    coords3d_2 = coords3d_2.copy()
+    centroid_1 = coords3d_1.mean(axis=0)
+    centroid_2 = coords3d_2.mean(axis=0)
+    coords3d_1 -= centroid_1[None, :]
+    coords3d_2 -= centroid_2[None, :]
+
+    tmp = coords3d_2.T.dot(coords3d_1)
+    U, W, Vt = np.linalg.svd(tmp)
+    rot_mat = U.dot(Vt)
+    if np.linalg.det(rot_mat) < 0:
+        U[:, -1] *= -1
+        rot_mat = U.dot(Vt)
+    return coords3d_1, coords3d_2, rot_mat
+
+
+def eigvec_grad(w, v, ind, mat_grad):
+    """Gradient of 'ind'-th eigenvector.
+
+    dv_i / dx_i = (w_i*I - mat)⁻¹ dmat/dx_i v_i
+    """
+    eigval = w[ind]
+    eigvec = v[:, ind]
+
+    w_diff = eigval - w
+    w_inv = np.divide(
+        1.0, w_diff, out=np.zeros_like(w_diff).astype(float), where=w_diff != 0.0
+    )
+    assert np.isfinite(w_inv).all()
+    pinv = v.dot(np.diag(w_inv)).dot(v.T)
+    pinv.dot(mat_grad)
+
+    wh = pinv.dot(mat_grad).dot(eigvec)
+    return wh
+
+
+def cross3(a, b):
+    """10x as fast as np.cross for two 1d arrays of size 3."""
+    return np.array(
+        (
+            a[1] * b[2] - a[2] * b[1],
+            a[2] * b[0] - a[0] * b[2],
+            a[0] * b[1] - a[1] * b[0],
+        )
+    )
+
+
+def norm3(a):
+    """5x as fas as np.linalg.norm for a 1d array of size 3."""
+    return sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2])
+
+
+def finite_difference_hessian(
+    coords: NDArray[float],
+    grad_func: Callable[[NDArray[float]], NDArray[float]],
+    step_size: float = 1e-2,
+    acc: Literal[2, 4] = 2,
+    callback: Optional[Callable] = None,
+) -> NDArray[float]:
+    """Numerical Hessian from central finite gradient differences.
+
+    See central differences in
+      https://en.wikipedia.org/wiki/Finite_difference_coefficient
+    for the different accuracies.
+    """
+    if callback is None:
+
+        def callback(*args):
+            pass
+
+    accuracies = {
+        2: ((-0.5, -1), (0.5, 1)),  # 2 calculations
+        4: ((1 / 12, -2), (-2 / 3, -1), (2 / 3, 1), (-1 / 12, 2)),  # 4 calculations
+    }
+    accs_avail = list(accuracies.keys())
+    assert acc in accs_avail
+
+    size = coords.size
+    fd_hessian = np.zeros((size, size))
+    zero_step = np.zeros(size)
+
+    coeffs = accuracies[acc]
+    for i, _ in enumerate(coords):
+        step = zero_step.copy()
+        step[i] = step_size
+
+        def get_grad(factor, displ, j):
+            displ_coords = coords + step * displ
+            callback(i, j)
+            grad = grad_func(displ_coords)
+            return factor * grad
+
+        grads = [get_grad(factor, displ, j) for j, (factor, displ) in enumerate(coeffs)]
+        fd = np.sum(grads, axis=0) / step_size
+        fd_hessian[i] = fd
+
+    # Symmetrize
+    fd_hessian = (fd_hessian + fd_hessian.T) / 2
+    return fd_hessian
+
+
+def rot_quaternion(coords3d, ref_coords3d):
+    # Translate to origin by removing centroid
+    c3d = coords3d - coords3d.mean(axis=0)
+    ref_c3d = ref_coords3d - ref_coords3d.mean(axis=0)
+
+    # Setup correlation matrix
+    R = c3d.T.dot(ref_c3d)
+
+    # Setup F matrix, Eq. (6) in [1]
+    F = np.zeros((4, 4))
+    R11, R12, R13, R21, R22, R23, R31, R32, R33 = R.flatten()
+    # Fill only upper triangular part.
+    F[0, 0] = R11 + R22 + R33
+    F[0, 1] = R23 - R32
+    F[0, 2] = R31 - R13
+    F[0, 3] = R12 - R21
+    #
+    F[1, 1] = R11 - R22 - R33
+    F[1, 2] = R12 + R21
+    F[1, 3] = R13 + R31
+    #
+    F[2, 2] = -R11 + R22 - R33
+    F[2, 3] = R23 + R32
+    #
+    F[3, 3] = -R11 - R22 + R33
+
+    # Eigenvalues, eigenvectors of upper triangular part.
+    w, v_ = np.linalg.eigh(F, UPLO="U")
+
+    # Quaternion corresponds to biggest (last) eigenvalue.
+    # np.linalg.eigh already returns sorted eigenvalues.
+    return w, v_, c3d, ref_c3d
+
+
+def quaternion_to_rot_mat(q):
+    q0, q1, q2, q3 = q
+    q_ = q0**2 - (q1**2 + q2**2 + q3**2)
+    R = np.zeros((3, 3))
+    R[0, 0] = q_ + 2 * q1**2
+    R[0, 1] = 2 * (q1 * q2 - q0 * q3)
+    R[0, 2] = 2 * (q1 * q3 - q0 * q2)
+    R[1, 0] = 2 * (q1 * q2 + q0 * q3)
+    R[1, 1] = q_ + 2 * q2**2
+    R[1, 2] = 2 * (q2 * q3 - q0 * q1)
+    R[2, 0] = 2 * (q1 * q3 - q0 * q2)
+    R[2, 1] = 2 * (q2 * q3 + q0 * q1)
+    R[2, 2] = q_ + 2 * q3**2
+    return R
+
+
+def rmsd_grad(
+    coords3d: NDArray[float], ref_coords3d: NDArray[float], offset: float = 1e-9
+) -> Tuple[float, NDArray[float]]:
+    """RMSD and gradient between two sets of coordinates from quaternions.
+
+    The gradient is given w.r.t. the coordinates of 'coords3d'.
+
+    Python adaption of
+        ls_rmsd.f90
+    from the xtb repository of the Grimme group, which in turn implements
+        [1] https://doi.org/10.1002/jcc.20110
+    .
+
+    Parameters
+    ----------
+    coords3d
+        Coordinate array of shape (N, 3) with N denoting the number of atoms.
+    ref_coords3d
+        Reference coordinates.
+    offset
+        Small floating-point number that is added to the RMSD, to avoid division
+        by zero.
+
+    Returns
+    -------
+    rmsd
+        RMSD value.
+    rmsd_grad
+        Gradient of the RMSD value w.r.t. to 'coords3d'.
+    """
+    assert coords3d.shape == ref_coords3d.shape
+
+    w, v_, c3d, ref_c3d = rot_quaternion(coords3d, ref_coords3d)
+    quat = v_[:, -1]
+    eigval = w[-1]
+
+    atom_num = coords3d.shape[0]
+    x_norm = np.linalg.norm(c3d) ** 2
+    y_norm = np.linalg.norm(ref_c3d) ** 2
+    rmsd = np.sqrt(max(0.0, ((x_norm + y_norm) - 2.0 * eigval)) / (atom_num)) + offset
+
+    # scipy expects the quaternion
+    #     a + b*i + c*j + d*k
+    # as (i, j, k, a), that is the scalar component must come last.
+    # Currently we have (a, i, j, k), so we have to rearrange before passing the
+    # quaternion to scipy.
+    rot = Rotation.from_quat((*quat[1:], quat[0]))
+    U = rot.as_matrix()
+
+    grad = (c3d - ref_c3d @ U) / (rmsd * atom_num)
+    return rmsd, grad
+
+
+def pivoted_cholesky(A: NDArray, tol: float = -1.0):
+    """Cholesky factorization a real symmetric positive semidefinite matrix.
+    Cholesky factorization is carried out with full pivoting.
+
+    Adapated from PySCF.
+
+    P.T * A * P = L * L.T
+
+    Parameters
+    ----------
+    A
+        Matrix to be factorized.
+    tol
+        User defined tolerance, as outlined in the LAPACK docs.
+
+    Returns
+    -------
+    L
+        Lower or upper triangular matrix.
+    piv
+        Pivot vectors, starting at 0.
+    rank
+        Rank of the factoirzed matrix.
+    """
+
+    N = A.shape[0]
+    L, piv, rank, info = dpstrf(A, tol=tol, lower=True)
+    piv -= 1  # LAPACK returns 1-based indices
+    assert info >= 0
+    L[np.triu_indices(N, k=1)] = 0
+    L[:, rank:] = 0
+    return L, piv, rank
+
+
+def pivoted_cholesky2(A: NDArray[float], tol: Optional[float] = None, m_max: int = 0):
+    """https://doi.org/10.1016/j.apnum.2011.10.001"""
+
+    R = np.zeros_like(A)
+    m = 0
+    n = len(A)
+    # Decompose to max rank.
+    if tol is None:
+        tol = 0.0
+    assert tol >= 0.0, f"{tol=} must be >= 0.0!"
+    if m_max == 0:
+        m_max = n
+    assert 0 <= m_max <= n, f"{m_max=} must fullfil (0 <= m_max <= {n=})!"
+    d = np.diag(A).copy()  # Diagonal
+    error = np.linalg.norm(A, ord="nuc")
+    piv = np.arange(n, dtype=int)
+    while True:
+        # Stop when error is sufficiently small or we are at max rank.
+        # while (error > tol) or (m_max and m < m_max):
+        if (error <= tol) or (m_max and (m == m_max)):
+            break
+        i = m + d[piv[m:]].argmax()
+        piv[m], piv[i] = piv[i], piv[m]
+        R[m, piv[m]] = np.sqrt(d[piv[m]])
+        for i in range(m + 1, n):
+            j = np.arange(m)
+            sum_ = (R[j, piv[m]] * R[j, piv[i]]).sum()
+            R[m, piv[i]] = (A[piv[m], piv[i]] - sum_) / R[m, piv[m]]
+            d[piv[i]] -= R[m, piv[i]] ** 2
+        error = d[m + 1 :].sum()
+        m += 1
+    # R.T @ R == A
+    return R, piv, m
+
+
+def matrix_power(mat, p, thresh=1e-12, strict=True):
+    w, v = np.linalg.eigh(mat)
+    assert (not strict) or (
+        w > 0.0
+    ).all(), "matrix_power must be called with a (semi)-positive-definite matrix!"
+    mask = np.abs(w) > thresh
+    w_pow = w[mask] ** p
+    v_mask = v[:, mask]
+    return v_mask @ np.diag(w_pow) @ v_mask.T
+
+
+def sym_mat_from_triu(arr, data):
+    nrows, ncols = arr.shape
+    assert nrows == ncols
+    triu = np.triu_indices(nrows)
+    tril1 = np.tril_indices(nrows, k=-1)
+    arr[triu] = data
+    arr[tril1] = arr.T[tril1]
+
+
+def sym_mat_from_tril(arr, data):
+    nrows, ncols = arr.shape
+    assert nrows == ncols
+    tril = np.tril_indices(nrows)
+    arr[tril] = data
+    triu1 = np.triu_indices(nrows, k=1)
+    arr[triu1] = arr.T[triu1]
+
+
+def multi_component_sym_mat(arr, dim):
+    target_shape = (dim, dim)
+    shape = arr.shape
+    sym = np.zeros((*target_shape, *shape[1:]))
+    triu = np.triu_indices(dim)
+    triu1 = np.triu_indices(dim, k=1)
+    tril1 = np.tril_indices(dim, k=-1)
+    sym[triu] = arr
+    sym[tril1] = sym[triu1]
+    return sym.reshape(*target_shape, *shape[1:])

pysisyphus/line_searches/Backtracking.py

@@ -0,0 +1,88 @@
+from pysisyphus.line_searches.LineSearch import (
+    LineSearch,
+    LineSearchNotConverged,
+)
+
+from pysisyphus.line_searches.interpol import interpol_alpha_quad, interpol_alpha_cubic
+from pysisyphus.optimizers.poly_fit import cubic_fit, quartic_fit
+
+
+class Backtracking(LineSearch):
+    def __init__(self, *args, rho_lo=5e-2, rho_hi=0.9, use_grad=False, **kwargs):
+        """Backtracking line search enforcing Armijo conditions.
+
+        Uses only energy evaluations.
+
+        See [1], Chapter 3, Line Search methods, Section 3.1 p. 31 and
+        Section 3.5 p. 56."""
+
+        kwargs["cond"] = "armijo"
+        super().__init__(*args, **kwargs)
+
+        self.rho_lo = float(rho_lo)
+        self.rho_hi = float(rho_hi)
+        self.use_grad = use_grad
+
+    def alpha_new_from_phi(self, cycle, phi0, dphi0, alpha, alpha_prev):
+        phi_i = self.get_phi_dphi("f", alpha)
+        self.log(f"\tCycle {cycle:02d}: alpha={alpha:.6f}, ϕ={phi_i:.6f} au")
+
+        if cycle == 0:
+            # Quadratic interpolation
+            alpha_new = interpol_alpha_quad(phi0, dphi0, phi_i, alpha)
+            type_ = "quadratic"
+        else:
+            # Cubic interpolation
+            phi_prev = self.get_phi_dphi("f", alpha_prev)
+            alpha_new = interpol_alpha_cubic(
+                phi0, dphi0, phi_prev, phi_i, alpha_prev, alpha
+            )
+            type_ = "cubic"
+        return alpha_new, type_
+
+    def alpha_new_from_phi_dphi(self, cycle, phi0, dphi0, alpha):
+        phi_i, dphi_i = self.get_phi_dphi("fg", alpha)
+        self.log(f"\tCycle {cycle:02d}: α={alpha:.6f}, ϕ={phi_i:.6f} au")
+
+        # First we try a constrained quartic polynomial
+        res = quartic_fit(phi0, phi_i, dphi0, dphi_i)
+        type_ = "quartic"
+        # If the quartic poly failed, we continue with a cubic polynomial
+        if res is None:
+            res = cubic_fit(phi0, phi_i, dphi0, dphi_i)
+            type_ = "cubic"
+        # If the cubic poly failed we resort to bisection. ohoh
+        if res is None:
+            alpha_new = 0.5 * alpha
+            type_ = "bisection"
+        else:
+            alpha_new = res.x * alpha
+        return alpha_new, type_
+
+    def run_line_search(self):
+        phi0, dphi0 = self.get_phi_dphi("fg", 0)
+
+        alpha_prev = None
+        alpha = self.alpha_init
+        for i in range(self.max_cycles):
+            if self.use_grad:
+                alpha_new, type_ = self.alpha_new_from_phi_dphi(i, phi0, dphi0, alpha)
+            else:
+                alpha_new, type_ = self.alpha_new_from_phi(i, phi0, dphi0, alpha, alpha_prev)
+            self.log(f"\tNew α from {type_} interpolation: {alpha_new:.6f}")
+
+            lower_bound = alpha * self.rho_lo
+            upper_bound = alpha * self.rho_hi
+            if alpha_new < lower_bound:
+                self.log("\tNew α is too small!")
+            if alpha_new > upper_bound:
+                self.log("\tNew α is too big!")
+
+            # Assert that alpha doesn't change too much compared to the previous alpha
+            alpha_new = min(alpha_new, upper_bound)
+            alpha_new = max(alpha_new, lower_bound)
+            alpha_prev = alpha
+            alpha = alpha_new
+            self.log(f"\tNext α: {alpha:.6f}\n")
+
+        raise LineSearchNotConverged