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

pysisyphus/wrapper/mwfn.py

@@ -0,0 +1,169 @@
+import logging
+import os
+from pathlib import Path
+import shutil
+from subprocess import PIPE, Popen
+
+import numpy as np
+
+from pysisyphus.config import get_cmd
+from pysisyphus.constants import AU2EV
+from pysisyphus.wrapper.exceptions import SegfaultException
+
+
+logger = logging.getLogger("mwfn")
+
+
+def log(msg):
+    logger.debug(msg)
+
+
+def wrap_stdin(stdin):
+    return f"<< EOF\n{stdin}\nEOF"
+
+
+def call_mwfn(inp_fn, stdin, cwd=None):
+    if cwd is None:
+        cwd = Path(".")
+    mwfn_cmd = get_cmd("mwfn")
+    cmd = [mwfn_cmd, inp_fn]
+    log(f"\n{mwfn_cmd} {inp_fn} {wrap_stdin(stdin)}")
+    proc = Popen(
+        cmd, universal_newlines=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, cwd=cwd
+    )
+    stdout, stderr = proc.communicate(stdin)
+    if "segmentation fault occurred" in stderr:
+        raise SegfaultException(
+            "Multiwfn segfaulted! Multiwfn seems to have problems "
+            "with systems >= 1000 basis functions. Maybe your system is too big."
+        )
+    proc.terminate()
+    return stdout, stderr
+
+
+def make_cdd(inp_fn, state, log_fn, cwd=None, keep=False, quality=2, prefix="S"):
+    """Create CDD cube in cwd.
+
+    Parameters
+    ----------
+    inp_fn : str
+        Filename of a .molden/.fchk file.
+    state : int
+        CDD cubes will be generated up to this state.
+    log_fn : str
+        Filename of the .log file.
+    cwd : str or Path, optional
+        If a different cwd should be used.
+    keep : bool
+        Wether to keep electron.cub and hole.cub, default is False.
+    quality : int
+        Quality of the cube. (1=low, 2=medium, 3=high).
+    """
+
+    assert quality in (1, 2, 3)
+
+    msg = (
+        f"Requested CDD calculation from Multiwfn for state {state} using "
+        f"{inp_fn} and {log_fn}"
+    )
+    log(msg)
+
+    stdin = f"""18
+    1
+    {log_fn}
+    {state}
+    1
+    {quality}
+    10
+    1
+    11
+    1
+    15
+    0
+    0
+    0
+    q
+    """
+    stdout, stderr = call_mwfn(inp_fn, stdin, cwd=cwd)
+
+    if cwd is None:
+        cwd = "."
+    cwd = Path(cwd)
+
+    cube_fns = ("electron.cub", "hole.cub", "CDD.cub")
+    if not keep:
+        # always keep CDD.cub
+        for fn in cube_fns[:2]:
+            full_path = cwd / fn
+            os.remove(full_path)
+    # Rename cubes according to the current state
+    new_paths = list()
+    for fn in cube_fns:
+        old_path = cwd / fn
+        root, ext = os.path.splitext(fn)
+        new_path = cwd / f"{prefix}_{state:03d}_{root}{ext}"
+        try:
+            shutil.copy(old_path, new_path)
+            os.remove(old_path)
+            new_paths.append(new_path)
+        except FileNotFoundError:
+            pass
+    return new_paths
+
+
+def get_mwfn_exc_str(energies, Xa, Ya=None, Xb=None, Yb=None, thresh=1e-3):
+    """Write plain text input for MWFN according to 3.21.
+
+    As of version 3.8 MWFN does not seem to handle this file when spin
+    labels are present, even though it is given as an example in the manual.
+    """
+
+    # We only use the spin label for unrestricted calculations, where Xb is present.
+    spin_a = "A" if (Xb is not None) else ""
+    assert len(energies) == (
+        len(Xa) + 1
+    ), "Found too few energies. Is the GS energy missing?"
+    exc_energies = (energies[1:] - energies[0]) * AU2EV
+    # states, occ, virt
+    nstates, occ_mos, _ = Xa.shape
+
+    exc_str = ""
+    mult = 1
+    log(f"Using dummy multiplicity={mult} in get_mwfn_exc_str")
+
+    def set_default(mat):
+        if mat is None:
+            mat = [None] * nstates
+        return mat
+
+    Ya = set_default(Ya)
+    Xb = set_default(Xb)
+    Yb = set_default(Yb)
+
+    def get_exc_lines(ci_coeffs, arrow, spin=""):
+        exc_lines = list()
+        for (occ, virt), coeff in np.ndenumerate(ci_coeffs):
+            if abs(coeff) < thresh:
+                continue
+            occ_mo = occ + 1
+            virt_mo = occ_mos + 1 + virt
+            exc_line = f"{occ_mo:>8d}{spin} {arrow} {virt_mo}{spin}       {coeff: .5f}"
+            exc_lines.append(exc_line)
+        return exc_lines
+
+    for root_, (xa, ya, xb, yb, exc_en) in enumerate(
+        zip(Xa, Ya, Xb, Yb, exc_energies), 1
+    ):
+        exc_str += f"Excited State {root_} {mult} {exc_en:.4f}\n"
+        # Excitations (X vector)
+        exc_lines = get_exc_lines(xa, "->", spin_a)
+        # De-Excitations (Y vector), if present
+        if ya is not None:
+            exc_lines += get_exc_lines(ya, "<-", spin_a)
+        if xb is not None:
+            exc_lines += get_exc_lines(xb, "->", "B")
+        if yb is not None:
+            exc_lines += get_exc_lines(yb, "<-", "B")
+        exc_str += "\n".join(exc_lines)
+        exc_str += "\n\n"
+    return exc_str

