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

pysisyphus/irc/GonzalezSchlegel.py

@@ -0,0 +1,187 @@
+from math import cos, sin
+
+import numpy as np
+from scipy.optimize import newton
+
+from pysisyphus.irc.IRC import IRC
+from pysisyphus.optimizers.hessian_updates import bfgs_update
+from pysisyphus.TableFormatter import TableFormatter
+
+
+# [1] An improved algorithm for reaction path following
+# http://aip.scitation.org/doi/pdf/10.1063/1.456010
+# [2] Extension to internal coordinates (not implemented)
+# https://pubs.acs.org/doi/pdf/10.1021/j100377a021
+
+
+class GonzalezSchlegel(IRC):
+    def __init__(
+        self,
+        geometry,
+        max_micro_cycles=20,
+        micro_step_thresh=1e-3,
+        hessian_recalc=None,
+        line_search=False,
+        **kwargs,
+    ):
+        super().__init__(geometry, **kwargs)
+
+        self.max_micro_cycles = max_micro_cycles
+        self.micro_step_thresh = micro_step_thresh
+        self.hessian_recalc = hessian_recalc
+        self.line_search = line_search
+        if self.line_search:
+            print("!Line search seems faulty right now!")
+
+        self.pivot_coords = list()
+        self.eye = np.eye(self.geometry.coords.size)
+        self.micro_counter = 0
+
+        micro_header = "# |dx| |tangent|".split()
+        micro_fmts = ["d", ".2E", ".3E"]
+        self.micro_formatter = TableFormatter(micro_header, micro_fmts, 10)
+
+    def perp_component(self, vec, perp_to):
+        # Make unit vector
+        # perp_to /= np.linalg.norm(perp_to)
+        # Substract parallel component
+        return vec - perp_to.dot(vec) * perp_to / perp_to.dot(perp_to)#np.linalg.norm(perp_to)**2
+
+    def micro_step(self, counter):
+        """Constrained optimization on a hypersphere."""
+
+        # Calculate gradient at current coordinates
+        gradient = self.mw_gradient
+        self.log(f"\tnorm(mw_grad)={np.linalg.norm(gradient):.6f}")
+
+        # Interpolation proposed in the paper (Eq. (12) - (15)).
+        # Does not seem to help.
+        if self.line_search and (counter > 0):
+            pivot_coords = self.pivot_coords[-1]
+            p_prev = self.prev_coords - pivot_coords  # p"
+            p_cur = self.mw_coords - pivot_coords  # p'
+            g_prev = self.prev_grad  # g"
+            g_cur = self.gradient  # g'
+            g_prev_p = self.perp_component(g_prev, p_prev)
+            g_cur_p = self.perp_component(g_cur, p_cur)
+            g_prev_p_norm = np.linalg.norm(g_prev_p)
+            g_cur_p_norm = np.linalg.norm(g_cur_p)
+            # Angle between p_prev and p_cur
+            theta_prime = np.arccos(
+                p_prev.dot(p_cur) / np.linalg.norm(p_prev) / np.linalg.norm(p_cur)
+            )  # θ'
+            theta = g_prev_p_norm * theta_prime / (g_prev_p_norm - g_cur_p_norm)  # θ
+            theta_quot = theta / theta_prime
+            cos_theta = cos(theta)
+            sin_theta = sin(theta)
+            cos_theta_prime = cos(theta_prime)
+            sin_theta_prime = sin(theta_prime)
+            sin_quot = sin_theta / sin_theta_prime
+            # Interpolated quantities
+            g_interp = g_prev * (1 - theta_quot) + g_cur * theta_quot
+            p_interp = (
+                p_prev * (cos_theta - sin_quot * cos_theta_prime) + p_cur * sin_quot
+            )
+            x_interp = pivot_coords + p_interp
+            gradient = g_interp
+            self.mw_coords = x_interp
+            self.displacement = p_interp
+
+        gradient_diff = gradient - self.prev_grad
+        coords_diff = self.mw_coords - self.prev_coords
+        # Update previous quantities.
+        self.prev_coords = self.mw_coords.copy()
+        self.prev_grad = gradient.copy()
+
+        # Recalculate Hessian
+        if (
+            self.hessian_recalc
+            # and (self.micro_counter > 0)
+            and (self.micro_counter % self.hessian_recalc == 0)
+        ):
+            self.mw_hessian = self.geometry.mw_hessian
+        # Or update Hessian
+        else:
+            dH, _ = bfgs_update(self.mw_hessian, coords_diff, gradient_diff)
+            self.mw_hessian += dH
+        eigvals, eigvecs = np.linalg.eigh(self.mw_hessian)
+
+        constraint = (0.5 * self.step_length) ** 2
+        big = np.abs(eigvals) > 1e-8
+        big_eigvals = eigvals[big]
+        big_eigvecs = eigvecs[:, big]
+        grad_star = big_eigvecs.T.dot(gradient)
+        displ_star = big_eigvecs.T.dot(self.displacement)
+
+        def get_dx(lambda_):
+            """In basis of Hessian eigenvectors."""
+            return -(grad_star - lambda_ * displ_star) / (big_eigvals - lambda_)
+
+        def on_sphere(lambda_):
+            p = displ_star + get_dx(lambda_)
+            return p.dot(p) - constraint
+
+        # Initial guess for λ.
+        # λ must be smaller then the smallest eigenvector
+        lambda_0 = big_eigvals[0]
+        lambda_0 *= 1.5 if (lambda_0 < 0) else 0.5
+        self.log(f"\tSmallest eigenvalue is {big_eigvals[0]:.4f}, λ_0={lambda_0:.4f}.")
+        # Find the root with scipy
+        lambda_ = newton(on_sphere, lambda_0, maxiter=500)
+        self.log(f"\tDetermined λ={lambda_0:.4f} from Newtons method.")
+
+        # Calculate dx from optimized lambda in basis of Hessian eigenvectors and
+        # transform back to mass-weighted Cartesians.
+        dx = big_eigvecs.dot(get_dx(lambda_))
+        self.displacement += dx
+        self.mw_coords += dx
+
+        grad_tangent_to_sphere = self.perp_component(gradient, self.displacement)
+        self.micro_counter += 1
+
+        dx_norm = np.linalg.norm(dx)
+        grad_norm = np.linalg.norm(grad_tangent_to_sphere)
+        self.log(f"\tnorm(dx)={dx_norm:.6f}")
+        self.log(f"\tgradient tangent to sphere={grad_norm:.6f}")
+
+        return dx, grad_tangent_to_sphere
+
+    def step(self):
+        grad0 = self.mw_gradient
+        grad0_norm = np.linalg.norm(grad0)
+        # For the BFGS update in the first micro step we use the original
+        # point and the initial guess to calculate gradient and
+        # coordinate differences.
+        self.prev_grad = grad0
+        self.prev_coords = self.mw_coords
+
+        # Take a step against the gradient to the pivot point x*_k+1.
+        pivot_step = 0.5 * self.step_length * -grad0 / grad0_norm
+        pivot_coords = self.mw_coords + pivot_step
+        self.pivot_coords.append(pivot_coords)
+
+        # Initial guess for x'_k+1 (full step from prev_coords, or another
+        # half step from the pivot point)
+        self.mw_coords = pivot_coords + pivot_step
+
+        # Initial displacement p' from the pivot point
+        self.displacement = pivot_step
+
+        micro_coords_ = list()
+        for i in range(self.max_micro_cycles):
+            self.log(f"Micro cycle {i:02d}")
+            try:
+                dx, _ = self.micro_step(i)
+            except RuntimeError:
+                print("Constrained search did not converge!")
+                self.converged = True
+                return
+            micro_coords_.append(self.mw_coords)
+            if np.linalg.norm(dx) <= self.micro_step_thresh:
+                break
+        else:
+            self.logger.warning("Max micro cycles exceeded!")
+
+
+    def postprocess(self):
+        self.pivot_coords = np.array(self.pivot_coords)

