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

pysisyphus/intcoords/setup_fast.py

@@ -0,0 +1,176 @@
+import itertools as it
+import logging
+
+import numpy as np
+from sklearn.neighbors import KDTree
+
+from pysisyphus.elem_data import COVALENT_RADII as CR
+from pysisyphus.helpers_pure import log, timed
+from pysisyphus.intcoords.valid import bend_valid, dihedral_valid
+
+
+logger = logging.getLogger("internal_coords")
+
+BOND_FACTOR = 1.3
+
+
+def get_max_bond_dists(atoms, bond_factor, covalent_radii=None):
+    if covalent_radii is None:
+        cr = CR
+    else:
+        cr = {atom: covrad for atom, covrad in zip(atoms, covalent_radii)}
+
+    unique_atoms = set(atoms)
+    atom_pairs = it.combinations_with_replacement(unique_atoms, 2)
+    max_bond_dists = {
+        frozenset((from_, to_)): bond_factor * (cr[from_] + cr[to_])
+        for from_, to_ in atom_pairs
+    }
+    return max_bond_dists
+
+
+def find_bonds(
+    atoms, coords3d, covalent_radii=None, bond_factor=BOND_FACTOR, min_dist=0.1
+):
+    atoms = [atom.lower() for atom in atoms]
+    c3d = coords3d.reshape(-1, 3)
+    if covalent_radii is None:
+        covalent_radii = [CR[atom] for atom in atoms]
+    cr = np.array(covalent_radii)
+
+    max_bond_dists = get_max_bond_dists(atoms, bond_factor, covalent_radii=cr)
+    radii = bond_factor * (cr.copy() + max(cr))
+    kdt = KDTree(c3d)
+    res, dists = kdt.query_radius(c3d, radii, return_distance=True)
+    bonds_ = list()
+    for i, (atom, bonds, dists_) in enumerate(zip(atoms, res, dists)):
+        fsets = [frozenset((atom, atoms[a])) for a in bonds]
+        ref_dists = np.array([max_bond_dists[fset] for fset in fsets])
+        keep = np.logical_and(dists_ <= ref_dists, min_dist <= dists_)
+        for to_ in bonds[keep]:
+            bonds_.append(frozenset((i, to_)))
+    bonds = np.array([tuple((from_, to_)) for from_, to_ in set(bonds_)])
+    return bonds
+
+
+def find_bonds_for_geom(geom, bond_factor=BOND_FACTOR):
+    return find_bonds(geom.atoms, geom.coords3d, geom.covalent_radii)
+
+
+def get_bond_vec_getter(
+    atoms, covalent_radii, bonds_for_inds, no_bonds_with=None, bond_factor=BOND_FACTOR
+):
+    max_bond_dists = get_max_bond_dists(
+        atoms, bond_factor, covalent_radii=covalent_radii
+    )
+    max_bond_dists_for_inds = [
+        np.array([max_bond_dists[frozenset((atoms[ind], atom_))] for atom_ in atoms])
+        for ind in bonds_for_inds
+    ]
+    if no_bonds_with is None:
+        # List of empty lists
+        no_bonds_with = [[] * len(bonds_for_inds)]
+
+    # Set it to a negative value, so the calculated distance, which is always positive
+    # can't be smaller than this value.
+    for mbd, nbw in zip(max_bond_dists_for_inds, no_bonds_with):
+        mbd[nbw] = -1
+
+    all_inds = np.arange(len(atoms))
+
+    def get_bond_vecs(coords, return_bonded_inds=False):
+        coords3d = coords.reshape(-1, 3)
+        all_bond_vecs = list()
+        all_bonded_inds = list()
+        for ind, max_dists in zip(bonds_for_inds, max_bond_dists_for_inds):
+            distance_vecs = coords3d - coords3d[ind]
+            distances = np.linalg.norm(distance_vecs, axis=1)
+            # Set 0.0 distance of atom with itself to a high value to not form
+            # and ind-ind bond.
+            distances[ind] = 10_000
+            bond_mask = distances <= max_dists
+            all_bond_vecs.append(distance_vecs[bond_mask])
+            all_bonded_inds.append(all_inds[bond_mask])
+
+        if return_bonded_inds:
+            return all_bond_vecs, all_bonded_inds
+        else:
+            return all_bond_vecs
+
+    return get_bond_vecs
+
+
+def get_bend_candidates(bonds):
+    """Also yields duplicates [a, b, c] and [c, b, a]."""
+    bond_dict = {}
+    bonds = [tuple(bond) for bond in bonds]
+    # Construct a dictionary holding neighbours for a given atom.
+    for from_, to_ in bonds:
+        bond_dict.setdefault(from_, list()).append(to_)
+        bond_dict.setdefault(to_, list()).append(from_)
+
+    for bond in bonds:
+        from_, to_ = bond
+        # Look up neighbours of from_ and to_ in the dictionary
+        from_neighs = set(bond_dict[from_]) - set((to_,))
+        to_neighs = set(bond_dict[to_]) - set((from_,))
+        bend_candidates = [(neigh,) + bond for neigh in from_neighs] + [
+            bond + (neigh,) for neigh in to_neighs
+        ]
+        yield from bend_candidates
+
+
+def find_bends(coords3d, bonds, min_deg, max_deg, logger=None):
+    bend_set = set()
+    for indices in get_bend_candidates(bonds):
+        if (
+            (not bend_valid(coords3d, indices, min_deg, max_deg))
+            or (indices in bend_set)
+            or (indices[::-1] in bend_set)
+        ):
+            continue
+        bend_set.add(indices)
+    return [list(bend) for bend in bend_set]
+
+
+def find_dihedrals(coords3d, bonds, bends, max_deg, logger=None):
+    bond_dict = {}
+    bonds = [tuple(bond) for bond in bonds]
+    for from_, to_ in bonds:
+        bond_dict.setdefault(from_, list()).append(to_)
+        bond_dict.setdefault(to_, list()).append(from_)
+
+    dihedral_set = set()
+    for bend in bends:
+        bend = tuple(bend)
+        from_, central, to_ = bend
+        from_neighs = set(bond_dict[from_]) - set((to_, central))
+        to_neighs = set(bond_dict[to_]) - set((from_, central))
+        dihedral_candidates = [(neigh,) + bend for neigh in from_neighs] + [
+            bend + (neigh,) for neigh in to_neighs
+        ]
+        for indices in dihedral_candidates:
+            if not dihedral_valid(coords3d, indices, deg_thresh=max_deg):
+                continue
+            dihedral_set.add(indices)
+    return [list(dihedral) for dihedral in dihedral_set]
+
+
+def find_bonds_bends(geom, bond_factor=BOND_FACTOR, min_deg=15, max_deg=175):
+    log(logger, "Starting detection of bonds and bends.")
+    bonds = find_bonds_for_geom(geom, bond_factor=bond_factor)
+    log(logger, f"Found {len(bonds)} bonds.")
+    bends = find_bends(geom.coords3d, bonds, min_deg=min_deg, max_deg=max_deg)
+    log(logger, f"Found {len(bends)} bends.")
+    return bonds, bends
+
+
+@timed(logger)
+def find_bonds_bends_dihedrals(geom, bond_factor=BOND_FACTOR, min_deg=15, max_deg=175):
+    log(logger, f"Detecting bonds, bends and dihedrals for {len(geom.atoms)} atoms.")
+    bonds, bends = find_bonds_bends(
+        geom, bond_factor=bond_factor, min_deg=min_deg, max_deg=max_deg
+    )
+    proper_dihedrals = find_dihedrals(geom.coords3d, bonds, bends, max_deg)
+    log(logger, f"Found {len(proper_dihedrals)} proper dihedrals.")
+    return bonds, bends, proper_dihedrals

