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

pysisyphus/io/mol2.py

@@ -0,0 +1,146 @@
+import jinja2
+import pyparsing as pp
+import numpy as np
+
+from pysisyphus.constants import ANG2BOHR
+from pysisyphus.Geometry import Geometry
+from pysisyphus.helpers_pure import file_or_str
+
+
+@file_or_str(".mol2")
+def parse_mol2(text):
+    def get_line_word(*args):
+        return pp.Word(*args).setWhitespaceChars(" \t")
+
+    new_record = pp.CaselessLiteral("@<TRIPOS>")
+
+    # <TRIPOS>MOLECULE
+    molecule = (
+        pp.CaselessLiteral("@<TRIPOS>MOLECULE")
+        + pp.LineEnd()
+        # comment line/molecule name
+        + pp.OneOrMore(get_line_word(pp.printables)).set_results_name("mol_name")
+        + pp.common.integer.set_results_name("num_atoms")
+        + pp.Optional(pp.common.integer.set_results_name("num_bonds"))
+        + pp.Optional(pp.common.integer.set_results_name("num_subst"))
+        + pp.Optional(pp.common.integer.set_results_name("num_feat"))
+        + pp.Optional(pp.common.integer.set_results_name("num_sets"))
+        + pp.oneOf(
+            ("SMALL", "BIOPOLYMER", "PROTEIN", "NUCLEIC_ACID", "SACCHARIDE")
+        ).set_results_name("mol_type")
+        + pp.oneOf(
+            ("NO_CHARGES", "GASTEIGER", "MMFF94_CHARGES", "USER_CHARGES", "HUCKEL")
+        ).set_results_name("charge_type")
+        + pp.Optional(
+            ~new_record + pp.Word(pp.printables).set_results_name("status_bits")
+        )
+        # Only spaces may not be enough for mol comment
+        + pp.Optional(~new_record + pp.Word(pp.printables + " ")).set_results_name(
+            "mol_comment"
+        )
+    )
+
+    # <TRIPOS>ATOM
+    atom_data_line = pp.Group(
+        ~new_record
+        + pp.common.integer.set_results_name("atom_id")
+        + pp.Word(pp.alphanums).set_results_name("atom_name")
+        + pp.Group(pp.common.real + pp.common.real + pp.common.real).set_results_name(
+            "xyz"
+        )
+        + pp.Word(pp.printables).set_results_name("atom_type")
+        + pp.Optional(pp.common.integer.set_results_name("subst_id"))
+        + pp.Optional(pp.Word(pp.printables).set_results_name("subst_name"))
+        + pp.Optional(pp.common.real.set_results_name("charge"))
+        + pp.Optional(get_line_word(pp.printables).set_results_name("status_bit"))
+    )
+    atom = pp.CaselessLiteral("@<TRIPOS>ATOM") + pp.OneOrMore(
+        atom_data_line
+    ).set_results_name("atoms_xyzs")
+
+    # <TRIPOS>BOND
+    bond_data_line = pp.Group(
+        ~new_record
+        + pp.common.integer.set_results_name("bond_id")
+        + pp.common.integer.set_results_name("origin_atom_id")
+        + pp.common.integer.set_results_name("target_atom_id")
+        + pp.Word(pp.printables).set_results_name("bond_type")
+    )
+    bond = pp.CaselessLiteral("@<TRIPOS>BOND") + pp.OneOrMore(
+        bond_data_line
+    ).set_results_name("bond")
+
+    parser = molecule + atom + pp.Optional(bond)
+    parser.ignore(pp.helpers.python_style_comment)
+
+    result = parser.parseString(text)
+    return result
+
+
+@file_or_str(".mol2")
+def atoms_coords_from_mol2(text):
+    result = parse_mol2(text)
+    as_dict = result.asDict()
+
+    atoms = list()
+    coords = np.zeros((as_dict["num_atoms"], 3), dtype=float)
+    atoms_xyzs = as_dict["atoms_xyzs"]
+    for i, line in enumerate(atoms_xyzs):
+        assert i + 1 == line["atom_id"]
+        atom = line["atom_type"].split(".")[0]
+        atoms.append(atom)
+        coords[i] = line["xyz"]
+    assert len(atoms) == len(coords)
+
+    coords *= ANG2BOHR
+
+    return atoms, coords
+
+
+def geom_from_mol2(text, **kwargs):
+    atoms, coords = atoms_coords_from_mol2(text)
+    geom = Geometry(atoms, coords, **kwargs)
+    return geom
+
+
+MOL2_DICT_TPL = jinja2.Template(
+    """@<TRIPOS>MOLECULE
+{{ mol_name }}
+{{ num_atoms }} {{ num_bonds}} {{ num_subst }} {{ num_feat }} {{ num_sets }}
+{{ mol_type }}
+{{ charge_type }}
+
+@<TRIPOS>ATOM
+{%- for ax in atoms_xyzs %}
+{{ ax["atom_id"] }} {{ ax["atom_name"] }} {{ render_xyz(ax["xyz"])}} {{ ax["atom_type"] }}  {{ ax["subst_id"] }} {{ ax["subst_name"] }} {{ ax["charge"]}}
+{%- endfor %}
+@<TRIPOS>BOND
+{%- for bond in bonds %}
+ {{ bond["bond_id"] }} {{ bond["origin_atom_id"]}} {{ bond["target_atom_id"] }} {{ bond["bond_type"]}}
+{%- endfor %}
+
+"""
+)
+
+
+def render_xyz(xyz):
+    fmt = " >12.6f"
+    return " ".join(map(lambda _: f"{_:{fmt}}", xyz))
+
+
+def dict_to_mol2_string(as_dict):
+    d = as_dict
+    rendered = MOL2_DICT_TPL.render(
+        mol_name=d["mol_name"],
+        num_bonds=d["num_bonds"],
+        num_subst=d["num_subst"],
+        num_feat=d["num_feat"],
+        num_sets=d["num_sets"],
+        num_atoms=d["num_atoms"],
+        mol_type=d["mol_type"],
+        charge_type=d["charge_type"],
+        atoms_xyzs=d["atoms_xyzs"],
+        bonds=d["bond"],
+        render_xyz=render_xyz,
+    )
+    return rendered

