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

pysisyphus/wavefunction/helpers.py

@@ -0,0 +1,104 @@
+from typing import Literal, Union
+
+import numpy as np
+
+from enum import IntEnum
+
+
+L_MAP = {
+    "s": 0,
+    "p": 1,
+    "d": 2,
+    "f": 3,
+    "g": 4,
+    "h": 5,
+}
+L_MAP_INV = {key: L for L, key in L_MAP.items()}
+L_SIZE = {l: (l + 1) * (l + 2) // 2 for l in L_MAP.values()}
+
+Ls = Literal["s", "p", "d", "f", "g", "h"]
+L_Inp = Union[int, Ls]
+
+
+def get_l(l_inp: L_Inp) -> int:
+    """Convert shell label to angular moment quantum number l."""
+    try:
+        l = L_MAP[l_inp.lower()]
+    except (KeyError, AttributeError):
+        l = int(l_inp)
+    return l
+
+
+def get_shell_shape(*Ls):
+    return [L_SIZE[L] for L in Ls]
+
+
+class BFType(IntEnum):
+    CARTESIAN = 1
+    PURE_SPHERICAL = 2
+
+
+def canonical_order(L):
+    inds = list()
+    for i in range(L + 1):
+        l = L - i
+        for n in range(i + 1):
+            m = i - n
+            inds.append((l, m, n))
+    return inds
+
+
+def cca_order(l):
+    """Same as canonical_order()."""
+    inds = [
+        (l, 0, 0),
+    ]
+    a = l
+    b = c = 0
+    for _ in range(((l + 1) * (l + 2) // 2) - 1):
+        if c < l - a:
+            b -= 1
+            c += 1
+        else:
+            a -= 1
+            c = 0
+            b = l - a
+        inds.append((a, b, c))
+    return inds
+
+
+def cart2ang_moms(cart):
+    """Translate 'xxx' to (3, 0, 0) etc."""
+
+    ang_moms = np.zeros(3, dtype=int)
+    for char in cart:
+        # x: 120, y: 121, z: 122
+        ang_moms[ord(char.lower()) - 120] += 1
+    return tuple(ang_moms)
+
+
+def permut_for_order(cart_orders, pysis_order_func=cca_order):
+    """Create permutation matrices to reorder Cartesian integrals."""
+    Ps = dict()
+    for cart_order in cart_orders:
+        lengths = [len(_) for _ in cart_order]
+        l0 = lengths[0]
+        assert all([length == l0 for length in lengths])
+        other_order = [cart2ang_moms(_) for _ in cart_order]
+        pysis_order = pysis_order_func(l0)
+
+        num = len(pysis_order)
+        P = np.zeros((num, num), dtype=int)
+        for i, po in enumerate(other_order):
+            ind = pysis_order.index(po)
+            P[i, ind] = 1
+        Ps[l0] = P
+    return Ps
+
+
+def symmetric_orthogonalization(mat, S, thresh=1e-6):
+    w, v = np.linalg.eigh(mat.T.dot(S).dot(mat))
+    mask = w >= thresh
+    w_isqrt = np.sqrt(w[mask])
+    S_isqrt = (v[:, mask] / w_isqrt).dot(v[:, mask].T)
+    return mat.dot(S_isqrt)

pysisyphus/wavefunction/ints/boys.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python
+
+# [1] https://pubs.acs.org/doi/full/10.1021/acs.jctc.7b00788
+#     libreta: Computerized Optimization and Code Synthesis for Electron
+#     Repulsion Integral Evaluation
+#     Jun Zhang, 2018
+# [2] https://doi.org/10.1002/qua.560400604
+#     Two-electron repulsion integrals over Gaussian s functions
+#     Gill, Johnson, Pople, 1991
+
+import argparse
+import sys
+
+import numpy as np
+from scipy.special import factorial2
+
+from pysisyphus.config import CONFIG_DIR, L_MAX, L_AUX_MAX
+
+
+_BOYS_TABLE = np.load(
+    CONFIG_DIR / "wavefunction/ints/boys_table_N_64_xasym_27.1_step_0.01.npy"
+)
+_BOYS_N_MAX = (
+    max(L_MAX, L_AUX_MAX) * 3
+)  # Currently, there are at most 3center integrals
+_BOYS_X_ASYM = (
+    27.0  # Beyond this x the Boys function can be calculated via an analytical formula
+)
+_BOYS_ADD_POINTS = 10  # Go a bit beyond X_ASYM
+_BOYS_STEP = 0.01
+_BOYS_FACTOR = 100  # int(1 / _BOYS_FACTOR)
+_BOYS_XS = np.arange(0, _BOYS_X_ASYM + (_BOYS_ADD_POINTS + 1) * _BOYS_STEP, _BOYS_STEP)
+
+PI = np.pi
+FACT2 = np.array(
+    [factorial2(N, exact=True) for N in range(2 * _BOYS_N_MAX)], dtype=np.int64
+)
+
+
+def make_boys_table():
+    from scipy.integrate import quad
+
+    def boys(t, x, N):
+        return t ** (2 * N) * np.exp(-x * t**2)
+
+    xs = _BOYS_XS
+    boys_table = list()
+    for N in range(_BOYS_N_MAX + 1):
+        print(f"{N=}, calculating at {xs.size} points from {xs[0]} to {xs[-1]}")
+        vals = list()
+        max_abserr = 0.0
+        for i, x in enumerate(xs):
+            if i % 1000 == 0:
+                print(f"\t{i} values")
+            y, abserr = quad(boys, 0, 1, args=(x, N), epsabs=5e-13, epsrel=5e-13)
+            max_abserr = max(abserr, max_abserr)
+            vals.append(y)
+        print(f"\tN={N}, max(abserr)={max_abserr:.8e}")
+        boys_table.append(vals)
+    boys_table = np.array(boys_table)
+    fn = f"boys_table_N_{_BOYS_N_MAX}_xasym_{xs[-1]:.1f}_step_{_BOYS_STEP:.2f}.npy"
+    np.save(fn, boys_table)
+    return fn
+
+
+def neville(x, xs_table, table, step, points=5, factor=None):
+    """Slow, recursive implementation of Neville interpolation.
+
+    We multiply 'x' by int(1/step), so we only have to deal with integer arithmetic, to
+    determine the first entry from the table. 'x_closest' is always chosen in a way, that
+    'x' is contained in the 'xs' interval. Just to be sure, one can also suppy the 'factor'
+    to this method."""
+
+    if factor is None:
+        factor = int(1 / step)
+
+    # Determine closest x
+    x_closest = int(x * factor)
+    indices = np.arange(points) + x_closest
+    xs = xs_table[indices]
+    ys = table[indices]
+    p_ = {(i, i): ys[i] for i in range(points)}
+
+    def p(i, j):
+        key = (i, j)
+        if key not in p_:
+            xi, xj = xs[[i, j]]
+            p_[key] = ((x - xj) * p(i, j - 1) - (x - xi) * p(i + 1, j)) / (xi - xj)
+        return p_[key]
+
+    return p(0, points - 1)
+
+
+def neville_gen5(x, xs_table, table, step, factor=None):
+    """Code-generated Neville interpolation using 5 points."""
+
+    points = 5
+    if factor is None:
+        factor = int(1 / step)
+
+    # Determine closest x
+    x_closest = int(x * factor)
+    indices = np.arange(points) + x_closest
+    xs = xs_table[indices]
+    ys = table[indices]
+
+    x0 = -xs[4]
+    x1 = x - xs[0]
+    x2 = -xs[1]
+    x3 = x + x2
+    x4 = -xs[2]
+    x5 = x + x4
+    x6 = -xs[3]
+    x7 = x + x6
+    x8 = x + x0
+    x9 = (x5 * ys[3] - x7 * ys[2]) / (-x6 - xs[2])
+    x10 = (x3 * ys[2] - x5 * ys[1]) / (-x4 - xs[1])
+    x11 = (-x10 * x7 + x3 * x9) / (-x6 - xs[1])
+
+    return (
+        x1
+        * (
+            -x11 * x8
+            + x3
+            * (x5 * (x7 * ys[4] - x8 * ys[3]) / (-x0 - xs[3]) - x8 * x9)
+            / (-x0 - xs[2])
+        )
+        / (-x0 - xs[1])
+        - x8
+        * (
+            x1 * x11
+            - x7
+            * (x1 * x10 - x5 * (x1 * ys[1] - x3 * ys[0]) / (-x2 - xs[0]))
+            / (-x4 - xs[0])
+        )
+        / (-x6 - xs[0])
+    ) / (-x0 - xs[0])
+
+
+def neville_boys(N, x):
+    """Wrapper for Boys function from Neville-interpolation."""
+    return neville_gen5(
+        x, _BOYS_XS, _BOYS_TABLE[N], step=_BOYS_STEP, factor=_BOYS_FACTOR
+    )
+
+
+def factorial_boys(N, x):
+    """Boys function for (big) x > 27.0 as described in the SI of [1]. See also [2].
+                  ___________
+     -N - 1      ╱  -2⋅N - 1
+    2      ⋅√π⋅╲╱  x         ⋅(2⋅N - 1)!
+
+    """
+    return FACT2[max(0, 2 * N - 1)] / 2 ** (N + 1) * np.sqrt(PI / x ** (2 * N + 1))
+
+
+def boys(N, xs):
+    """Wrapper for Boys function calculation.
+
+    Supports scalar values and np.ndarray for 'xs'.
+    """
+
+    def func(N, x):
+        return neville_boys(N, x) if (x <= _BOYS_X_ASYM) else factorial_boys(N, x)
+
+    if isinstance(xs, np.ndarray):
+        boys_list = list()
+
+        with np.nditer(xs) as it:
+            for x in it:
+                boys_list.append(func(N, x))
+        boys_table = np.reshape(boys_list, xs.shape)
+        return boys_table
+    else:
+        return func(N, xs)
+
+
+def parse_args(args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--table", action="store_true")
+    return parser.parse_args(args)
+
+
+def run():
+    args = parse_args(sys.argv[1:])
+
+    if args.table:
+        fn = make_boys_table()
+        print(f"Wrote Boys table to '{fn}'.")
+
+
+if __name__ == "__main__":
+    run()

pysisyphus/wavefunction/ints/cart_gto3d.py

@@ -0,0 +1,176 @@
+"""
+Molecular integrals over Gaussian basis functions generated by sympleints.
+See https://github.com/eljost/sympleints for more information.
+
+sympleints version: 0.1.dev79+g63f1ef8.d20230515
+symppy version: 1.10.1
+
+sympleints was executed with the following arguments:
+	lmax = 4
+	lauxmax = 6
+	write = False
+	out_dir = devel_ints
+	keys = ['~2c2e', '~3c2e_sph']
+	sph = False
+	opt_basic = True
+	normalize = cgto
+"""
+
+import numpy
+
+
+def cart_gto3d_0(ax, da, A, R):
+    """3D Cartesian s-Gaussian shell.
+    Exponent ax, contraction coeff. da, centered at A, evaluated at R.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((1,), dtype=float)
+
+    # 1 item(s)
+    result[0] = numpy.sum(
+        da
+        * numpy.exp(-ax * ((A[0] - R[0]) ** 2 + (A[1] - R[1]) ** 2 + (A[2] - R[2]) ** 2))
+    )
+    return result
+
+
+def cart_gto3d_1(ax, da, A, R):
+    """3D Cartesian p-Gaussian shell.
+    Exponent ax, contraction coeff. da, centered at A, evaluated at R.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((3,), dtype=float)
+
+    x0 = A[0] - R[0]
+    x1 = A[1] - R[1]
+    x2 = A[2] - R[2]
+    x3 = da * numpy.exp(-ax * (x0**2 + x1**2 + x2**2))
+
+    # 3 item(s)
+    result[0] = numpy.sum(-x0 * x3)
+    result[1] = numpy.sum(-x1 * x3)
+    result[2] = numpy.sum(-x2 * x3)
+    return result
+
+
+def cart_gto3d_2(ax, da, A, R):
+    """3D Cartesian d-Gaussian shell.
+    Exponent ax, contraction coeff. da, centered at A, evaluated at R.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((6,), dtype=float)
+
+    x0 = A[0] - R[0]
+    x1 = x0**2
+    x2 = A[1] - R[1]
+    x3 = x2**2
+    x4 = A[2] - R[2]
+    x5 = x4**2
+    x6 = da * numpy.exp(-ax * (x1 + x3 + x5))
+    x7 = 0.5773502691896258 * x6
+    x8 = x0 * x6
+
+    # 6 item(s)
+    result[0] = numpy.sum(x1 * x7)
+    result[1] = numpy.sum(x2 * x8)
+    result[2] = numpy.sum(x4 * x8)
+    result[3] = numpy.sum(x3 * x7)
+    result[4] = numpy.sum(x2 * x4 * x6)
+    result[5] = numpy.sum(x5 * x7)
+    return result
+
+
+def cart_gto3d_3(ax, da, A, R):
+    """3D Cartesian f-Gaussian shell.
+    Exponent ax, contraction coeff. da, centered at A, evaluated at R.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((10,), dtype=float)
+
+    x0 = A[0] - R[0]
+    x1 = x0**2
+    x2 = A[1] - R[1]
+    x3 = x2**2
+    x4 = A[2] - R[2]
+    x5 = x4**2
+    x6 = da * numpy.exp(-ax * (x1 + x3 + x5))
+    x7 = 0.2581988897471611 * x6
+    x8 = x2 * x6
+    x9 = 0.5773502691896258
+    x10 = x1 * x9
+    x11 = x4 * x6
+    x12 = x3 * x9
+    x13 = x0 * x6
+    x14 = x5 * x9
+
+    # 10 item(s)
+    result[0] = numpy.sum(-(x0**3) * x7)
+    result[1] = numpy.sum(-x10 * x8)
+    result[2] = numpy.sum(-x10 * x11)
+    result[3] = numpy.sum(-x12 * x13)
+    result[4] = numpy.sum(-x0 * x4 * x8)
+    result[5] = numpy.sum(-x13 * x14)
+    result[6] = numpy.sum(-(x2**3) * x7)
+    result[7] = numpy.sum(-x11 * x12)
+    result[8] = numpy.sum(-x14 * x8)
+    result[9] = numpy.sum(-(x4**3) * x7)
+    return result
+
+
+def cart_gto3d_4(ax, da, A, R):
+    """3D Cartesian g-Gaussian shell.
+    Exponent ax, contraction coeff. da, centered at A, evaluated at R.
+
+    Generated code; DO NOT modify by hand!"""
+
+    result = numpy.zeros((15,), dtype=float)
+
+    x0 = -A[0] + R[0]
+    x1 = x0**2
+    x2 = -A[1] + R[1]
+    x3 = x2**2
+    x4 = -A[2] + R[2]
+    x5 = x4**2
+    x6 = da * numpy.exp(-ax * (x1 + x3 + x5))
+    x7 = 0.09759000729485332 * x6
+    x8 = 0.2581988897471611 * x6
+    x9 = x0**3 * x8
+    x10 = 0.3333333333333333 * x6
+    x11 = x1 * x10
+    x12 = 1.732050807568877
+    x13 = x12 * x4
+    x14 = x2**3
+    x15 = x0 * x8
+    x16 = x10 * x3
+    x17 = x4**3
+
+    # 15 item(s)
+    result[0] = numpy.sum(x0**4 * x7)
+    result[1] = numpy.sum(x2 * x9)
+    result[2] = numpy.sum(x4 * x9)
+    result[3] = numpy.sum(x11 * x3)
+    result[4] = numpy.sum(x11 * x13 * x2)
+    result[5] = numpy.sum(x11 * x5)
+    result[6] = numpy.sum(x14 * x15)
+    result[7] = numpy.sum(x0 * x13 * x16)
+    result[8] = numpy.sum(x0 * x10 * x12 * x2 * x5)
+    result[9] = numpy.sum(x15 * x17)
+    result[10] = numpy.sum(x2**4 * x7)
+    result[11] = numpy.sum(x14 * x4 * x8)
+    result[12] = numpy.sum(x16 * x5)
+    result[13] = numpy.sum(x17 * x2 * x8)
+    result[14] = numpy.sum(x4**4 * x7)
+    return result
+
+
+cart_gto3d = {
+    (0,): cart_gto3d_0,
+    (1,): cart_gto3d_1,
+    (2,): cart_gto3d_2,
+    (3,): cart_gto3d_3,
+    (4,): cart_gto3d_4,
+}