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

pysisyphus/intcoords/RobustTorsion.py

@@ -0,0 +1,59 @@
+# [1] Transition-State Optimization Methods using Internal Coordinates
+#     https://macsphere.mcmaster.ca/handle/11375/15450?mode=full
+#     Rabi, 2014, Phd Thesis
+
+import numpy as np
+
+from pysisyphus.intcoords.Primitive import Primitive
+from pysisyphus.intcoords.derivatives import (
+    q_rd1,
+    dq_rd1,
+    d2q_rd1,
+    q_rd2,
+    dq_rd2,
+    d2q_rd2,
+)
+
+
+class RobustTorsion1(Primitive):
+    @staticmethod
+    def _weight(atoms, coords3d, indices, f_damping):
+        return 1.0
+
+    @staticmethod
+    def _calculate(coords3d, indices, gradient=False):
+        args = coords3d[indices].flatten()
+        val = q_rd1(*args)
+
+        if gradient:
+            row = np.zeros_like(coords3d)
+            grad = dq_rd1(*args).reshape(-1, 3)
+            row[indices] = grad
+            return val, row.flatten()
+        return val
+
+    @staticmethod
+    def _jacobian(coords3d, indices):
+        return d2q_rd1(*coords3d[indices].flatten())
+
+
+class RobustTorsion2(Primitive):
+    @staticmethod
+    def _weight(atoms, coords3d, indices, f_damping):
+        return 1.0
+
+    @staticmethod
+    def _calculate(coords3d, indices, gradient=False):
+        args = coords3d[indices].flatten()
+        val = q_rd2(*args)
+
+        if gradient:
+            row = np.zeros_like(coords3d)
+            grad = dq_rd2(*args).reshape(-1, 3)
+            row[indices] = grad
+            return val, row.flatten()
+        return val
+
+    @staticmethod
+    def _jacobian(coords3d, indices):
+        return d2q_rd2(*coords3d[indices].flatten())

pysisyphus/intcoords/Rotation.py