pysisyphus/io/molden.py

@@ -0,0 +1,293 @@
+import re
+
+import numpy as np
+import pyparsing as pp
+
+from pysisyphus.elem_data import ATOMIC_NUMBERS
+from pysisyphus.Geometry import Geometry
+from pysisyphus.io.xyz import parse_xyz
+from pysisyphus.helpers_pure import file_or_str
+from pysisyphus.wavefunction import MoldenShells, Shell, Wavefunction
+from pysisyphus.wavefunction.helpers import BFType
+
+
+@file_or_str(".molden", ".input")
+def parse_molden_atoms_coords(molden_str):
+    _, geometries = re.split(r"\[GEOMETRIES\] \(XYZ\)", molden_str)
+    atoms_coords, comments = parse_xyz(geometries, with_comment=True)
+
+    return atoms_coords, comments
+
+
+def geoms_from_molden(fn, **kwargs):
+    atoms_coords, comments = parse_molden_atoms_coords(fn)
+    geoms = [
+        Geometry(atoms, coords.flatten(), comment=comment, **kwargs)
+        for (atoms, coords), comment in zip(atoms_coords, comments)
+    ]
+    return geoms
+
+
+def parse_mo(mo_lines):
+    # sym, ene_key, energy, spin_key, spin, occup_key, occup, *rest = mo_lines
+    sym, ene_line, spin_line, occup_line, *rest = mo_lines
+    ene_key, energy = ene_line.split("=")
+    spin_key, spin = spin_line.split("=")
+    occup_key, occup = occup_line.split("=")
+    assert (
+        (ene_key.strip() == "ene")
+        and (spin_key.strip() == "spin")
+        and (occup_key.strip() == "occup")
+    )
+    prev_ind = 0
+    coeffs = list()
+    for line in rest:
+        ind, coeff = line.split()
+        ind = int(ind)
+        assert ind == prev_ind + 1
+        prev_ind = ind
+        coeffs.append(coeff)
+    return {
+        "sym": sym.strip(),
+        "ene": float(energy),
+        "spin": spin.strip(),
+        "occup": float(occup),
+        "coeffs": np.array(coeffs),
+    }
+
+
+@file_or_str(".molden", ".input")
+def parse_molden(text, with_mos=True):
+    int_ = pp.common.integer
+    real = pp.common.real
+    sci_real = pp.common.sci_real
+
+    def get_section(name):
+        return pp.CaselessLiteral(f"[{name}]")
+
+    molden_format = get_section("Molden Format")
+    n_atoms = get_section("N_Atoms") + int_
+    atoms_header = get_section("Atoms")
+    title = get_section("Title") + pp.Optional(
+        pp.ZeroOrMore(~atoms_header + pp.Word(pp.printables))
+    )
+
+    alpha_re = re.compile("([a-zA-Z]+)")
+
+    def drop_number(toks):
+        """OpenMolcas writes atoms like H1, C2, ...
+        We don't want the number."""
+        return alpha_re.match(toks[0]).group(1)
+
+    # [Atoms]
+    # element_name number atomic_number x y z
+    unit = pp.one_of(("AU Angs (AU) (Angs)"), caseless=True)
+    atom_symbol = pp.Word(pp.alphanums).set_parse_action(drop_number)
+    xyz = pp.Group(sci_real + sci_real + sci_real)
+    atom_line = pp.Group(
+        atom_symbol.set_results_name("symbol")
+        + int_.set_results_name("number")
+        + int_.set_results_name("atomic_number")
+        + xyz.set_results_name("xyz")
+    )
+    atoms = (
+        atoms_header
+        + pp.Optional(unit).set_results_name("unit")
+        + pp.OneOrMore(atom_line).set_results_name("atoms")
+    )
+
+    # [Charge], written by OpenMOLCAS
+    charge = get_section("Charge")
+    charge_kind = pp.one_of(("(Mulliken)",), caseless=True)
+    charges = charge + charge_kind + pp.OneOrMore(sci_real)
+
+    def pgto_exps_coeffs(s, loc, toks):
+        data = toks.asList()
+        exps, coeffs = np.array(data, dtype=float).reshape(-1, 2).T
+        pr = pp.ParseResults.from_dict(
+            {
+                "exponents": exps,
+                "coeffs": coeffs,
+            }
+        )
+        # Somehow this function will result in exponents and coeffs being both
+        # stored in lists of length 1.
+        return pr
+
+    # [GTO]
+    ang_mom = pp.one_of("s p sp d f g h i", caseless=True)
+    pgto = sci_real + sci_real
+    shell = pp.Group(
+        ang_mom.set_results_name("ang_mom")
+        + int_.set_results_name("contr_depth")
+        # Usually 1.0, can be left out
+        + pp.Optional(real.set_whitespace_chars(" ").suppress() + pp.LineEnd())
+        + pp.OneOrMore(pgto).set_parse_action(pgto_exps_coeffs)
+    )
+    atom_gtos = pp.Group(
+        int_.set_results_name("number")  # Center
+        + pp.Optional(pp.Literal("0"))
+        + pp.OneOrMore(shell).set_results_name("shells")
+    )
+    gto = (
+        pp.CaselessLiteral("[GTO]")
+        + pp.Optional(unit)
+        + pp.Group(pp.OneOrMore(atom_gtos)).set_results_name("gto")
+    )
+
+    # [5D] [7F] [9G] etc.
+    ang_mom_flags = pp.ZeroOrMore(pp.one_of("[5D] [7F] [9G]", caseless=True))
+
+    # Pyparsing code to parse MOs ... slow. Regex-based code is much faster.
+    # [MO]
+    # sym_label = pp.Word(pp.printables)
+    # spin = pp.one_of("Alpha Beta", caseless=True)
+    # mo_coeff = pp.Suppress(int_) + real
+    # mo = pp.Group(
+    # pp.CaselessLiteral("Sym=").suppress()
+    # + sym_label.set_results_name("sym")
+    # + pp.CaselessLiteral("Ene=").suppress()
+    # + sci_real.set_results_name("ene")
+    # + pp.CaselessLiteral("Spin=").suppress()
+    # + spin.set_results_name("spin")
+    # + pp.CaselessLiteral("Occup=").suppress()
+    # + real.set_results_name("occup")
+    # + pp.Group(pp.OneOrMore(mo_coeff)).set_results_name("coeffs")
+    # )
+    # mos = pp.CaselessLiteral("[MO]") + pp.OneOrMore(mo).set_results_name("mos")
+    mos = pp.CaselessLiteral("[MO]") + pp.OneOrMore(
+        pp.Regex(r"[^\[]+")  # Match everything until the next [ is encountered
+    ).set_results_name("mos")
+
+    # Actual parser
+    parser = molden_format + pp.Each(
+        [
+            pp.Optional(expr)
+            for expr in (n_atoms, title, atoms, charges, gto, ang_mom_flags)
+        ]
+    )
+    if with_mos:
+        parser += mos
+
+    res = parser.parse_string(text)
+    as_dict = res.asDict()
+    if with_mos:
+        mos_raw = as_dict["mos"][0]
+
+        by_mo = [bm.strip().split("\n") for bm in mos_raw.lower().strip().split("sym=")]
+        assert by_mo[0] == [""], by_mo[0]
+        by_mo = by_mo[1:]
+
+        as_dict["mos"] = [parse_mo(mo_lines) for mo_lines in by_mo]
+    return as_dict
+
+
+def parse_molden_atoms(data):
+    atoms = list()
+    coords = list()
+    nuc_charges = list()
+    for atom in data["atoms"]:
+        atoms.append(atom["symbol"])
+        coords.extend(atom["xyz"])
+        Z = atom["atomic_number"]
+        nuc_charges.append(Z)
+    atoms = tuple(atoms)
+    coords = np.array(coords, dtype=float).flatten()
+    nuc_charges = np.array(nuc_charges, dtype=int)
+    return atoms, coords, nuc_charges
+
+
+@file_or_str(".molden", ".input")
+def shells_from_molden(text):
+    data = parse_molden(text, with_mos=False)
+
+    atoms, coords, _ = parse_molden_atoms(data)
+    atomic_numbers = [ATOMIC_NUMBERS[atom.lower()] for atom in atoms]
+    coords3d = coords.reshape(-1, 3)
+
+    _shells = list()
+    for atom_gtos, center, atomic_num in zip(data["gto"], coords3d, atomic_numbers):
+        center_ind = atom_gtos["number"] - 1
+        for shell in atom_gtos["shells"]:
+            L = shell["ang_mom"]
+            exps = shell["exponents"][0]
+            coeffs = shell["coeffs"][0]
+            shell = Shell(
+                L=L,
+                center=center,
+                coeffs=coeffs,
+                exps=exps,
+                center_ind=center_ind,
+                atomic_num=atomic_num,
+            )
+            _shells.append(shell)
+
+    shells = MoldenShells(_shells)
+    return shells
+
+
+@file_or_str(".molden", ".input")
+def wavefunction_from_molden(text, charge=None, shells_func=None, **wf_kwargs):
+    """Construct Wavefunction object from .molden file.
+
+    shells_func is used for ORCA, to modify the contraction coefficients.
+    """
+    data = parse_molden(text)
+    atoms, coords, nuc_charges = parse_molden_atoms(data)
+    nuc_charge = sum(nuc_charges)
+
+    spins = list()
+    occ_a = 0.0
+    occ_b = 0.0
+    Ca = list()
+    Cb = list()
+    for mo in data["mos"]:
+        spin = mo["spin"].lower()
+        occ = mo["occup"]
+        spins.append(spin)
+        coeffs = mo["coeffs"]
+        if spin == "alpha":
+            occ_a += occ
+            Ca.append(coeffs)
+        elif spin == "beta":
+            occ_b += occ
+            Cb.append(coeffs)
+        else:
+            raise Exception(f"Spin can only be 'alpha' or 'beta', but got '{spin}'!")
+    assert occ_a.is_integer
+    assert occ_b.is_integer
+    occ_a = int(occ_a)
+    occ_b = int(occ_b)
+
+    # MOs must be in columns
+    Ca = np.array(Ca, dtype=float).T
+    Cb = np.array(Cb, dtype=float).T
+    # Restricted calculation
+    if Cb.size == 0:
+        Cb = Ca.copy()
+        occ_a = occ_b = occ_a // 2
+    C = np.stack((Ca, Cb))
+
+    molden_charge = nuc_charge - (occ_a + occ_b)
+    if charge is None:
+        charge = molden_charge
+    # Multiplicity = (2S + 1), S = number of unpaired elecs. * 0.5
+    mult = (occ_a - occ_b) + 1
+    unrestricted = set(spins) == {"Alpha", "Beta"}
+
+    if shells_func is None:
+        shells_func = shells_from_molden
+    shells = shells_func(text)
+
+    return Wavefunction(
+        atoms=atoms,
+        coords=coords,
+        charge=charge,
+        mult=mult,
+        unrestricted=unrestricted,
+        occ=(occ_a, occ_b),
+        C=C,
+        bf_type=BFType.PURE_SPHERICAL,
+        shells=shells,
+        **wf_kwargs,
+    )

