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

pysisyphus/stocastic/align.py

@@ -0,0 +1,127 @@
+import itertools as it
+
+import numpy as np
+import rmsd as rmsd
+from scipy.optimize import linear_sum_assignment
+from scipy.spatial.distance import cdist
+
+
+def match_geom_atoms(ref_geom, geom_to_match, hydrogen=True):
+    """Apply the hungarian method to geom_to_match.
+
+    Uses the scipy implementation of the Hungarian method/
+    Kuhn-Munkres algorithm in scipy.optimize.linear_sum_assignment.
+    
+    See
+        [1] 10.1021/ci400534h
+        [2] 10.1021/acs.jcim.6b00516
+    """
+
+    assert len(ref_geom.atoms) == len(geom_to_match.atoms), \
+        "Atom numbers don't match!"
+
+    ref_coords, _ = ref_geom.coords_by_type
+    coords_to_match, inds_to_match = geom_to_match.coords_by_type
+    atoms = ref_coords.keys()
+
+    # The new geometry that will contain the perhaps reordered
+    # coordinates.
+    geom_matched = geom_to_match.copy()
+    for atom in atoms:
+        # Don't match hydrogens if not requested
+        if atom.lower() == "h" and not hydrogen:
+            continue
+        ref_coords_for_atom = ref_coords[atom]
+        coords_to_match_for_atom = coords_to_match[atom]
+        # Pairwise distances between two collections
+        # Atoms of ref_geom are along the rows, atoms of geom_to_match
+        # along the columns.
+        cd = cdist(ref_coords_for_atom, coords_to_match_for_atom)
+        # Hungarian method, row_inds are returned already sorted, so
+        # we only have to consider col_inds.
+        row_inds, col_inds = linear_sum_assignment(cd)
+        # Resort the coordinates
+        new_coords_for_atom = coords_to_match_for_atom[col_inds]
+        # Original indices of the coordinates in the full coords array
+        # in the Geometry object.
+        old_inds = inds_to_match[atom]
+        # Update coordinates and modify the array directly
+        c3d = geom_matched.coords3d
+        c3d[old_inds] = new_coords_for_atom
+    return geom_matched
+
+
+def apply_transform(coords3d, swap, reflection):
+    """Apply axis swaps and reflections to a coordinate array."""
+    # Swap axes
+    coords3d = coords3d[:, swap]
+    # Reflect
+    coords3d *= reflection
+    return coords3d
+
+
+def matched_rmsd(geom1, geom2, thresh=5e-2):
+    """RMSD for optimally aligned and matched geometries.
+
+    Returns
+    -------
+    matched_rmsd : float
+        RMSD of optimally aligned and matched geometries.
+    matched_geoms : tuple(Geometry, Geometry)
+        Tuple of the optimally aligned and matched geometries.
+    """
+
+    # Work on copies of the Geometries, as calling standard_orientation
+    # moves their coordinates.
+    geom1_copy = geom1.copy()
+    geom1_copy.standard_orientation()
+    coords3d_1 = geom1_copy.coords3d
+    geom2_copy = geom2.copy()
+    geom2_copy.standard_orientation()
+    coords3d_2 = geom2_copy.coords3d.copy()
+
+    # After bringing the Geometries into standard orientation we may
+    # still have to consider additional axis swaps and reflections to
+    # allow optimal atom matching using the Hungarian method.
+
+    # Six possible axis swaps, (3*2, (x, y, z)*((x), (y), (z))).
+    axes = (0, 1, 2)
+    swaps =  list(it.permutations(axes))
+    # Eight possible reflections, (±x, ±y, ±z).
+    reflections = (
+            ( 1,  1,  1),  # no reflection
+            (-1,  1,  1),  # reflect on yz plane
+            ( 1, -1,  1),  # reflect on xz plane
+            ( 1,  1, -1),  # reflect on xy plane
+            (-1, -1,  1),  # reflect on yz and xz planes
+            (-1,  1, -1),  # reflect on yz and xy planes
+            ( 1, -1, -1),  # reflect on xz and xy planes
+            (-1, -1, -1)   # reflect on yz, xz, xy planes
+    )
+    # 48 combinations of six axis swaps and eight reflections.
+    transforms = list(it.product(swaps, reflections))
+
+    matched_rmsds = list()
+    matched_coords = list()
+    for i, transform in enumerate(transforms):
+        # Apply swap and reflection
+        c3d_trans = apply_transform(coords3d_2.copy(), *transform)
+        geom2_to_match = geom2.copy()
+        geom2_to_match.coords3d = c3d_trans
+        # Apply Hungarian method to the transformed Geometry
+        geom2_matched = match_geom_atoms(geom1_copy, geom2_to_match)
+        mrmsd = rmsd.kabsch_rmsd(coords3d_1, geom2_matched.coords3d)
+        matched_rmsds.append(mrmsd)
+        matched_coords.append(geom2_matched.coords)
+
+        # Break when the two geometries are similar. Then we don't have to
+        # apply the remaining transformations.
+        if mrmsd <= thresh:
+            break
+
+    matched_rmsds = np.array(matched_rmsds)
+    min_rmsd_ind = matched_rmsds.argmin()
+    min_rmsd = matched_rmsds.min()
+    best_matching_coords = matched_coords[min_rmsd_ind]
+    geom2_copy.coords = best_matching_coords
+    return min_rmsd, (geom1_copy, geom2_copy)