pysisyphus/wrapper/packmol.py

@@ -0,0 +1,71 @@
+import subprocess
+import tempfile
+
+from jinja2 import Template
+
+from pysisyphus.config import get_cmd
+
+
+TPL = """tolerance {{ tolerance }}
+output {{ output_fn }}
+filetype pdb
+
+{% if solute_fn %}
+# Solute
+structure {{ solute_fn }}
+ number {{ solute_num }}
+ {% if solute_num == 1 %}
+     fixed 0. 0. 0. 0. 0. 0.
+     centerofmass
+ {% endif %}
+end structure
+{% endif %}
+
+# Solvent
+structure {{ solvent_fn }}
+ number {{ solvent_num }}
+ inside sphere 0. 0. 0. {{ sphere_radius }}
+end structure
+"""
+
+
+def make_input(
+    output_fn,
+    solvent_fn,
+    solvent_num,
+    sphere_radius,
+    solute_fn=None,
+    solute_num=None,
+    tolerance=2.0,
+):
+    tpl = Template(TPL)
+    rendered = tpl.render(
+        tolerance=tolerance,
+        output_fn=output_fn,
+        solute_fn=solute_fn,
+        solute_num=solute_num,
+        solvent_fn=solvent_fn,
+        solvent_num=solvent_num,
+        sphere_radius=sphere_radius,
+    )
+    return rendered
+
+
+def call_packmol(inp):
+    packmol_cmd = get_cmd("packmol")
+
+    with tempfile.NamedTemporaryFile(mode="w", dir=".") as tmp:
+        tmp.write(inp)
+        tmp.flush()
+        tmp.seek(0)
+        with open(tmp.name) as stdin_f:
+            proc = subprocess.run(
+                [packmol_cmd],
+                stdin=stdin_f,
+                stdout=subprocess.PIPE,
+                text=True,
+            )
+    # out = proc.stdout
+    # err = proc.stderr
+
+    return proc

pysisyphus/xyzloader.py