@@ -0,0 +1,147 @@
+# [1] http://dx.doi.org/10.1063/1.4952956
+#     Lee-Ping Wang, 2016
+
+import numpy as np
+
+from pysisyphus.intcoords.Primitive import Primitive
+from pysisyphus.linalg import eigvec_grad, rot_quaternion
+
+
+def compare_to_geometric(c3d, ref_c3d, dR, dF, dqdx, dvdx, atol=1e-14):
+    from geometric.rotate import get_R_der, get_F_der, get_q_der, get_expmap_der
+
+    dR_ref = get_R_der(c3d, ref_c3d)
+    np.testing.assert_allclose(dR, dR_ref)
+    dF_ref = get_F_der(c3d, ref_c3d)
+    np.testing.assert_allclose(dF.reshape(-1, 3, 4, 4), dF_ref)
+    dq_ref = get_q_der(c3d, ref_c3d)
+    np.testing.assert_allclose(dqdx.T.flatten(), dq_ref.flatten(), atol=atol)
+    dvdx_ref = get_expmap_der(c3d, ref_c3d)
+    np.testing.assert_allclose(dvdx.T.flatten(), dvdx_ref.flatten(), atol=atol)
+
+
+class Rotation(Primitive):
+    """See (II. Theory) in [1], Eq. (3) - (14)"""
+
+    index = None
+
+    def __init__(self, indices, *args, ref_coords3d, **kwargs):
+        kwargs["cache"] = False
+        kwargs["calc_kwargs"] = ("index", "ref_coords3d")
+        super().__init__(indices, *args, **kwargs)
+
+        self.ref_coords3d = ref_coords3d.reshape(-1, 3).copy()
+
+    @staticmethod
+    def _weight(atoms, coords3d, indices, f_damping):
+        return 1
+
+    @staticmethod
+    def _calculate(coords3d, indices, gradient=False, index=0, ref_coords3d=None):
+        w, v_, c3d, ref_c3d = rot_quaternion(coords3d[indices], ref_coords3d[indices])
+
+        quat = v_[:, -1]
+        # Eigenvector sign is ambigous. Force first item to be positive,
+        # similar to geomeTRIC code.
+        if quat[0] < 0.0:
+            quat *= -1
+
+        # Eq. (8) in [1].
+        # v = 2 * q_i * (cos⁻¹(q_0) / sqrt(1 - q_0 ** 2)
+        #
+        # As q_0 approaches 1, the denominator becomes very small, and dividing
+        # by this small number results in numerical instability.
+        #
+        # According to wolframalpha v(q_0) limit approaches 2 for q_0 = 1.
+        #
+        #   input: limit of (2 * arccos(x) / sqrt(1-x**2))
+        #   output: lim v(x) for x -> 1 becomes 2.
+        q0 = quat[0]
+        if abs(q0 - 1.0) <= 1e-8:
+            prefac = 2 - 2 / 3 * (q0 - 1)
+            dvdq0 = -2 / 3
+        else:
+            arccos_q0 = np.arccos(q0)
+            diff = 1 - q0 ** 2
+            prefac = 2 * arccos_q0 / np.sqrt(diff)
+            dvdq0 = 2 * q0 * arccos_q0 / diff ** 1.5 - 2 / diff
+
+        # Exponential map
+        v = prefac * quat[1:]
+
+        if gradient:
+            # Gradient of correlation matrix
+            y1, y2, y3 = ref_c3d.T
+            dR = np.zeros((*c3d.shape, 3, 3))
+            dR[:, 0, 0, 0] = y1
+            dR[:, 0, 0, 1] = y2
+            dR[:, 0, 0, 2] = y3
+            #
+            dR[:, 1, 1, 0] = y1
+            dR[:, 1, 1, 1] = y2
+            dR[:, 1, 1, 2] = y3
+            #
+            dR[:, 2, 2, 0] = y1
+            dR[:, 2, 2, 1] = y2
+            dR[:, 2, 2, 2] = y3
+            dR11, dR12, dR13, dR21, dR22, dR23, dR31, dR32, dR33 = dR.reshape(-1, 9).T
+
+            # Gradient of F matrix. Construct full matrix, as we have to do a dot
+            # product later on.
+            dF = np.zeros((ref_c3d.size, 4, 4))
+            dF[:, 0, 0] = dR11 + dR22 + dR33
+            dF[:, 0, 1] = dR23 - dR32
+            dF[:, 0, 2] = dR31 - dR13
+            dF[:, 0, 3] = dR12 - dR21
+            #
+            dF[:, 1, 0] = dF[:, 0, 1]
+            dF[:, 1, 1] = dR11 - dR22 - dR33
+            dF[:, 1, 2] = dR12 + dR21
+            dF[:, 1, 3] = dR13 + dR31
+            #
+            dF[:, 2, 0] = dF[:, 0, 2]
+            dF[:, 2, 1] = dF[:, 1, 2]
+            dF[:, 2, 2] = -dR11 + dR22 - dR33
+            dF[:, 2, 3] = dR23 + dR32
+            #
+            dF[:, 3, 0] = dF[:, 0, 3]
+            dF[:, 3, 1] = dF[:, 1, 3]
+            dF[:, 3, 2] = dF[:, 2, 3]
+            dF[:, 3, 3] = -dR11 - dR22 + dR33
+
+            # Quaternion gradient
+            dqdx = eigvec_grad(w, v_, ind=-1, mat_grad=dF)
+
+            dvdq = np.zeros((3, 4))
+            dvdq[:, 0] = dvdq0 * quat[1:]
+            dvdq[:, 1:] = np.diag((prefac, prefac, prefac))
+
+            # Gradient of exponential map from chain rule.
+            # See bottom-left on 214108-3 in [1], after Eq. (11).
+            dvdx = np.einsum("ji,ik->jk", dvdq, dqdx)
+
+            # compare_to_geometric(c3d, ref_c3d, dR, dF, dqdx, dvdx)
+            row = np.zeros_like(coords3d)
+            if index is None:
+                return v, dvdx.reshape(3, -1)
+            row[indices] = dvdx[index].reshape(-1, 3)
+            return v[index], row.flatten()
+        return v[index]
+
+    @staticmethod
+    def _jacobian(coords3d, indices, index=0, ref_coords3d=None):
+        """Not implemented!"""
+        size = len(indices) * 3
+        return np.zeros(size * size)
+
+
+class RotationA(Rotation):
+    index = 0
+
+
+class RotationB(Rotation):
+    index = 1
+
+
+class RotationC(Rotation):
+    index = 2