pysisyphus/testing.py

@@ -0,0 +1,96 @@
+import importlib
+import shutil
+
+from pysisyphus.config import Config, DEFAULTS
+from pysisyphus import logger
+
+try:
+    import pytest
+except ModuleNotFoundError:
+    logger.warning("pytest package could not be imported.")
+
+
+"""Inspired by
+https://github.com/MolSSI/QCEngine/blob/master/qcengine/testing.py
+
+Maybe implement something like this to make test access easier
+    https://stackoverflow.com/a/36601576/12486216
+"""
+
+
+_reason = "Calculator {} is not available."
+_using_cache = dict()
+# Python modules to be imported using importlib.import_module
+IMPORT_DICT = {
+    "dftd4": "dftd4",
+    "pyscf": "pyscf",
+    "dalton": "daltonproject",
+    "qcengine": "qcengine",
+    "openmm": "simtk.openmm",
+    "thermoanalysis": "thermoanalysis",
+    "pyxtb": "xtb.interface",
+    "obabel": "openbabel.openbabel",
+    "geodesic": "geodesic_interpolate",
+}
+
+
+def module_available(calculator):
+    try:
+        import_name = IMPORT_DICT[calculator]
+    except KeyError:
+        return False
+
+    try:
+        _ = importlib.import_module(import_name)
+        available = True
+    except (ModuleNotFoundError, ImportError):
+        available = False
+    return available
+
+
+class DummyMark:
+    def __init__(self, available):
+        self.args = (available,)
+
+
+def using(calculator, set_pytest_mark=True):
+    """Calling disabling set_pytest_mark avoids a runtime dependency on pytest."""
+    calculator = calculator.lower()
+
+    if calculator not in _using_cache:
+        available = False
+
+        # Look into .pysisyphusrc first
+        try:
+            cmd = Config[calculator]["cmd"]
+        except KeyError:
+            # Try defaults last
+            try:
+                cmd = DEFAULTS[calculator]
+            except KeyError:
+                cmd = None
+
+            # Look for dscf availability
+            if calculator == "turbomole":
+                cmd = "dscf"
+
+        # Check if cmd is available on $PATH
+        if cmd is not None:
+            available = bool(shutil.which(cmd))
+        # Handling native python packages from here
+        else:
+            available = module_available(calculator)
+
+        reason = _reason.format(calculator)
+        skipif = not available
+        if set_pytest_mark:
+            mark = pytest.mark.skipif(skipif, reason=reason)
+        else:
+            mark = DummyMark(skipif)
+        _using_cache[calculator] = mark
+    return _using_cache[calculator]
+
+
+def available(calculator, **kwargs):
+    # True when skipif is False
+    return not using(calculator, **kwargs).args[0]

pysisyphus/thermo.py