@@ -0,0 +1,168 @@
+import re
+
+import numpy as np
+
+from pysisyphus.constants import BOHR2ANG
+
+
+def make_xyz_str(atoms, coords, comment=""):
+    assert len(atoms) == len(coords)
+    atoms = [a.capitalize() for a in atoms]
+
+    coord_fmt = "{: 03.8f}"
+    line_fmt = "{:>3s} " + " ".join(
+        [
+            coord_fmt,
+        ]
+        * 3
+    )
+
+    body = [line_fmt.format(a, *xyz) for a, xyz in zip(atoms, coords)]
+    body = "\n".join(body)
+
+    return f"{len(atoms)}\n{comment}\n{body}"
+
+
+def make_trj_str(atoms, coords_list, comments=None):
+    if comments is None:
+        comments = ["" for _ in coords_list]
+    xyz_strings = [
+        make_xyz_str(atoms, coords, comment)
+        for coords, comment in zip(coords_list, comments)
+    ]
+    return "\n".join(xyz_strings)
+
+
+def coords_to_trj(trj_fn, atoms, coords_list, comments=None):
+    coords = np.array(coords_list)
+    coords = coords.reshape(-1, len(atoms), 3) * BOHR2ANG
+    trj_str = make_trj_str(atoms, coords, comments)
+    with open(trj_fn, "w") as handle:
+        handle.write(trj_str)
+    return trj_fn
+
+
+def make_trj_str_from_geoms(geoms, comments=None, energy_comments=False):
+    atoms = geoms[0].atoms
+    coords_list = [geom.coords3d * BOHR2ANG for geom in geoms]
+    if energy_comments and comments is None:
+        comments = [str(geom._energy) for geom in geoms]
+    elif comments is not None:
+        assert len(comments) == len(geoms)
+
+    return make_trj_str(atoms, coords_list, comments)
+
+
+def write_geoms_to_trj(geoms, fn, comments=None):
+    trj_str = make_trj_str_from_geoms(geoms, comments)
+    with open(fn, "w") as handle:
+        handle.write(trj_str)
+
+
+def split_xyz_str(xyz_str):
+    """Example:
+
+    xyz:
+     1
+
+     X -1.2 1.4 0.0
+     1
+
+     X 2.0 4.0 0.0
+
+    """
+    float_ = r"([\+\d\-\.]+)"
+    header_re = re.compile(r"(\d+)")
+    coord_re = re.compile(fr"[a-zA-Z]+\s+{float_}\s+{float_}\s+{float_}")
+
+    lines = [l.strip() for l in xyz_str.strip().split("\n")]
+
+    lines_remaining = len(lines)
+    cur_line = 0
+    valid_xyz_strs = list()
+    while lines_remaining:
+        header_mobj = header_re.match(lines[cur_line])
+        expect_lines = int(header_mobj[1])
+        slice_ = slice(
+            cur_line + 2, cur_line + 2 + expect_lines
+        )  # lgtm [py/hash-unhashable-value]
+        check_lines = lines[slice_]
+        assert len(check_lines) == expect_lines
+        assert all([coord_re.match(line.strip()) for line in check_lines])
+
+        valid_xyz_strs.append(str(expect_lines) + "\n\n" + "\n".join(check_lines))
+
+        lines_read = expect_lines + 2
+        lines_remaining -= lines_read
+        cur_line += lines_read
+    atoms_coords = [parse_xyz_str(_, with_comment=False) for _ in valid_xyz_strs]
+    return atoms_coords
+
+
+def parse_xyz_str(xyz_str, with_comment):
+    """Parse a xyz string.
+
+    Paramters
+    ---------
+    xyz_str : str
+        The contents of a .xyz file.
+    with_comment : bool
+        Return comment line if True.
+
+    Returns
+    -------
+    atoms : list
+        List of length N (N = number of atoms) holding the
+        element symbols.
+    coords: np.array
+        An array of shape (N, 3) holding the xyz coordinates.
+    comment_line : str, optional
+        Comment line if with_comment argument was True.
+    """
+
+    xyz_lines = xyz_str.strip().split("\n")
+    comment_line = xyz_lines[1]
+
+    # Only consider the first four items on a line
+    atom_num = int(xyz_lines[0])
+    atoms_present = len(xyz_lines) - 2
+    assert len(xyz_lines) == atom_num + 2, \
+        f"Expected {atom_num} atoms, but found only {atoms_present}!"
+    atoms_coords = [
+        line.strip().split()[:4] for line in xyz_str.strip().split("\n")[2:]
+    ]
+    atoms, coords = zip(*[(a, c) for a, *c in atoms_coords])
+    coords = np.array(coords, dtype=float)
+    if with_comment:
+        return atoms, coords, comment_line
+    else:
+        return atoms, coords
+
+
+def parse_xyz_file(xyz_fn, with_comment=False):
+    with open(xyz_fn) as handle:
+        xyz_str = handle.read()
+
+    return parse_xyz_str(xyz_str, with_comment)
+
+
+def parse_trj_file(trj_fn, with_comments=False):
+    with open(trj_fn) as handle:
+        trj_str = handle.read()
+
+    return parse_trj_str(trj_str, with_comments)
+
+
+def parse_trj_str(trj_str, with_comments=False):
+    trj_lines = trj_str.strip().split("\n")
+    number_of_atoms = int(trj_lines[0].strip())
+    xyz_lines = number_of_atoms + 2
+    # Split the trj file in evenly sized strings
+    xyz_strs = [
+        "\n".join(trj_lines[i : i + xyz_lines])
+        for i in range(0, len(trj_lines), xyz_lines)
+    ]
+    xyzs = [parse_xyz_str(xyz_str, with_comments) for xyz_str in xyz_strs]
+
+    assert len(xyzs) == (len(trj_lines) / xyz_lines)
+    return xyzs

pysisyphus/yaml_mods.py

@@ -0,0 +1,45 @@
+from pysisyphus.constants import AU2KJPERMOL, AU2KCALPERMOL, AU2EV, ANG2BOHR, BOHR2M
+
+import numpy as np
+import yaml
+from yaml.constructor import ConstructorError
+
+_UNIT_MAP = {
+    # Energies are converted to Hartree (E_h)
+    "Eh": 1,
+    "kJpermol": 1 / AU2KJPERMOL,  # kJ mol⁻¹
+    "kcalpermol": 1 / AU2KCALPERMOL,  # kcal mol⁻¹
+    "eV": 1 / AU2EV,  # eV
+    # Times are converted to fs (1e-15 s)
+    "fs": 1,
+    "ps": 1e-3,
+    "ns": 1e-6,
+    # Lengths are converted to Bohr (a_0)
+    "a0": 1,
+    "angstrom": 1 / ANG2BOHR,
+    "nm": 1 / BOHR2M * 1e9,
+    "deg": np.pi / 180.0
+}
+_UNITS = list(_UNIT_MAP.keys())
+UNITS = _UNITS
+
+
+def get_constructor(unit):
+    conv = _UNIT_MAP[unit]
+
+    def constructor(loader, node):
+        try:
+            data = float(loader.construct_scalar(node)) * conv
+        except ConstructorError:
+            data = np.array(loader.construct_sequence(node), dtype=float) * conv
+        return data
+
+    return constructor
+
+
+def get_loader(units=_UNITS):
+    loader = yaml.SafeLoader
+    for unit in units:
+        tag = f"!{unit}"
+        loader.add_constructor(tag, get_constructor(unit))
+    return loader