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

pysisyphus/cos/FreeEndNEB.py

@@ -0,0 +1,25 @@
+from pysisyphus.cos.AdaptiveNEB import AdaptiveNEB
+
+# [1] https://www.pnas.org/content/pnas/104/9/3031.full.pdf
+#     Zhu, 2006
+#     Original method
+# [2] http://dx.doi.org/10.1063/1.4962019
+#     Zhang, 2016
+#     FreeEnd Adaptive NEB
+
+
+class FreeEndNEB(AdaptiveNEB):
+    def __init__(self, *args, fix_first=False, fix_last=False, **kwargs):
+        """Simple Free-End-NEB method.
+
+        Derived from AdaptiveNEB with disabled adaptation.
+        Only implements Eq. (7) from [2]. For other implementations
+        please see the commit 01bc8812ca6f1cd3645d43e0337d9e3c5fb0ba55.
+        There the other variants are present but I think Eq. (7) in [2] is
+        the simplest & best bet.
+        """
+        kwargs["adapt"] = False
+        super().__init__(*args, fix_first=fix_first, fix_last=fix_last, **kwargs)
+
+        assert (not self.fix_first) or (not self.fix_last), \
+            "FreeEndNEB without moving end-image(s) is useless!"

pysisyphus/cos/FreezingString.py

@@ -0,0 +1,103 @@
+import numpy as np
+
+from pysisyphus.Geometry import Geometry
+
+
+class FreezingString:
+
+    def __init__(self, images, calc_getter, max_nodes=10, opt_steps=3):
+        self.images = images
+        self.calc_getter = calc_getter
+        self.opt_steps = opt_steps
+        self.max_nodes = int(max_nodes)
+        assert self.max_nodes % 2 == 0, "max_nodes must be a multiple of 2!"
+
+        left_frontier, right_frontier = self.images
+        self.left_string = [left_frontier, ]
+        self.right_string = [right_frontier, ]
+        self.opt_steps_left = self.opt_steps
+
+        self._forces = None
+        self.atoms = left_frontier.atoms
+        coord_diff = np.linalg.norm(right_frontier.coords - left_frontier.coords)
+        self.step_length = coord_diff / (self.max_nodes+1)
+        self.set_new_frontier_nodes()
+        self.coord_type = "cart"
+
+    @property
+    def left_frontier(self):
+        return self.left_string[-1]
+
+    @property
+    def right_frontier(self):
+        return self.right_string[0]
+
+    def get_tangent(self):
+        tangent = self.right_frontier.coords - self.left_frontier.coords
+        tangent /= np.linalg.norm(tangent)
+        return tangent
+
+    @property
+    def forces(self):
+        left_forces = self.left_frontier.forces
+        right_forces = self.right_frontier.forces
+        forces = (left_forces, right_forces)
+        tangent = self.get_tangent()
+        perp_forces = np.array([f - f.dot(tangent)*tangent for f in forces]).flatten()
+        self._forces = perp_forces
+        self.energies = [self.left_frontier.energy, self.right_frontier.energy]
+        
+        return self._forces
+
+    def as_xyz(self):
+        return ""
+
+    @property
+    def fully_grown(self):
+        return (len(self.left_string) + len(self.right_string)
+                == self.max_nodes + 2)
+
+    @property
+    def energy(self):
+        return 10
+        # return self.energies
+
+    def set_new_frontier_nodes(self):
+        tangent = self.get_tangent()
+        new_left_coords = self.left_frontier.coords + tangent*self.step_length
+        new_left_frontier = Geometry(self.atoms, new_left_coords)
+        new_left_frontier.set_calculator(self.calc_getter())
+        self.left_string.append(new_left_frontier)
+
+        new_right_coords = self.right_frontier.coords - tangent*self.step_length
+        new_right_frontier = Geometry(self.atoms, new_right_coords)
+        new_right_frontier.set_calculator(self.calc_getter())
+        self.right_string.insert(0, new_right_frontier)
+ 
+    def get_new_image(self, coords, index):
+        new_image = Geometry(self.left_frontier.atoms, coords)
+        new_image.set_calculator(self.calc_getter())
+        self.images.insert(index, new_image)
+        self.log(f"Create new image; insert it before index {index}.")
+        return new_image
+
+    def reparametrize(self):
+        self.opt_steps_left -= 1
+
+        if not self.fully_grown and self.opt_steps_left == 0:
+            self.set_new_frontier_nodes()
+            self.opt_steps_left = self.opt_steps
+
+    @property
+    def allcoords(self):
+        return np.array([img.coords for img in self.left_string + self.right_string]).flatten()
+    
+    @property
+    def coords(self):
+        return np.array((self.left_frontier.coords, self.right_frontier.coords)).flatten()
+
+    @coords.setter
+    def coords(self, coords):
+        left, right = coords.reshape(2, -1)
+        self.left_frontier.coords = left
+        self.right_frontier.coords = right