pysisyphus/intcoords/update.py

@@ -0,0 +1,272 @@
+import numpy as np
+
+from pysisyphus.config import BEND_MIN_DEG, LB_MIN_DEG
+from pysisyphus.helpers_pure import log
+from pysisyphus.intcoords.eval import eval_primitives
+from pysisyphus.intcoords.exceptions import NeedNewInternalsException
+from pysisyphus.intcoords.valid import bend_valid, dihedral_valid
+from pysisyphus.intcoords.PrimTypes import Bends, Dihedrals, Rotations
+
+
+def correct_dihedrals(new_dihedrals, old_dihedrals):
+    """Dihedrals are periodic. Going from -179° to 179° is not a step of 358°,
+    but a step of 2°. By considering the actual distance of the dihedrals from
+    π the correct step can be calculated.
+
+        dihedral step length  = abs(abs(new_dihedral) - π) + abs(abs(old_dihedral) - π)
+
+    or put differently
+
+        dihedral step length = abs(abs(new_dihedral - old_dihedral) - 2*π)
+
+    The sign is left to be determined. Going from -179° to 179° (roughly π - -π = 2π)
+    is a counter clockwise rotation and the dihedral has to decrease below -π. Going
+    from 179° to -179° (roughly -π - π = -2π) is a clockwise rotation and the dihedral
+    increases abvove π. So the correct sign corresponds to the negative sign of the
+    original difference.
+
+    original difference  2π -> dihedral must decrease -> sign = -1
+    original difference -2π -> dihedral must increase -> sign = +1
+
+    Overall, the old dihedral is modified by the actual step length with the correct
+    sign."""
+    new_dihedrals = np.atleast_1d(new_dihedrals)
+    old_dihedrals = np.atleast_1d(old_dihedrals)
+    dihedrals_step = new_dihedrals - old_dihedrals
+    shifted_by_2pi = np.abs(np.abs(dihedrals_step) - 2 * np.pi) < np.pi / 2
+    corrected_dihedrals = new_dihedrals.copy()
+    corrected_dihedrals[shifted_by_2pi] -= (
+        2 * np.pi * np.sign(dihedrals_step[shifted_by_2pi])
+    )
+    return corrected_dihedrals
+
+
+def update_internals(
+    new_coords3d,
+    old_internals,
+    primitives,
+    dihedral_inds,
+    rotation_inds,
+    bend_inds,
+    check_dihedrals=False,
+    check_bends=False,
+    bend_min_deg=BEND_MIN_DEG,
+    bend_max_deg=LB_MIN_DEG,
+    rotation_thresh=0.9,
+    logger=None,
+):
+    prim_internals = eval_primitives(new_coords3d, primitives)
+    new_internals = np.array([prim_int.val for prim_int in prim_internals])
+    internal_diffs = new_internals - old_internals
+
+    new_rotations = new_internals[rotation_inds]
+    # Check for approaching singularity as discussed in the geomeTRIC paper. The
+    # original code seems to check this only for linear molecules and instead
+    # does some +2π/-2π magic, similar to how dihedrals differences are handled.
+    if (np.abs(new_rotations / np.pi) >= rotation_thresh).any():
+        raise NeedNewInternalsException(new_coords3d)
+
+    dihedrals = [prim_internals[i] for i in dihedral_inds]
+
+    dihedral_diffs = internal_diffs[dihedral_inds]
+
+    # Find differences that are shifted by 2*pi
+    shifted_by_2pi = np.abs(np.abs(dihedral_diffs) - 2 * np.pi) < np.pi / 2
+    new_dihedrals = np.array([dihed.val for dihed in dihedrals])
+    if any(shifted_by_2pi):
+        new_dihedrals[shifted_by_2pi] -= (
+            2 * np.pi * np.sign(dihedral_diffs[shifted_by_2pi])
+        )
+        # Update values
+        for dihed, new_val in zip(dihedrals, new_dihedrals):
+            dihed.val = new_val
+
+    invalid_inds = list()
+    # See if dihedrals became invalid (collinear atoms)
+    if check_dihedrals:
+        are_valid = [dihedral_valid(new_coords3d, prim.inds) for prim in dihedrals]
+        try:
+            first_dihedral = dihedral_inds[0]
+        except IndexError:
+            first_dihedral = 0
+        invalid_inds = [
+            i + first_dihedral for i, is_valid in enumerate(are_valid) if not is_valid
+        ]
+
+    if check_bends and len(bend_inds) > 0:
+        bends = [prim_internals[i] for i in bend_inds]
+        are_valid = [
+            bend_valid(new_coords3d, prim.inds, bend_min_deg, bend_max_deg)
+            for prim in bends
+        ]
+        first_bend = bend_inds[0]
+        invalid_inds = [
+            i + first_bend for i, is_valid in enumerate(are_valid) if not is_valid
+        ]
+
+    if len(invalid_inds) > 0:
+        invalid_prims = [primitives[i] for i in invalid_inds]
+        invalid_msg = ", ".join([str(tp) for tp in invalid_prims])
+        log(logger, "Internal coordinate(s) became invalid! Need new internal coordinates!")
+        log(logger, f"Invalid primitives: {invalid_msg}")
+        raise NeedNewInternalsException(
+            new_coords3d, invalid_inds=invalid_inds, invalid_prims=invalid_prims
+        )
+
+    return prim_internals
+
+
+def inds_from_prim_types(typed_prims, prim_types):
+    inds = [
+        i for i, (prim_type, *inds) in enumerate(typed_prims) if prim_type in prim_types
+    ]
+    return inds
+
+
+def transform_int_step(
+    int_step,
+    old_cart_coords,
+    cur_internals,
+    Bt_inv_prim,
+    primitives,
+    typed_prims=None,
+    dihedral_inds=None,
+    rotation_inds=None,
+    bend_inds=None,
+    check_dihedrals=False,
+    check_bends=False,
+    bend_min_deg=BEND_MIN_DEG,
+    bend_max_deg=LB_MIN_DEG,
+    freeze_atoms=None,
+    constrained_inds=None,
+    update_constraints=False,
+    cart_rms_thresh=1e-6,
+    Bt_inv_prim_getter=None,
+    max_cycles=25,
+    logger=None,
+):
+    """Transformation is done in primitive internals, so int_step must be given
+    in primitive internals and not in DLC!"""
+
+    # If an iterable of typed prims is given we can derive bend/dihedral/rotation
+    # indices from them.
+    if typed_prims is not None:
+        if dihedral_inds is None:
+            dihedral_inds = inds_from_prim_types(typed_prims, Dihedrals)
+
+        if bend_inds is None:
+            bend_inds = inds_from_prim_types(typed_prims, Bends)
+
+        if rotation_inds is None:
+            rotation_inds = inds_from_prim_types(typed_prims, Rotations)
+
+    if freeze_atoms is None:
+        freeze_atoms = list()
+
+    if constrained_inds is None:
+        constrained_inds = list()
+
+    freeze_atoms = np.array(freeze_atoms, dtype=int)
+    new_cart_coords = old_cart_coords.copy()
+    remaining_int_step = int_step
+    target_internals = cur_internals + int_step
+    # When we want to update the constraints we use the target primitive internals,
+    if update_constraints:
+        constrained_vals = target_internals[constrained_inds]
+    # otherwise we try to stay with the original constrained values.
+    else:
+        constrained_vals = cur_internals[constrained_inds]
+
+    def backtransform(remaining_int_step, Bt_inv_prim):
+        """Separate function so it can be a called after the main loop
+        finished to re-enforce the constraints."""
+        nonlocal new_cart_coords
+
+        cart_step = Bt_inv_prim.T.dot(remaining_int_step)
+        # Remove step from frozen atoms.
+        cart_step.reshape(-1, 3)[freeze_atoms] = 0.0
+        cart_rms = np.sqrt(np.mean(cart_step**2))
+        # Update cartesian coordinates
+        new_cart_coords += cart_step
+        # Determine new internal coordinates
+        new_prim_ints = update_internals(
+            new_cart_coords.reshape(-1, 3),
+            old_internals,
+            primitives,
+            dihedral_inds,
+            rotation_inds,
+            bend_inds,
+            check_dihedrals=check_dihedrals,
+            check_bends=check_bends,
+            bend_min_deg=bend_min_deg,
+            bend_max_deg=bend_max_deg,
+            logger=logger,
+        )
+        new_internals = [prim.val for prim in new_prim_ints]
+        return new_prim_ints, new_internals, cart_rms
+
+    last_rms = 9999
+    old_internals = cur_internals
+    backtransform_failed = True
+    for i in range(max_cycles):
+        if Bt_inv_prim_getter is not None:
+            Bt_inv_prim = Bt_inv_prim_getter(new_cart_coords)
+            log(logger, f"Recalculated (B^T)^+ in microcycle {i}")
+
+        new_prim_ints, new_internals, cart_rms = backtransform(
+            remaining_int_step, Bt_inv_prim
+        )
+        remaining_int_step = target_internals - new_internals
+        internal_rms = np.sqrt(np.mean(remaining_int_step**2))
+        log(
+            logger,
+            f"Cycle {i}: rms(Δcart)={cart_rms:1.4e}, rms(Δint.) = {internal_rms:1.5e}",
+        )
+
+        # This assumes the first cart_rms won't be > 9999 ;)
+        if cart_rms < last_rms:
+            # Store results of the conversion cycle for laster use, if
+            # the internal-cartesian-transformation goes bad.
+            best_cycle = (new_cart_coords.copy(), new_internals.copy())
+            best_cycle_ind = i
+        elif i != 0:
+            # If the conversion somehow fails we fallback to the best previous step.
+            log(logger, f"Backconversion failed! Falling back to step {best_cycle_ind}")
+            new_cart_coords, new_internals = best_cycle
+            break
+        else:
+            raise Exception(
+                "Internal-cartesian back-transformation already "
+                "failed in the first step. Aborting!"
+            )
+        old_internals = new_internals
+
+        last_rms = cart_rms
+        if cart_rms < cart_rms_thresh:
+            log(
+                logger,
+                f"Internal->Cartesian transformation converged in {i+1} cycle(s)!",
+            )
+            backtransform_failed = False
+            break
+
+    if len(constrained_inds) > 0:
+        for j in range(max_cycles):
+            cur_constrained_vals = np.array(new_internals)[constrained_inds]
+            diff = constrained_vals - cur_constrained_vals
+            if any(np.abs(diff) <= 1e-5):
+                break
+            remaining_int_step = np.zeros_like(remaining_int_step)
+            remaining_int_step[constrained_inds] = diff
+            new_prim_ints, new_internals, _ = backtransform(
+                remaining_int_step, Bt_inv_prim
+            )
+        if j > 0:
+            log(logger, f"Re-enforced constraints in {j} additional cycle(s).")
+
+    log(logger, "")
+
+    # Return the difference between the new cartesian coordinates that yield
+    # the desired internal coordinates and the old cartesian coordinates.
+    cart_step = new_cart_coords - old_cart_coords
+    return new_prim_ints, cart_step, backtransform_failed