pysisyphus/io/orca.py

@@ -0,0 +1,189 @@
+# [1] 10.1016/j.comptc.2014.10.002
+#     JANPA: An open source cross-platform implementation of the
+#     Natural Population Analysis on the Java platform
+#     Nikolaienko, Bulavin, Hovorun, 2014
+
+import json
+
+import numpy as np
+from scipy.special import gamma
+
+from pysisyphus.helpers_pure import file_or_str
+from pysisyphus.io import molden
+from pysisyphus.wavefunction import (
+    get_l,
+    Shell,
+    ORCAShells,
+    ORCAMoldenShells,
+    Wavefunction,
+)
+from pysisyphus.wavefunction.helpers import BFType
+
+
+@file_or_str(".json")
+def shells_from_json(text):
+    data = json.loads(text)
+    atoms = data["Molecule"]["Atoms"]
+
+    _shells = list()
+    for atom in atoms:
+        center = np.array(atom["Coords"])
+        center_ind = atom["Idx"]
+        bfs = atom["BasisFunctions"]
+        atomic_num = atom["ElementNumber"]
+        for bf in bfs:
+            exps = np.array(bf["Exponents"])
+            coeffs = np.array(bf["Coefficients"])
+            L = get_l(bf["Shell"])
+            shell = Shell(
+                L=L,
+                center=center,
+                coeffs=coeffs,
+                exps=exps,
+                center_ind=center_ind,
+                atomic_num=atomic_num,
+            )
+            _shells.append(shell)
+    shells = ORCAShells(_shells)
+    return shells
+
+
+@file_or_str(".json")
+def wavefunction_from_json(text):
+    data = json.loads(text)
+    mol = data["Molecule"]
+
+    charge = mol["Charge"]
+    mult = mol["Multiplicity"]
+    atoms = list()
+    coords = list()
+    for atom in mol["Atoms"]:
+        atom_label = atom["ElementLabel"]
+        atom_coords = atom["Coords"]
+        atoms.append(atom_label)
+        coords.append(atom_coords)
+
+    unrestricted = (mol["HFTyp"] == "UHF") or (mult != 1)
+    mos = mol["MolecularOrbitals"]["MOs"]
+    if unrestricted:
+        mo_num = len(mos)
+        assert mo_num % 2 == 0
+        a_num = mo_num // 2
+        mos_a = mos[:a_num]
+        mos_b = mos[a_num:]
+    else:  # restricted
+        mos_a = mos
+        mos_b = list()
+
+    def get_occ_and_mo_coeffs(mos):
+        mo_coeffs = list()
+        occ = 0
+        for mo in mos:
+            _occ = mo["Occupancy"]
+            if (_occ % 1) != 0.0:
+                raise Exception("Fractional occupations are not handled!")
+            occ += int(_occ)
+
+            mo_coeffs.append(mo["MOCoefficients"])
+        # MOs must be in columns
+        mo_coeffs = np.array(mo_coeffs).T
+        return occ, mo_coeffs
+
+    occ_a, Ca = get_occ_and_mo_coeffs(mos_a)
+    occ_b, Cb = get_occ_and_mo_coeffs(mos_b)
+
+    # Restricted calculation
+    if Cb.size == 0:
+        Cb = Ca.copy()
+        occ_a = occ_b = occ_a // 2
+    C = np.stack((Ca, Cb))
+
+    shells = shells_from_json(text)
+
+    return Wavefunction(
+        atoms=atoms,
+        coords=coords,
+        charge=charge,
+        mult=mult,
+        unrestricted=unrestricted,
+        occ=(occ_a, occ_b),
+        C=C,
+        bf_type=BFType.PURE_SPHERICAL,
+        shells=shells,
+    )
+
+
+def radial_integral(l, exponent):
+    """
+    Integrates
+        (r r**l * exp(-exponent * r**2))**2 dr from r=0 to r=oo
+    as described in the SI of the JANPA paper [1] (see top of page 8,
+    second integral in the square root.
+
+    In my opinion, the integrals lacks a factor 'r'. Below, some sympy code
+    can be found to solve this integral (including 1*r).
+
+    import sympy as sym
+    r, z = sym.symbols("r z", positive=True)
+    l = sym.symbols("l", integer=True, positive=True)
+    sym.integrate((r * r**l * sym.exp(-z*r**2))**2, (r, 0, sym.oo))
+
+    The 'solved' integral on page 8 is correct again.
+
+     ∞
+     ⌠
+     ⎮              2
+     ⎮  2  2⋅l  -2⋅r ⋅z
+     ⎮ r ⋅r   ⋅ℯ        dr = (2*z)**(-l - 1/2)*gamma(l + 3/2)/(4*z)
+     ⌡
+     0
+    """
+    return (2 * exponent) ** (-l - 1 / 2) * gamma(l + 3 / 2) / (4 * exponent)
+
+
+@file_or_str(".molden", ".input")
+def shells_from_molden(text):
+    molden_shells = molden.shells_from_molden(text)
+
+    dividers = {
+        0: 1,
+        1: 1,
+        2: 3,
+        3: 15,
+        4: 35,
+    }
+
+    def fix_contr_coeffs(l, coeffs, exponents):
+        """Fix contraction coefficients. Based on equations found in the SI
+        of the JANPA paper [1]."""
+        l = get_l(l)
+        divider = dividers[l]
+        rad_ints = radial_integral(l, exponents)
+        norms2 = rad_ints * 4 * np.pi / (2 * l + 1) / divider
+        norms = np.sqrt(norms2)
+        normed_coeffs = coeffs * norms
+        return normed_coeffs
+
+    _shells = list()
+    for shell in molden_shells.shells:
+        L, center, _, exps, *_ = shell.as_tuple()
+        fixed_coeffs = fix_contr_coeffs(L, shell.coeffs_org, exps)
+        fixed_shell = Shell(
+            L=L,
+            center=center,
+            coeffs=fixed_coeffs,
+            exps=exps,
+            center_ind=shell.center_ind,
+            atomic_num=shell.atomic_num,
+        )
+        _shells.append(fixed_shell)
+    shells = ORCAMoldenShells(_shells)
+    return shells
+
+
+@file_or_str(".molden", ".input")
+def wavefunction_from_molden(text, charge=None, **wf_kwargs):
+    shells_func = shells_from_molden
+    return molden.wavefunction_from_molden(
+        text, charge=charge, shells_func=shells_func, **wf_kwargs
+    )