pysisyphus/cos/GrowingChainOfStates.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+from pysisyphus.cos.ChainOfStates import ChainOfStates
+from pysisyphus.Geometry import Geometry
+
+
+class GrowingChainOfStates(ChainOfStates):
+
+    def __init__(self, images, calc_getter, max_nodes=10,
+                 **kwargs):
+        super().__init__(images, **kwargs)
+
+        self.max_nodes = max_nodes
+        self.calc_getter = calc_getter
+        self.zero_step = np.zeros_like(self.images[0].coords)
+
+    def get_new_image_from_coords(self, coords, index):
+        new_image = Geometry(
+            self.image_atoms,
+            coords,
+            coord_type=self.coord_type,
+            coord_kwargs={"typed_prims": self.typed_prims},
+            freeze_atoms=self.images[0].freeze_atoms.copy()
+        )
+        new_image.set_calculator(self.calc_getter())
+        self.images.insert(index, new_image)
+        self.log(f"Create new image; insert it before index {index}.")
+        return new_image
+
+    @property
+    def arc_dims(self):
+        cds = [0, ]
+        for i, image in enumerate(self.images[:-1]):
+            next_image = self.images[i+1]
+            diff = np.linalg.norm(next_image - image)
+            cds.append(diff)
+        cds = np.cumsum(cds)
+        tot_length = cds[-1]
+        norm_cds = cds / cds.max()
+        return tot_length, norm_cds
+
+    @property
+    def max_image_num(self):
+        return self.max_nodes + 2
+
+    def new_node_coords(self, k):
+        l = (self.max_nodes-k) / (self.max_nodes+1-k)
+        kth_coords = self.images[k].coords
+        last_coords = self.images[-1].coords
+        new_coords = l*kth_coords + (1-l)*last_coords
+        return new_coords
+
+    def set_new_node(self, k):
+        new_coords = self.new_node_coords(k)
+        new_node = Geometry(
+            self.image_atoms,
+            new_coords,
+            freeze_atoms=self.images[0].freeze_atoms.copy()
+        )
+        new_node.set_calculator(self.calc_getter())
+        self.images.insert(k+1, new_node)
+        return new_node
+
+    def prepare_opt_cycle(self, *args, **kwargs):
+        parent_result = super().prepare_opt_cycle(*args, **kwargs)
+
+        # Compare size of coords arrays to determine if new nodes
+        # were added in the last reparametrization.
+        last_size = self.coords_list[-1].size
+        length_changed = last_size != self.coords.size
+        return parent_result or length_changed

pysisyphus/cos/GrowingNT.py