pysisyphus/intcoords/Stretch.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+from pysisyphus.intcoords.Primitive import Primitive
+from pysisyphus.intcoords.derivatives import d2q_b
+from pysisyphus.linalg import norm3
+
+
+class Stretch(Primitive):
+
+    @staticmethod
+    def _weight(atoms, coords3d, indices, f_damping):
+        return Stretch.rho(atoms, coords3d, indices)
+
+    @staticmethod
+    def _calculate(coords3d, indices, gradient=False):
+        n, m = indices
+        bond = coords3d[m] - coords3d[n]
+        bond_length = norm3(bond)
+        if gradient:
+            bond_normed = bond / bond_length
+            row = np.zeros_like(coords3d)
+            # 1 / -1 correspond to the sign factor [1] Eq. 18
+            row[m,:] =  bond_normed
+            row[n,:] = -bond_normed
+            row = row.flatten()
+            return bond_length, row
+        return bond_length
+
+    @staticmethod
+    def _jacobian(coords3d, indices):
+        return d2q_b(*coords3d[indices].flatten())

pysisyphus/intcoords/Torsion.py

@@ -0,0 +1,101 @@
+from math import sin
+
+import numpy as np
+
+from pysisyphus.intcoords.Primitive import Primitive
+from pysisyphus.intcoords import Bend
+from pysisyphus.intcoords.derivatives import d2q_d2
+from pysisyphus.linalg import cross3, norm3
+
+
+class Torsion(Primitive):
+    @staticmethod
+    def _weight(atoms, coords3d, indices, f_damping):
+        m, o, p, n = indices
+        rho_mo = Torsion.rho(atoms, coords3d, (m, o))
+        rho_op = Torsion.rho(atoms, coords3d, (o, p))
+        rho_pn = Torsion.rho(atoms, coords3d, (p, n))
+        rad_mop = Bend._calculate(coords3d, (m, o, p))
+        rad_opn = Bend._calculate(coords3d, (o, p, n))
+        return (
+            (rho_mo * rho_op * rho_pn) ** (1 / 3)
+            * (f_damping + (1 - f_damping) * sin(rad_mop))
+            * (f_damping + (1 - f_damping) * sin(rad_opn))
+        )
+
+    @staticmethod
+    def _calculate(coords3d, indices, gradient=False):
+        m, o, p, n = indices
+        u_dash = coords3d[m] - coords3d[o]
+        v_dash = coords3d[n] - coords3d[p]
+        w_dash = coords3d[p] - coords3d[o]
+        u_norm = norm3(u_dash)
+        v_norm = norm3(v_dash)
+        w_norm = norm3(w_dash)
+        u = u_dash / u_norm
+        v = v_dash / v_norm
+        w = w_dash / w_norm
+        phi_u = np.arccos(u.dot(w))
+        phi_v = np.arccos(-w.dot(v))
+        uxw = cross3(u, w)
+        vxw = cross3(v, w)
+        cos_dihed = uxw.dot(vxw) / (np.sin(phi_u) * np.sin(phi_v))
+        # Restrict cos_dihed to the allowed interval for arccos [-1, 1]
+        cos_dihed = min(1, max(cos_dihed, -1))
+
+        dihedral_rad = np.arccos(cos_dihed)
+
+        # Arccos only returns values between 0 and π, but dihedrals can
+        # also be negative. This is corrected now.
+        #
+        # (v ⨯ w) · u will be < 0 when both vectors point in different directions.
+        #
+        #  M  --->   N
+        #  ^        ^
+        #   \      /
+        #    u    v    positive dihedral, M rotates into N clockwise
+        #     \  /     (v ⨯ w) · u > 0, keep positive sign
+        #      OwP
+        #              w points downward, into the screen plane.
+        #              The vector resulting from the cross-product is easily
+        #              visualized with your right hand.
+        #
+        #  M
+        #   \
+        #  | u
+        #  |  \
+        #  |   OwP     negative dihedral, M rotates into N counter-clockwise
+        #  v  /        (v ⨯ w) · u < 0, invert dihedral sign
+        #    v
+        #   /
+        #  N
+        #
+        if (dihedral_rad != np.pi) and (vxw.dot(u) < 0):
+            dihedral_rad *= -1
+
+        if gradient:
+            row = np.zeros_like(coords3d)
+            #                  |  m  |  n  |  o  |  p  |
+            # ------------------------------------------
+            # sign_factor(amo) |  1  |  0  | -1  |  0  | 1st term
+            # sign_factor(apn) |  0  | -1  |  0  |  1  | 2nd term
+            # sign_factor(aop) |  0  |  0  |  1  | -1  | 3rd term
+            # sign_factor(apo) |  0  |  0  | -1  |  1  | 4th term
+            sin2_u = np.sin(phi_u) ** 2
+            sin2_v = np.sin(phi_v) ** 2
+            first_term = uxw / (u_norm * sin2_u)
+            second_term = vxw / (v_norm * sin2_v)
+            third_term = uxw * np.cos(phi_u) / (w_norm * sin2_u)
+            fourth_term = -vxw * np.cos(phi_v) / (w_norm * sin2_v)
+            row[m, :] = first_term
+            row[n, :] = -second_term
+            row[o, :] = -first_term + third_term - fourth_term
+            row[p, :] = second_term - third_term + fourth_term
+            row = row.flatten()
+            return dihedral_rad, row
+        return dihedral_rad
+
+    @staticmethod
+    def _jacobian(coords3d, indices):
+        sign = np.sign(Torsion._calculate(coords3d, indices))
+        return sign * d2q_d2(*coords3d[indices].flatten())

