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

pysisyphus/drivers/barriers.py

@@ -0,0 +1,271 @@
+from pathlib import Path
+from time import time
+
+import numpy as np
+
+from pysisyphus.config import T_DEFAULT, p_DEFAULT
+from pysisyphus.constants import AU2KJPERMOL
+from pysisyphus.helpers_pure import highlight_text, standard_state_corr
+from pysisyphus.TablePrinter import TablePrinter
+from pysisyphus.thermo import print_thermoanalysis
+
+
+def do_endopt_ts_barriers(
+    ts_geom,
+    left_geoms,
+    right_geoms=None,
+    left_fns=None,
+    right_fns=None,
+    do_thermo=False,
+    T=T_DEFAULT,
+    p=p_DEFAULT,
+    calc_getter=None,
+    solv_calc_getter=None,
+    do_standard_state_corr=False,
+):
+    print(highlight_text("Barrier heights after end optimization(s)"))
+    print()
+
+    # Only allow standard state correction when solvent calculator is specified.
+    do_ssc = do_standard_state_corr and (solv_calc_getter is not None)
+    ssc = standard_state_corr(T=T, p=p) if do_ssc else 0.0
+
+    if right_geoms is None:
+        right_geoms = []
+
+    def set_fns(fns, geoms):
+        if fns is None:
+            fns = ["" for geom in geoms]
+        else:
+            fns = [Path(fn).name for fn in fns]
+        return fns
+    left_fns = set_fns(left_fns, left_geoms)
+    right_fns = set_fns(right_fns, left_geoms)
+    ts_fn = "TS"
+
+    ts_atom_num = len(ts_geom.atoms)
+
+    def drop_total_geom(geoms):
+        atom_nums = [len(geom.atoms) for geom in geoms]
+        tot_atom_num = sum(atom_nums)
+        total_geom = None
+        if tot_atom_num > ts_atom_num:
+            total_ind = atom_nums.index(max(atom_nums))
+            total_geom = geoms[total_ind]
+            geoms = [geom for i, geom in enumerate(geoms) if i != total_ind]
+        return geoms, total_geom
+
+    left_geoms, left_total_geom = drop_total_geom(left_geoms)
+    right_geoms, right_total_geom = drop_total_geom(right_geoms)
+
+    def tot_atom_num(geoms):
+        return sum([len(geom.atoms) for geom in geoms])
+
+    left_atom_num = tot_atom_num(left_geoms)
+    assert left_atom_num == ts_atom_num, (
+        f"Atom number mismatch between TS ({ts_atom_num} atoms) and "
+        f"left side ({left_atom_num} atoms)! Aborting barrier calculation"
+    )
+    right_tot_atom_num = tot_atom_num(right_geoms)
+    assert (right_tot_atom_num == ts_atom_num) or (right_tot_atom_num == 0)
+
+    def get_energy(geom, base_name):
+        try:
+            geom.energy
+        except AttributeError:
+            try:
+                geom.set_calculator(calc_getter(base_name=base_name))
+            except TypeError:
+                raise Exception(
+                    f"Energy isn't set at '{base_name}' geometry "
+                    "and no 'calc_getter' was supplied!\nPlease either set "
+                    "the desired quantities (energy/(Hessian)) or supply "
+                    "a 'calc_getter' to calculate them."
+                )
+        return geom.energy
+
+    def get_energies(geoms, base_name):
+        return [
+            get_energy(geom, f"{base_name}_{i:02d}") for i, geom in enumerate(geoms)
+        ]
+
+    en_key = "energy"
+    ts_energy = get_energy(ts_geom, "ts")
+    left_energies = get_energies(left_geoms, "left")
+    right_energies = get_energies(right_geoms, "right")
+
+    def zeros(geoms):
+        return np.zeros(len(geoms))
+
+    # Gibbs free energies
+    if do_thermo:
+        en_key = "free energy"
+
+        def get_thermo(geom, title, is_ts=False):
+            thermo = geom.get_thermoanalysis(geom, T=T, p=p)
+            print_thermoanalysis(thermo, geom=geom, is_ts=is_ts, level=1, title=title)
+            print()
+            return thermo
+
+        ts_thermo = get_thermo(ts_geom, "TS", is_ts=True)
+        ts_dG = ts_thermo.dG
+        left_thermos = [get_thermo(geom, fn) for geom, fn in zip(left_geoms, left_fns)]
+        left_dGs = [thermo.dG for thermo in left_thermos]
+        right_thermos = [
+            get_thermo(geom, fn) for geom, fn in zip(right_geoms, right_fns)
+        ]
+        right_dGs = [thermo.dG for thermo in right_thermos]
+    else:
+        ts_dG = 0.0
+        left_dGs = zeros(left_geoms)
+        right_dGs = zeros(right_geoms)
+
+    def get_solv_correction(geom, fn=None, name=None):
+        fn = str(fn)
+        if fn is not None:
+            infix = f"'{Path(fn).name: >40s}'"
+        else:
+            atom_num = len(geom.atoms)
+            infix = f"{atom_num} atoms"
+
+        print(f"Solvated calculation for {infix} ...", end="")
+        start = time()
+        solv_calc_kwargs = {}
+        if name is not None:
+            solv_calc_kwargs["base_name"] = f"solv_{name}"
+        solv_energy = solv_calc_getter(**solv_calc_kwargs).get_energy(
+            geom.atoms, geom.cart_coords
+        )["energy"]
+        dur = time() - start
+        print(f" finished in {dur:.1f} s.")
+        # Add standard state correction. ssc will be 0.0 if, disabled.
+        return solv_energy, (solv_energy - geom.energy) + ssc
+
+    def get_solv_corrections(geoms, fns, name):
+        return zip(
+            *[get_solv_correction(geom, fn, name) for geom, fn in zip(geoms, fns)]
+        )
+
+    if solv_calc_getter is not None:
+        print(highlight_text("Calculations with solvent model", level=1) + "\n")
+        ts_solv_energy, ts_solv_corr = get_solv_correction(ts_geom, ts_fn, "ts")
+        left_solv_energies, left_solv_corrs = get_solv_corrections(
+            left_geoms, left_fns, "left"
+        )
+        right_solv_energies, right_solv_corrs = get_solv_corrections(
+            right_geoms, right_fns, "right"
+        )
+        print()
+    # Use zeros, so we can add the term later.
+    else:
+        ts_solv_corr = 0.0
+        left_solv_corrs = zeros(left_geoms)
+        right_solv_corrs = zeros(right_geoms)
+
+    # Calculate total contributions for both sides
+    left_dG = sum(left_dGs)
+    right_dG = sum(right_dGs)
+    left_solv_corr = sum(left_solv_corrs)
+    right_solv_corr = sum(right_solv_corrs)
+
+    ts_energy_corr = ts_energy + ts_solv_corr + ts_dG
+    left_energy_corr = sum(left_energies) + left_dG + left_solv_corr
+    right_energy_corr = sum(right_energies) + right_dG + right_solv_corr
+    energies_corr = [left_energy_corr, ts_energy_corr]
+    # TS is always only 1 geometry
+    geom_nums = [len(left_geoms), 1]
+
+    fns = ["Left", "TS"]
+    if right_geoms:
+        energies_corr.append(right_energy_corr)
+        geom_nums.append(len(right_geoms))
+        fns.append("Right")
+    max_len = max(len(s) for s in fns)
+
+    def print_table(table, header, width=17):
+        col_fmts = ["str"] + (len(header) - 1) * ["float"]
+        tp = TablePrinter(header, col_fmts, width=width, sub_underline=False)
+        tp.print_header()
+        for fn, row in zip(all_fns, table.T):
+            fn = str(fn)  # fns may be PosixPath etc.
+            fn_cut = fn[:4] + ".." + fn[-11:] if (len(fn) > width) else fn
+            tp.print_row((fn_cut, *row))
+        print()
+
+    all_fns = left_fns + [ts_fn] + right_fns
+    # Electronic energies
+    all_energies = np.concatenate((left_energies, [ts_energy], right_energies))
+    to_stack = [all_energies]
+    gas_titles = ["File", "E_el"]
+    if do_thermo:
+        # Thermochemical corrections
+        all_dGs = np.concatenate((left_dGs, [ts_dG], right_dGs))
+        # Free Gibbs energies in the gas phase
+        all_Gs_gas = all_energies + all_dGs
+        to_stack += [all_dGs, all_Gs_gas]
+        gas_titles += ["dG_gas", "G_gas"]
+
+    gas_table = np.stack(to_stack)
+    print("All tabulated quantities are given in au.\n")
+    print_table(gas_table, gas_titles)
+    full_titles = gas_titles
+
+    if solv_calc_getter is not None:
+        all_solv_energies = np.concatenate(
+            (left_solv_energies, [ts_solv_energy], right_solv_energies)
+        )
+        all_solv_corrs = np.concatenate(
+            (left_solv_corrs, [ts_solv_corr], right_solv_corrs)
+        )
+        to_stack = [all_energies, all_solv_energies, all_solv_corrs]
+        solv_titles = ["File", "E_el", "E_solv", "dG_solv"]
+        if do_thermo:
+            all_Gs_sol = all_Gs_gas + all_solv_corrs
+            to_stack += [all_Gs_sol]
+            solv_titles += ["G_sol"]
+        solv_table = np.stack(to_stack)
+        if do_ssc:
+            print("dG_solv includes a correction for change of standard state.\n")
+        print_table(solv_table, solv_titles)
+        full_titles += solv_titles[2:]
+
+    energies_corr = np.array(energies_corr)
+    energies_corr -= energies_corr.min()
+    min_ind = energies_corr.argmin()
+    energies_corr *= AU2KJPERMOL
+
+    print(highlight_text("Barriers", level=1))
+    print()
+    print(f"Temperature: {T:.2f} K")
+    print(f"Pressure: {p:.1f} Pa\n")
+
+    print("Corrections:")
+    print(f"Change of standard-state: {do_ssc}, {ssc*AU2KJPERMOL:.2} kJ mol⁻¹")
+    print(f"                 Solvent: {solv_calc_getter is not None}")
+    print(f"         Thermochemistry: {do_thermo}")
+    print()
+
+    def print_geoms_fns(geoms, fns):
+        for i, (geom, fn) in enumerate(zip(geoms, fns)):
+            fn_name = Path(fn).name
+            print(f"\t{i}: {fn_name} ({geom}, {len(geom.atoms)} atoms)")
+
+    def get_geom_key(geoms):
+        return "geometry" if len(geoms) == 1 else "geometries"
+
+    print(f"Left {get_geom_key(left_geoms)}:")
+    print_geoms_fns(left_geoms, left_fns)
+    print("TS geometry:")
+    print_geoms_fns((ts_geom,), ("",))
+    if right_geoms:
+        print(f"Right {get_geom_key(right_geoms)}:")
+        print_geoms_fns(right_geoms, right_fns)
+    print()
+
+    print(f"Minimum {en_key} of {energies_corr[min_ind]} kJ mol⁻¹ at '{fns[min_ind]}'.")
+    print()
+    for fn, en, gnum in zip(fns, energies_corr, geom_nums):
+        geom_str = "geometry" if gnum == 1 else "geometries"
+        is_sum = " " if gnum == 1 else "Σ"
+        print(f"\t{is_sum}{fn:>{max_len}s}: {en:>8.2f} kJ mol⁻¹ ({gnum} {geom_str})")
+    print()