pysisyphus/intcoords/valid.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+from pysisyphus.helpers_pure import log
+from pysisyphus.intcoords.PrimTypes import PrimTypes
+from pysisyphus.intcoords import Bend
+from pysisyphus.linalg import norm3
+
+
+def bend_valid(coords3d, indices, min_deg, max_deg):
+    val = Bend._calculate(coords3d, indices)
+    deg = np.rad2deg(val)
+    return min_deg <= deg <= max_deg
+
+
+def are_collinear(vec1, vec2, deg_thresh=179.5):
+    thresh = np.cos(np.deg2rad(deg_thresh))
+    return abs(vec1.dot(vec2)) >= abs(thresh)
+
+
+def dihedral_valid(coords3d, inds, deg_thresh=177.5):
+    if len(set(inds)) != 4:
+        return False
+
+    m, o, p, n = inds
+    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
+
+    valid = not (
+        are_collinear(u, w, deg_thresh=deg_thresh)
+        or are_collinear(v, w, deg_thresh=deg_thresh)
+    )
+    return valid
+
+
+def dihedrals_are_valid(coords3d, dihedral_inds, logger=None):
+    valid = [dihedral_valid(coords3d, inds) for inds in dihedral_inds]
+    invalid = [dihedral_ind for dihedral_ind, v in zip(dihedral_inds, valid) if not v]
+    if invalid:
+        log(logger, f"Invalid dihedrals: {invalid}")
+    all_valid = all(valid)
+    return all_valid
+
+
+def check_typed_prims(
+    coords3d,
+    typed_prims,
+    bend_min_deg,
+    dihed_max_deg,
+    lb_min_deg,
+    logger=None,
+    check_bends=True,
+):
+    if check_bends:
+        bend_func = lambda indices: bend_valid(
+            coords3d, indices, min_deg=bend_min_deg, max_deg=lb_min_deg
+        )
+    else:
+        bend_func = lambda indices: True
+    funcs = {
+        PrimTypes.BEND: bend_func,
+        PrimTypes.PROPER_DIHEDRAL: lambda indices: dihedral_valid(
+            coords3d,
+            indices,
+            deg_thresh=dihed_max_deg,
+        ),
+        PrimTypes.IMPROPER_DIHEDRAL: lambda indices: dihedral_valid(
+            coords3d,
+            indices,
+            deg_thresh=dihed_max_deg,
+        ),
+    }
+    valid_typed_prims = list()
+    for i, (type_, *indices) in enumerate(typed_prims):
+        try:
+            valid = funcs[type_](indices)
+        except KeyError:
+            valid = True
+        if valid:
+            valid_typed_prims.append((type_, *indices))
+        else:
+            log(logger, f"Primitive {(type_, *indices)} is invalid!")
+    return valid_typed_prims