pysisyphus/intcoords/Torsion2.py

@@ -0,0 +1,25 @@
+# See
+# https://en.wikipedia.org/wiki/Dihedral_angle#In_polymer_physics
+
+import numpy as np
+
+from pysisyphus.intcoords import Torsion
+from pysisyphus.intcoords.derivatives import q_d2, dq_d2, d2q_d2
+
+
+class Torsion2(Torsion):
+    @staticmethod
+    def _calculate(coords3d, indices, gradient=False):
+        args = coords3d[indices].flatten()
+        val = q_d2(*args)
+
+        if gradient:
+            row = np.zeros_like(coords3d)
+            grad = dq_d2(*args).reshape(-1, 3)
+            row[indices] = grad
+            return val, row.flatten()
+        return val
+
+    @staticmethod
+    def _jacobian(coords3d, indices):
+        return d2q_d2(*coords3d[indices].flatten())

pysisyphus/intcoords/Translation.py

@@ -0,0 +1,45 @@
+# [1] http://dx.doi.org/10.1063/1.4952956
+#     Lee-Ping Wang, 2016
+
+import numpy as np
+
+from pysisyphus.intcoords.Primitive import Primitive
+
+
+class Translation(Primitive):
+    """See (II. Theory) in [1], Eq. (2)"""
+
+    def __init__(self, *args, **kwargs):
+        kwargs["calc_kwargs"] = ("cart_axis",)
+        super().__init__(*args, **kwargs)
+
+    @staticmethod
+    def _weight(atoms, coords3d, indices, f_damping):
+        return 1
+
+    @staticmethod
+    def _calculate(coords3d, indices, gradient=False, cart_axis=0):
+        value = coords3d[indices, cart_axis].mean()
+        if gradient:
+            row = np.zeros_like(coords3d)
+            row[indices, cart_axis] = 1 / len(indices)
+            row = row.flatten()
+            return value, row
+        return value
+
+    @staticmethod
+    def _jacobian(coords3d, indices, cart_axis):
+        size = len(indices) * 3
+        return np.zeros(size * size)
+
+
+class TranslationX(Translation):
+    cart_axis = 0
+
+
+class TranslationY(Translation):
+    cart_axis = 1
+
+
+class TranslationZ(Translation):
+    cart_axis = 2