@@ -0,0 +1,156 @@
+import h5py
+import jinja2
+
+try:
+    from thermoanalysis.QCData import QCData
+    from thermoanalysis.thermo import thermochemistry
+
+    can_thermoanalysis = True
+except ModuleNotFoundError:
+    can_thermoanalysis = False
+
+from pysisyphus.config import p_DEFAULT, T_DEFAULT
+from pysisyphus.constants import AU2KJPERMOL, AU2KCALPERMOL
+from pysisyphus.helpers_pure import highlight_text
+from pysisyphus.Geometry import Geometry
+
+
+def get_thermoanalysis_from_hess_h5(
+    h5_fn, T=T_DEFAULT, p=p_DEFAULT, point_group="c1", return_geom=False
+):
+    with h5py.File(h5_fn, "r") as handle:
+        masses = handle["masses"][:]
+        vibfreqs = handle["vibfreqs"][:]
+        coords3d = handle["coords3d"][:]
+        energy = handle.attrs["energy"]
+        mult = handle.attrs["mult"]
+        atoms = handle.attrs["atoms"]
+
+    thermo_dict = {
+        "masses": masses,
+        "wavenumbers": vibfreqs,
+        "coords3d": coords3d,
+        "scf_energy": energy,
+        "mult": mult,
+    }
+
+    qcd = QCData(thermo_dict, point_group=point_group)
+    thermo = thermochemistry(qcd, temperature=T, pressure=p)
+    if return_geom:
+        geom = Geometry(atoms=atoms, coords=coords3d)
+        return thermo, geom
+    else:
+        return thermo
+
+
+THERMO_TPL = jinja2.Template(
+    """
+{% if geom -%}
+Geometry          : {{ geom }}, {{ geom.atoms|length }} atoms
+{%- endif %}
+Temperature       : {{ "%0.2f" % thermo.T }} K
+Pressure          : {{ thermo.p }} Pa
+Total Mass        : {{ "%0.4f" % thermo.M }} amu
+
+! Symmetry is currently not supported in pysisyphus. !
+! If not given otherwise, c1 and σ = 1 are assumed.  !
+Point Group       : {{ thermo.point_group }}
+Symmetry Number σ : {{ thermo.sym_num }}  
+Linear            : {{ thermo.linear }}
+
++
+| Normal Mode Wavenumbers
+{{ sep }}
+{% for nu in used_nus -%}
+ {{ "\t%04d" % loop.index }}: {{ nu }}
+{% endfor -%}
+{{ sep }}
+{% if is_ts %}This should be a TS.{% endif %}
+Expected {{ expected }} normal modes, got {{ used_nus|length}}.
+
++
+| Inner energy U = U_el + U_vib + U_rot + U_trans
+{{ sep }}
+{{ fmt("U_el", thermo.U_el) }}
+{{ fmt("ZPE", thermo.ZPE) }}
+{{ fmt("U_vib (incl. ZPE)", thermo.U_vib) }}
+{{ fmt("U_rot", thermo.U_rot) }}
+{{ fmt("U_trans", thermo.U_trans) }}
+{{ sep }}
+{{ fmt("U", thermo.U_tot) }}
+
++
+| Enthalpy H = U + kB*T
+{{ sep }}
+{{ fmt("U", thermo.U_tot) }}
+{{ fmt("kB*T", thermo.kBT) }}
+{{ sep }}
+{{ fmt("H", thermo.H) }}
+
++
+| Entropy correction T*S = T*(S_el + S_vib + S_rot + S_trans)
+{{ sep }}
+{{ fmt("T*S_el", thermo.TS_el) }}
+{{ fmt("T*S_vib", thermo.TS_vib) }}
+{{ fmt("T*S_rot", thermo.TS_rot) }}
+{{ fmt("T*S_trans", thermo.TS_trans) }}
+{{ sep }}
+{{ fmt("T*S", thermo.TS_tot) }}
+
++
+| Gibbs free energy G = H - T*S
+{{ sep }}
+{{ fmt("H", thermo.H) }}
+{{ fmt("T*S", thermo.TS_tot) }}
+{{ sep }}
+{{ fmt("G", thermo.G) }}
+{{ fmt("dG", thermo.dG) }}
+""".strip()
+)
+
+
+def print_thermoanalysis(
+    thermo, geom=None, is_ts=False, unit="joule", level=0, title=None
+):
+    """Print thermochemical analysis."""
+
+    units = {
+        "calorie": ("kcal mol⁻¹", AU2KCALPERMOL),
+        "joule": ("kJ mol⁻¹", AU2KJPERMOL),
+    }
+    unit_key, unit_conv = units[unit]
+
+    def fmt(key, hartree):
+        """Output key & energy in Hartree and the chosen unit."""
+        kjm = hartree * unit_conv
+        return f"{key:<18}: {hartree: >16.8f} Eh ({kjm: >18.2f} {unit_key})"
+
+    # Separator
+    sep = "+-----------------------------------------------------------------+"
+
+    sub_modes = 5 if thermo.linear else 6
+    # Expect one real mode less if it is a TS
+    sub_modes += 1 if is_ts else 0
+    expected = 3 * thermo.atom_num - sub_modes
+
+    def fmt_nus(nus):
+        return [f"{nu: >8.2f} cm⁻¹" + (", excluded" if nu < 0.0 else "") for nu in nus]
+
+    rendered = THERMO_TPL.render(
+        geom=geom,
+        thermo=thermo,
+        org_nus=thermo.org_wavenumbers,
+        used_nus=fmt_nus(thermo.wavenumbers),
+        expected=expected,
+        is_ts=is_ts,
+        sep=sep,
+        fmt=fmt,
+    )
+
+    if title is None:
+        title = ""
+    else:
+        title = f", {title}"
+    print(highlight_text(f"Thermochemical corrections{title}", level=level))
+    print()
+    print(rendered)