pysisyphus/interpolate/Geodesic.py

@@ -0,0 +1,93 @@
+# [1] https://doi.org/10.1063/1.5090303
+#     Geodesic interpolation for reaction pathways
+#     Zhu, Thompson, Martinez, 2019
+
+import numpy as np
+
+from pysisyphus.Geometry import Geometry
+from pysisyphus.interpolate.Interpolator import Interpolator
+from pysisyphus.constants import BOHR2ANG
+
+try:
+    from geodesic_interpolate.interpolation import redistribute
+    from geodesic_interpolate.geodesic import Geodesic as Geo
+
+    can_geodesic = True
+except ImportError:
+    can_geodesic = False
+
+
+class Geodesic(Interpolator):
+    def __init__(
+        self,
+        *args,
+        align: bool = False,
+        tol: float = 2e-3,
+        scaling: float = 1.7,
+        dist_cutoff: float = 3.0,
+        friction: float = 1e-2,
+        maxiter: int = 15,
+        microiter: int = 20,
+        **kwargs,
+    ):
+        """Geodesic Interpolation for Reaction Pathways.
+
+        Requires the 'geodesic-interpolate' package found at
+
+            https://github.com/virtualzx-nad/geodesic-interpolate.git
+
+        Parameters
+        ----------
+        align : bool, optional
+            Whether to align geometries, by default False
+        tol : float, optional
+            Convergence tolerance, by default 2e-3
+        scaling : float, optional
+            Exponential parameter for morse potential, by default 1.7
+        dist_cutoff : float, optional
+            Cut-off value for the distance between a pair of atoms
+            to be included in the coordinate system, by default 3.0
+        friction : float, optional
+            Size of friction term used to prevent very large
+            change of geometry, by default 1e-2
+        maxiter : int, optional
+            Maximum number of minimization iterations, by default 15
+        microiter : int, optional
+            Maximum number of micro iterations for
+            sweeping algorithm, by default 20
+        """
+        super().__init__(*args, align=align, **kwargs)
+        self.tol = tol
+        self.scaling = scaling
+        self.dist_cutoff = dist_cutoff
+        self.friction = friction
+        self.maxiter = maxiter
+        self.microiter = microiter
+
+    def interpolate(self, initial_geom, final_geom, **kwargs):
+        if not can_geodesic:
+            raise ModuleNotFoundError(
+                "Geodesic interpolation requires the geodesic_interpolate package."
+            )
+        coords3d = np.array((initial_geom.coords3d, final_geom.coords3d))
+        coords3d *= BOHR2ANG
+
+        nimages = 2 + self.between
+        raw = redistribute(self.atoms, coords3d, nimages, tol=self.tol * 5)
+
+        smoother = Geo(
+            self.atoms,
+            raw,
+            self.scaling,
+            threshold=self.dist_cutoff,
+            friction=self.friction,
+        )
+        if len(self.atoms) > 35:
+            path = smoother.sweep(
+                tol=self.tol, max_iter=self.maxiter, micro_iter=self.microiter
+            )
+        else:
+            path = smoother.smooth(tol=self.tol, max_iter=self.maxiter)
+        path /= BOHR2ANG
+        interpolated_geoms = [Geometry(self.atoms, coords) for coords in path]
+        return interpolated_geoms[1:-1]