pysisyphus/intcoords/__init__.py

@@ -0,0 +1,61 @@
+__all__ = [
+    "PrimitiveNotDefinedException",
+    "Bend",
+    "Bend2",
+    "CartesianX",
+    "CartesianY",
+    "CartesianZ",
+    "DummyImproper",
+    "DummyTorsion",
+    "DistanceFunction",
+    "LinearBend",
+    "LinearDisplacement",
+    "OutOfPlane",
+    "Stretch",
+    "Torsion",
+    "Torsion2",
+    "RobustTorsion1",
+    "RobustTorsion2",
+    "RotationA",
+    "RotationB",
+    "RotationC",
+    "TranslationX",
+    "TranslationY",
+    "TranslationZ",
+    "DLC",
+    "HDLC",
+    "CartesianCoords",
+    "MWCartesianCoords",
+    "RedundantCoords",
+    "TRIC",
+    "TMTRIC",
+    "HybridRedundantCoords",
+]
+
+from pysisyphus.intcoords.exceptions import PrimitiveNotDefinedException
+from pysisyphus.intcoords.Bend import Bend
+from pysisyphus.intcoords.Bend2 import Bend2
+from pysisyphus.intcoords.BondedFragment import BondedFragment
+from pysisyphus.intcoords.Cartesian import CartesianX, CartesianY, CartesianZ
+from pysisyphus.intcoords.DistanceFunction import DistanceFunction
+from pysisyphus.intcoords.DummyImproper import DummyImproper
+from pysisyphus.intcoords.DummyTorsion import DummyTorsion
+from pysisyphus.intcoords.CartesianCoords import CartesianCoords, MWCartesianCoords
+from pysisyphus.intcoords.LinearBend import LinearBend
+from pysisyphus.intcoords.LinearDisplacement import LinearDisplacement
+from pysisyphus.intcoords.OutOfPlane import OutOfPlane
+from pysisyphus.intcoords.Rotation import RotationA, RotationB, RotationC
+from pysisyphus.intcoords.RobustTorsion import RobustTorsion1, RobustTorsion2
+from pysisyphus.intcoords.Stretch import Stretch
+from pysisyphus.intcoords.Torsion import Torsion
+from pysisyphus.intcoords.Torsion2 import Torsion2
+from pysisyphus.intcoords.Translation import TranslationX, TranslationY, TranslationZ
+from pysisyphus.intcoords.RedundantCoords import (
+    RedundantCoords,
+    TRIC,
+    TMTRIC,
+    HybridRedundantCoords,
+)
+
+# DLC inherits from RedundantCoords, so we import it after RedundantCoords
+from pysisyphus.intcoords.DLC import DLC, HDLC

pysisyphus/intcoords/augment_bonds.py