@@ -0,0 +1,309 @@
+# [1] https://aip.scitation.org/doi/abs/10.1063/1.1885467
+#     Quapp, 2005
+
+import logging
+import os
+from pathlib import Path
+
+import numpy as np
+
+from pysisyphus.helpers_pure import rms
+from pysisyphus.intcoords.helpers import get_weighted_bond_mode
+
+
+class GrowingNT:
+    logger = logging.getLogger("cos")
+
+    def __init__(
+        self,
+        geom,
+        step_len=0.5,
+        rms_thresh=1.7e-3,
+        r=None,
+        final_geom=None,
+        between=None,
+        bonds=None,
+        r_update=True,
+        r_update_thresh=1.0,
+        stop_after_ts=False,
+        require_imag_freq=0.0,
+        hessian_at_ts=False,
+        out_dir=".",
+        dump=True,
+    ):
+        assert geom.coord_type == "cart"
+
+        self.geom = geom
+        self.step_len = step_len
+        self.rms_thresh = rms_thresh
+        self.final_geom = final_geom
+        self.between = between
+        self.bonds = bonds
+        self.r_update = r_update
+        self.r_update_thresh = r_update_thresh
+        self.stop_after_ts = stop_after_ts
+        self.require_imag_freq = require_imag_freq
+        self.hessian_at_ts = hessian_at_ts
+        self.out_dir = Path(out_dir)
+        self.dump = dump
+
+        if not self.out_dir.exists():
+            os.mkdir(self.out_dir)
+
+        self.coord_type = self.geom.coord_type
+        if self.final_geom:
+            self.converge_to_geom = self.final_geom
+
+        # Determine search direction
+        self.r = self.get_r(self.geom, self.final_geom, self.bonds, r)
+        self.r_org = self.r.copy()
+        # Determine appropriate step_len from between
+        if final_geom and self.between:
+            self.step_len = np.linalg.norm(final_geom.coords - geom.coords) / (
+                self.between + 1
+            )
+
+        self._initialized = False
+        self.images = [self.geom.copy()]
+        self.all_energies = list()
+        self.all_real_forces = list()
+        self.sp_images = [self.geom.copy()]  # Stationary points
+        self.ts_images = list()
+        self.min_images = list()
+
+        self.ts_imag_freqs = list()
+
+        # Right now this leads to a gradient calculation in the momement,
+        # this object is constructed, which is bad.
+        self.initialize()
+
+        if self.dump:
+            self.trj_fn = self.get_path("newton_trajectory_trj.xyz")
+
+    def get_path(self, fn):
+        return self.out_dir / fn
+
+    @staticmethod
+    def get_r(geom, final_geom, bonds, r):
+        if final_geom:
+            r = final_geom - geom
+            # self.converge_to_geom = self.final_geom
+        elif bonds is not None:
+            r = get_weighted_bond_mode(bonds, geom.coords3d)
+        # Use 'r' as it is
+        elif r is not None:
+            pass
+        else:
+            raise Exception("Please supply either 'r' or 'final_geom'!")
+
+        r = r / np.linalg.norm(r)
+        return r
+
+    def log(self, message):
+        self.logger.debug(message)
+
+    @property
+    def r(self):
+        """Parallel/search direction."""
+        return self._r
+
+    @property
+    def P(self):
+        """Projector that keeps perpendicular component."""
+        return self._P
+
+    @r.setter
+    def r(self, r):
+        """Update r and calculate new projector."""
+        self._r = r
+        self._P = np.eye(self.coords.size) - np.outer(self.r, self.r)
+
+    @property
+    def atoms(self):
+        return self.geom.atoms
+
+    @property
+    def coords(self):
+        return self.geom.coords
+
+    @coords.setter
+    def coords(self, coords):
+        self.geom.coords = coords
+
+    @property
+    def cart_coords(self):
+        return self.geom.cart_coords
+
+    def grow_image(self):
+        self.images[-1] = self.geom.copy()
+        # Update coordinates of newly grown image. Try to use Eq. (6) in [1].
+        if self._initialized and self.final_geom and self.between:
+            m = self.between + 2
+            k = len(self.images) - 1
+            lambda_ = (m - k) / (m + 1 - k)
+            # Adapted from [6] to produce a step instead of new coords
+            step = self.coords * (lambda_ - 1) + (1 - lambda_) * self.final_geom.coords
+        # If no final image is given we just displace along r
+        else:
+            step = self.step_len * self.r
+        self.coords = self.coords + step
+
+        # Calculate energy and forces at newly grown geometry and append new frontier
+        # image.
+        real_forces = self.geom.forces
+        energy = self.geom.energy
+        self.all_energies.append(energy)
+        self.all_real_forces.append(real_forces)
+        self.images.append(self.geom)
+
+    def initialize(self):
+        assert not self._initialized, "GrowingNT.initialize() can only be called once!"
+        # Calculation at initial geometry
+        init_results = self.geom.get_energy_and_forces_at(self.images[0].coords)
+        self.all_energies.append(init_results["energy"])
+        self.all_real_forces.append(init_results["forces"])
+        # Do initial displacement
+        self.grow_image()
+        # Indicate the GrowingNT was properly initialized
+        self._initialized = True
+
+    def calc_hessian_for(self, other_geom):
+        res = self.geom.get_energy_and_cart_hessian_at(other_geom.cart_coords)
+        cart_hessian = res["hessian"]
+        return cart_hessian
+
+    @property
+    def energy(self):
+        return self.geom.energy
+
+    @property
+    def forces(self):
+        forces = self.geom.forces
+        perp_forces = self.P.dot(forces)
+        return perp_forces
+
+    @property
+    def cart_forces(self):
+        return self.geom.cart_forces
+
+    def get_energy_at(self, coords):
+        return self.geom.get_energy_at(coords)
+
+    def get_energy_and_forces_at(self, coords):
+        return self.geom.get_energy_and_forces_at(coords)
+
+    def as_xyz(self):
+        return self.geom.as_xyz()
+
+    def clear_passed(self):
+        self.passed_min = False
+        self.passed_ts = False
+
+    def reparametrize(self):
+        """Check if GNT can be grown."""
+
+        # Real, unprojected, forces of the underlying geometry
+        real_forces = self.geom.forces
+        energy = self.energy
+        # Update the last element in all_real_forces and energies with the
+        # current values.
+        self.all_real_forces[-1] = real_forces
+        self.all_energies[-1] = energy
+
+        # See if we can grow the NT, by checking the convergence of the frontier
+        # image using projected forces.
+        forces = self.forces
+        can_grow = rms(forces) <= self.rms_thresh
+
+        if can_grow:
+            if self.dump:
+                with open(self.trj_fn, "w") as handle:
+                    handle.write("\n".join([geom.as_xyz() for geom in self.images]))
+
+            r"""
+            Check if we passed a stationary point (SP).
+            ^ Energy
+            |
+            | -3     -1     -2
+            |   \    /     /  \
+            |    \  /     /    \
+            |     -2     -3    -1
+            | Minimum       TS
+            """
+            ae = self.all_energies  # Shortcut
+            self.passed_min = len(ae) >= 3 and ae[-3] > ae[-2] < ae[-1]
+            self.passed_ts = len(ae) >= 3 and ae[-3] < ae[-2] > ae[-1]
+            passed_sp = self.passed_min or self.passed_ts
+            if passed_sp:
+                sp_image = self.images[-2].copy()
+                sp_kind = "Minimum" if self.passed_min else "TS"
+                self.sp_images.append(sp_image)
+                self.log(
+                    f"Passed stationary point! It seems to be a {sp_kind}."
+                    f"\n{sp_image.as_xyz()}"
+                )
+                if self.passed_ts:
+                    self.ts_images.append(sp_image)
+                    if self.hessian_at_ts:
+                        sp_hessian = self.calc_hessian_for(sp_image)
+                        nus, *_ = sp_image.get_normal_modes(sp_hessian)
+                        self.log(f"First 5 frequencies: {nus[:5]}")
+                    if self.require_imag_freq < 0.0:
+                        try:
+                            sp_hessian
+                        except NameError:
+                            sp_hessian = self.calc_hessian_for(sp_image)
+                        self.ts_imag_freqs.append(
+                            sp_image.get_imag_frequencies(sp_hessian)
+                        )
+                elif self.passed_min:
+                    self.min_images.append(sp_image)
+
+            # Update direction 'r', if requested
+            r_new = self.get_r(self.geom, self.final_geom, self.bonds, self.r)
+            r_dot = r_new.dot(self.r)
+            r_org_dot = r_new.dot(self.r_org)
+            self.log(f"r.dot(r')={r_dot:.6f} r_org.dot(r')={r_org_dot:.6f}")
+            if (
+                self.r_update
+                and (r_org_dot <= self.r_update_thresh)
+                and self.passed_min
+            ):
+                self.r = r_new
+                self.log("Updated r")
+
+            # Grow new image
+            self.grow_image()
+            assert (
+                len(self.images) == len(self.all_energies) == len(self.all_real_forces)
+            )
+
+        self.did_reparametrization = can_grow
+        return can_grow
+
+    def check_convergence(self, *args, **kwargs):
+        if len(self.ts_images) == 0:
+            return False
+
+        converged = self.stop_after_ts
+        if self.require_imag_freq:
+            converged = (
+                converged and self.ts_imag_freqs[-1][0] <= self.require_imag_freq
+            )
+        return converged
+
+    def get_additional_print(self):
+        if self.did_reparametrization:
+            img_num = len(self.images)
+            str_ = f"Grew Newton trajectory to {img_num} images."
+            if self.passed_min:
+                str_ += f" Passed minimum geometry at image {img_num-1}."
+            elif self.passed_ts:
+                str_ += f" Passed transition state geometry at image {img_num-1}."
+        else:
+            str_ = None
+
+        self.did_reparametrization = False
+        self.clear_passed()
+
+        return str_