pysisyphus/interpolate/IDPP.py

@@ -0,0 +1,55 @@
+from scipy.spatial.distance import pdist
+
+# from pysisyphus.constants import BOHR2ANG, ANG2BOHR
+from pysisyphus.calculators.IDPPCalculator import IDPPCalculator
+from pysisyphus.constants import BOHR2ANG, ANG2BOHR
+from pysisyphus.cos.NEB import NEB
+from pysisyphus.helpers import align_geoms
+from pysisyphus.optimizers.FIRE import FIRE
+from pysisyphus.interpolate.Interpolator import Interpolator
+
+
+# [1] http://aip.scitation.org/doi/full/10.1063/1.4878664
+# See https://gitlab.com/ase/ase/blob/master/ase/neb.py
+
+
+class IDPP(Interpolator):
+
+    def interpolate(self, initial_geom, final_geom, **kwargs):
+        # Do an initial linear interpolation to generate all geometries/images
+        # that will be refined later by IDPP interpolation.
+        linear_interpol = super().interpolate(initial_geom, final_geom)
+        idpp_geoms = [initial_geom] + linear_interpol + [final_geom]
+        align_geoms(idpp_geoms)
+
+        # Interestingly IDPP calculations work much better when done
+        # in Angstroem instead of in Bohr.
+        for geom in idpp_geoms:
+            geom.coords *= BOHR2ANG
+
+        # We want to interpolate between these two condensed distance matrices
+        initial_pd = pdist(initial_geom.coords3d)
+        final_pd = pdist(final_geom.coords3d)
+        steps = 1 + self.between
+        pd_diff = (final_pd - initial_pd) / steps
+
+        for i, geom in enumerate(idpp_geoms):
+            geom.set_calculator(IDPPCalculator(initial_pd + i * pd_diff))
+
+        neb = NEB(idpp_geoms)
+        opt_kwargs = {
+            "max_cycles": 1000,
+            "rms_force": 1e-2,
+            "align": False,
+            "check_coord_diffs": False,
+        }
+        opt = FIRE(neb, **opt_kwargs)
+        opt.run()
+
+        for geom in idpp_geoms:
+            # Delete IDPP calculator, energies and forces
+            geom.clear()
+            geom.coords *= ANG2BOHR
+
+        interpolated_geoms = idpp_geoms[1:-1]
+        return interpolated_geoms