@@ -0,0 +1,126 @@
+import logging
+
+import numpy as np
+
+from pysisyphus.Geometry import Geometry
+from pysisyphus.helpers_pure import log
+from pysisyphus.intcoords.setup import get_bond_sets
+from pysisyphus.intcoords import RedundantCoords
+from pysisyphus.intcoords.PrimTypes import PrimTypes
+
+
+logger = logging.getLogger("internal_coords")
+
+
+def augment_bonds(geom, root=0, proj=False):
+    assert geom.coord_type != "cart"
+    log(logger, "Trying to augment bonds.")
+
+    hessian = geom.cart_hessian
+    try:
+        energy = geom.energy
+    except AttributeError:
+        energy = None
+
+    func = find_missing_bonds_by_projection if proj else find_missing_strong_bonds
+
+    missing_bonds = func(geom, hessian, root=root)
+
+    if missing_bonds:
+        aux_bond_pt = PrimTypes.AUX_BOND
+        missing_aux_bonds = [(aux_bond_pt, *mbond) for mbond in missing_bonds]
+        print("\t@Missing bonds:", missing_bonds)
+        new_geom = Geometry(geom.atoms, geom.cart_coords,
+                            coord_type=geom.coord_type,
+                            coord_kwargs={"define_prims": missing_aux_bonds,},
+        )
+        new_geom.set_calculator(geom.calculator)
+        new_geom.energy = energy
+        new_geom.cart_hessian = hessian
+        return new_geom
+    else:
+        return geom
+
+
+def find_missing_strong_bonds(geom, hessian, bond_factor=1.7, thresh=0.3,
+                              root=0):
+    # Define only bonds
+    red = RedundantCoords(geom.atoms, geom.cart_coords,
+                          bond_factor=bond_factor, bonds_only=True)
+    cur_bonds = set([frozenset(b) for b in geom.internal.bond_atom_indices])
+
+    # Transform cartesian hessian to bond hessian
+    bond_hess = red.transform_hessian(hessian)
+    # Determine transisiton vector
+    eigvals, eigvecs = np.linalg.eigh(bond_hess)
+    # There are probably no bonds missing if there are no negative eigenvalues
+    if sum(eigvals < 0) == 0:
+        return list()
+
+    trans_vec = eigvecs[:, root]
+    # Find bonds that strongly contribute to the selected transition vector
+    strong = np.abs(trans_vec) > thresh
+    strong_bonds = np.array(red.bond_atom_indices)[strong]
+    strong_bonds = set([frozenset(b) for b in strong_bonds])
+
+    # Check which strong bonds are missing from the currently defiend bonds
+    missing_bonds = strong_bonds - cur_bonds
+    missing_bonds = [tuple(_) for _ in missing_bonds]
+    return missing_bonds
+
+
+def find_missing_bonds_by_projection(geom, hessian, bond_factor=2.0, bond_thresh=0.35,
+                                     concerted_thresh=0.35, root=0):
+
+    def array2set(arr):
+        return set([tuple(_) for _ in arr])
+
+    bonds_present = array2set(geom.internal.bond_atom_indices)
+    eigvals, eigvecs = np.linalg.eigh(hessian)
+
+    # There are probably no bonds missing if there are no negative eigenvalues
+    if sum(eigvals < 0) == 0:
+        return list()
+
+    trans_vec = eigvecs[:, root]
+
+    c3d = geom.coords3d
+    bond_vec_empty = np.zeros_like(c3d)
+    unique_bonds = array2set(get_bond_sets(geom.atoms, c3d, bond_factor=bond_factor))
+    unique_bonds -= bonds_present
+    unique_bonds = np.array(list(unique_bonds))
+
+    bond_vecs = list()
+    concerted_vecs = list()
+    for m, k in unique_bonds:
+        displ = c3d[k] - c3d[m]
+        displ /= np.linalg.norm(displ)
+
+        # Bond
+        bond = bond_vec_empty.copy()
+        bond[k] = displ
+        bond[m] = -displ
+        bond_vecs.append(bond)
+
+        # Concerted movement
+        conc = bond_vec_empty.copy()
+        conc[k] = displ
+        conc[m] = displ
+        concerted_vecs.append(conc)
+
+    def reshape(arr):
+        return np.array(arr).reshape(-1, trans_vec.size)
+    bond_vecs = reshape(bond_vecs)
+    concerted_vecs = reshape(concerted_vecs)
+
+    def overlaps(arr):
+        return np.abs(arr.dot(trans_vec))
+    bond_ovlps = overlaps(bond_vecs)
+    concerted_ovlps = overlaps(concerted_vecs)
+
+    unique_bonds = np.array(unique_bonds)
+    missing_bonds = unique_bonds[bond_ovlps > bond_thresh]
+    missing_concerted = unique_bonds[concerted_ovlps > concerted_thresh]
+
+    missing_inds = array2set(missing_bonds) | array2set(missing_concerted)
+    return missing_inds