pysisyphus/drivers/birkholz.py

@@ -0,0 +1,138 @@
+# [1] https://onlinelibrary.wiley.com/doi/abs/10.1002/jcc.23910
+#     Birkholz, Schlegel, 2015
+
+import numpy as np
+
+from pysisyphus.Geometry import Geometry
+from pysisyphus.drivers import relaxed_scan
+from pysisyphus.helpers_pure import highlight_text
+from pysisyphus.intcoords.setup import get_bond_mat
+from pysisyphus.intcoords.PrimTypes import normalize_prim_inputs
+
+
+def bond_order(r, r0, b=2):
+    """Bond order for given bond length and reference length.
+
+    Eq. (3) in [1]."""
+    return max(0, (b * (r0 / r) - 1) / (b - 1))
+
+
+def bond_orders(coords3d, bond_indices, r0s):
+    """List of bond orders."""
+    bos = list()
+    for r0, (a, b) in zip(r0s, bond_indices):
+        r = np.linalg.norm(coords3d[a] - coords3d[b])
+        bo = bond_order(r, r0)
+        bos.append(bo)
+    return np.array(bos)
+
+
+def get_r0s(geom, bond_indices):
+    """Reference bond lengths as sum of covalent radii."""
+    crs = geom.covalent_radii
+    a, b = bond_indices.T
+    return crs[a] + crs[b]
+
+
+def bond_orders_for_geom(geom, bond_indices):
+    """Wrapper for bond_orders for simple use with Geometry."""
+    r0s = get_r0s(geom, bond_indices)
+    return bond_orders(geom.coords3d, bond_indices, r0s)
+
+
+def length_for_bond_order(bo, r0, b=2):
+    """Return bond length for given bond order and reference length.
+
+    Eq. (3) in [1]."""
+    return b / ((b - 1) * bo + 1) * r0
+
+
+def birkholz_interpolation(geoms, calc_getter, recreate=True):
+    assert len(geoms) >= 2
+    start = geoms[0]
+    end = geoms[-1]
+    geoms = (start, end)
+    atoms = start.atoms
+    print(f"Coordinates of 'start' geometry\n{start.as_xyz()})")
+    print(f"Coordinates of 'end' geometry\n{end.as_xyz()})\n")
+
+    print(highlight_text("Bonding analysis"))
+    # Bond matrices
+    bm_start, bm_end = [get_bond_mat(geom) for geom in geoms]
+    # Determine formed/broken bonds. The lower triangular part of the bond
+    # matrices has to be zeroed, to avoid double counting. Changes in bonding
+    # are determined with logical XOR.
+    #
+    # Start  End    XOR    Comment
+    # -----  ---    ---    -------
+    # True   True   False  Bond is present at both geometries.
+    # False  False  False  Bond is absent at both geometries.
+    # True   False  True   Bond is broken when going from start to end.
+    # False  True   True   Bond is formed when going from start to end.
+    bm_diff = np.triu(bm_start) ^ np.triu(bm_end)
+    bond_indices = np.stack(np.nonzero(bm_diff), axis=1)
+    bonding_changes = bm_diff.sum()
+    print(f"{bonding_changes} bonds are formed/broken when going from start to end.\n")
+
+    # Determine bond orders at start and end
+    all_bos = [bond_orders_for_geom(geom, bond_indices) for geom in geoms]
+    # Reference bond lengths
+    r0s = get_r0s(start, bond_indices)
+
+    # Print summary
+    for title, geom, bos in zip(("Start", "End"), geoms, all_bos):
+        print(highlight_text(title, level=1))
+        for bo_, (a, b) in zip(bos, bond_indices):
+            aa = atoms[a]
+            ba = atoms[b]
+            print(f"Bond ({aa}{a: >4},{ba}{b: >4}): BO={bo_:.2f}")
+        print(
+            f"mean(BOs)={bos.mean():.2f}, max(BOs)={bos.max():.2f}, min(BOs)={bos.min():.2f}"
+        )
+        print()
+
+    # Guess goal bond lenghts from mean bond order
+    start_bos, end_bos = all_bos
+    mean_bos = (start_bos + end_bos) / 2
+    # Determine goal bond lenghts that yield the mean bond orders
+    goal_lengths = length_for_bond_order(mean_bos, r0s)
+
+    # Constrain formed/broken bonds
+    constrain_prims = normalize_prim_inputs([["BOND", *bond] for bond in bond_indices])
+
+    # Start relaxed scans towards TS from 'start' and 'end'
+    print(highlight_text("Relaxed scan towards TS, from 'start'"))
+    start_guess, *_ = relaxed_scan(
+        start, calc_getter, constrain_prims, target_values=goal_lengths, title="start"
+    )
+    print()
+    start_guess.dump_xyz("start_guess")
+
+    print(highlight_text("Relaxed scan towards TS, from 'end'"))
+    end_guess, *_ = relaxed_scan(
+        end, calc_getter, constrain_prims, target_values=goal_lengths, title="end"
+    )
+    print()
+    end_guess.dump_xyz("end_guess")
+
+    # Compare energies and take the one with lower energy
+    start_en = start_guess.energy
+    end_en = end_guess.energy
+    print(f"Energy of 'start'-guess: {start_en:.6f} au")
+    print(f"Energy of   'end'-guess: {end_en:.6f} au")
+    start_lower = start_en <= end_en
+    lower = "'start'-guess" if start_lower else "'end'-guess"
+    print(f"{lower} has lower energy.")
+    ts_guess = start_guess if start_lower else end_guess
+
+    if recreate:
+        print("Recreated Geometry object.")
+        ts_guess = Geometry(ts_guess.atoms, ts_guess.cart_coords, coord_type="redund")
+        ts_guess.set_calculator(calc_getter())
+    print()
+    print(f"Coordinates of TS guess\n{ts_guess.as_xyz()})\n")
+    ts_guess_fn = "ts_guess.xyz"
+    ts_guess.dump_xyz(ts_guess_fn)
+    print(f"Dumped TS-guess to '{ts_guess_fn}'.")
+
+    return ts_guess