pysisyphus/irc/IMKMod.py

@@ -0,0 +1,164 @@
+import numpy as np
+
+from pysisyphus.irc.IRC import IRC
+
+
+# [1] http://pubs.acs.org/doi/pdf/10.1021/ja00295a002
+# [2] https://math.stackexchange.com/questions/1882772/curve-fitting-with-derivatives
+
+
+class IMKMod(IRC):
+
+    def __init__(self, geometry, corr_first=True, corr_first_size=0.5,
+                 corr_first_energy=True, corr_bisec_size=0.0025,
+                 corr_bisec_energy=True, **kwargs):
+        super().__init__(geometry, **kwargs)
+
+        # Correction of pivot point
+        self.corr_first = bool(corr_first)
+        self.corr_first_size = float(corr_first_size)
+        self.corr_first_energy = bool(corr_first_energy)
+        # Correction along bisector
+        self.corr_bisec_size = corr_bisec_size
+        self.corr_bisec_energy = corr_bisec_energy
+
+        self.corr_bisec_thresh = 2*self.corr_bisec_size
+
+    def fit_parabola(self, x, y):
+        y_str = np.array2string(np.array(y), precision=6)
+        self.log(f"Fitting parabola with x={x} and y={y_str}")
+        fit = np.polyfit(x, y, deg=2)
+        parabola = np.poly1d(fit)
+        minimum = parabola.deriv().r
+        # We are only looking for a real minimum
+        real_minimum = (minimum[minimum.imag==0].real)[0]
+        self.log(f"Found minimum of fitted parabola at x={real_minimum:.4f}")
+
+        return real_minimum
+
+    def fit_grad_and_energies(self, energy0, grad0, energy1, direction):
+        grad0_proj = grad0.dot(direction/np.linalg.norm(direction))
+        # f (x) =  ax² + bx + c
+        # f'(x) = 2ax  + b
+        #
+        # Assuming energy0 and grad0 are calculated at x=0
+        # and
+        # energy is calculated at x=1
+        c = energy0
+        b = grad0_proj
+        a = energy1 - b - c
+        coeffs = (a, b, c)
+        poly = np.poly1d(coeffs)
+        minimum = poly.deriv().r
+        # We are only looking for a real minimum
+        real_minimum = (minimum[minimum.imag==0].real)[0]
+        self.log(f"Found minimum of fitted parabola at x={real_minimum:.4f}")
+
+        return real_minimum
+
+    def step(self):
+        # Get gradient at Q0
+        mw_coords_0 = self.mw_coords.copy()
+        grad_0 = self.mw_gradient
+        energy_0 = self.energy
+        self.log(f"Current point:\n\tenergy_0={energy_0:.6f} au")
+
+
+        ##############
+        # PIVOT STEP #
+        ##############
+
+        grad_0_norm = np.linalg.norm(grad_0)
+        dir_0 = -grad_0 / grad_0_norm
+        # Step direction is against the gradient to the pivot point Q1.
+        step = self.step_length * dir_0
+        mw_coords_1 = self.mw_coords + step
+        self.log(f"Took initial step of length {self.step_length:.6f} to pivot point")
+        self.mw_coords = mw_coords_1
+        energy_1 = self.energy
+
+        #########################
+        # PIVOT STEP CORRECTION #
+        #########################
+
+        self.log(f"Pivot point\n\tenergy_1={energy_1:.6f} au")
+        energy_diff = energy_1 - energy_0
+        if energy_diff > 0:
+            self.log(f"Energy increased at pivot point ΔE={energy_diff:.6f}")
+        correct_first_step = self.corr_first and (energy_diff > 0)
+        # Fit using energy at q0, energy at q1, and energy at half step between
+        # q0 and q1
+        corr_min = None
+        if correct_first_step and self.corr_first_energy:
+            self.log("Computing correction for pivot point from energy_0, "
+                     "energy_1, and additional energy calculation.")
+            corr_step = self.corr_first_size*step
+            mw_coords_1_corr = mw_coords_0 + corr_step
+            self.mw_coords = mw_coords_1_corr
+            energy_1_corr = self.energy
+            x_corr = np.array((0, self.corr_first_size, 1))
+            y_corr = (energy_0, energy_1_corr, energy_1)
+            corr_min = self.fit_parabola(x_corr, y_corr)
+        # Fit using energy & gradient at q0, and energy at q1
+        elif correct_first_step:
+            self.log("Computing correction for pivot point from energy_0, "
+                     "grad_0 and energy_1, along dir_0")
+
+            corr_min = self.fit_grad_and_energies(energy_0, grad_0, energy_1, dir_0)
+        else:
+            self.log("Skipping correction of pivot step")
+
+        if corr_min:
+            step_corr = corr_min * self.step_length * dir_0
+            mw_coords_1 = mw_coords_0 + step_corr
+            self.mw_coords = mw_coords_1
+
+        # Get gradient at Q1
+        self.log("Calculation of gradient at pivot point")
+        grad_1 = self.mw_gradient
+        energy_1 = self.energy
+        grad_1_norm = np.linalg.norm(grad_1)
+        dir_1 = -grad_1 / grad_1_norm
+
+        ##############
+        # BISECTOR D #
+        ##############
+
+        # Determine bisector d and normalized bisector vector D.
+        # d = grad_0/grad_0_norm - grad_1/grad_1_norm
+        d = -dir_0 + dir_1
+        D = d / np.linalg.norm(d)
+        self.log("Determined bisector D")
+
+        ##########################
+        # MINIMUM SEARCH ALONG D #
+        ##########################
+
+        # Take a step along D
+        step_2 = self.corr_bisec_size * D
+        mw_coords_2 = mw_coords_1 + step_2
+        self.mw_coords = mw_coords_2
+        energy_2 = self.energy
+        self.log(f"1st step along D\n\tenergy_2={energy_2:.6f} au")
+
+        if self.corr_bisec_energy:
+            if energy_2 > energy_1:
+                factor = 0.5
+            else:
+                factor = 2
+            step_3 = self.corr_bisec_size * factor * D
+            mw_coords_3 = mw_coords_1 + step_3
+            self.mw_coords = mw_coords_3
+            energy_3 = self.energy
+            self.log(f"2nd step along D\n\tenergy_3={energy_3:.6f} au")
+            x = np.array((0, 1, factor))
+            y = (energy_1, energy_2, energy_3)
+            corr_min = self.fit_parabola(x, y)
+        else:
+            self.log("Minimum search along D, by fitting energy_1, "
+                     "grad_1 and energy_2.")
+            corr_min = self.fit_grad_and_energies(energy_1, grad_1, energy_2, D)
+
+        step_corr = self.corr_bisec_size * corr_min * D
+        mw_coords_4 = mw_coords_1 + step_corr
+        self.mw_coords = mw_coords_4