physikmdb 1.0.0__py3-none-win_amd64.whl

physikmdb-1.0.0.data/purelib/physikmdb/__init__.py

@@ -0,0 +1,66 @@
+"""Photoemission momentum maps and molecular orbitals from PhysikMDB.
+
+The same C physics kernels the PhysikMDB website runs, plus a client for the
+database behind it.
+
+    import physikmdb
+
+    db    = physikmdb.Database()
+    calc  = db.calculation(21)
+    image = calc.momentum_map("HOMO", photon_energy=21.2, k_max=3.0)
+
+`Calculation` downloads the basis and the coefficient rows it needs on first
+use and keeps them, so a loop over orbitals costs one small request each:
+
+    for name in ("HOMO", "HOMO-1", "HOMO-2"):
+        image = calc.momentum_map(name, photon_energy=21.2, k_max=3.0)
+
+Work offline by saving a calculation once and reopening it:
+
+    calc.save("naphthalene/")
+    calc = physikmdb.load("naphthalene/")
+
+Units are eV and Angstrom, matching the website's own controls. Everything
+below is Hartree and Bohr, as the kernels take them; `physikmdb.units` is the
+only place that converts. To skip the conversion entirely, call
+`physikmdb.kernels` with your own basis and coefficients.
+
+No compiler needed: a prebuilt kernel library ships for Linux, macOS and
+Windows, and is built from source only on a platform without one.
+
+Submodules:
+
+- `physikmdb.kernels`  the kernels as numpy functions, in atomic units
+- `physikmdb.binary`   read/write basis.bin and coefficients.bin
+- `physikmdb.units`    eV/Angstrom <-> Hartree/Bohr
+- `physikmdb.plot`     quick matplotlib views (needs `physikmdb[plot]`)
+"""
+
+from physikmdb import binary, kernels, units
+from physikmdb.binary import Basis
+from physikmdb.database import (
+    Calculation,
+    Database,
+    Orbital,
+    PhysikMDBError,
+    System,
+    load,
+)
+from physikmdb.units import ANGSTROM_TO_BOHR, HARTREE_TO_EV
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "ANGSTROM_TO_BOHR",
+    "HARTREE_TO_EV",
+    "Basis",
+    "Calculation",
+    "Database",
+    "Orbital",
+    "PhysikMDBError",
+    "System",
+    "binary",
+    "kernels",
+    "load",
+    "units",
+]

physikmdb-1.0.0.data/purelib/physikmdb/_library.py

@@ -0,0 +1,257 @@
+"""Loading the compiled physics kernels. Internal - use `physikmdb.kernels`.
+
+`load()` returns the shared library, trying in order:
+
+1. The prebuilt binary bundled in this platform's wheel
+   (`_vendor/prebuilt/libkernels.*`). Nearly every install takes this path and
+   never needs a compiler.
+2. Compiling the C sources in `_vendor/kernels/` with whatever C compiler is
+   on PATH - only when no prebuilt binary shipped for this platform, or the
+   bundled one will not load.
+
+The result is cached, so a script calling several kernels pays the cost once.
+"""
+
+import ctypes
+import platform
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+_VENDOR_DIR = Path(__file__).resolve().parent / "_vendor"
+KERNEL_SOURCE_DIR = _VENDOR_DIR / "kernels"
+
+# map_image.c is separate from momentum_map.c but part of the same library
+KERNEL_SOURCES = ("momentum_map.c", "map_image.c", "realspace.c", "momentumspace.c")
+
+_PREBUILT_EXTENSION = {"Linux": "so", "Darwin": "dylib", "Windows": "dll"}.get(
+    platform.system(), "so"
+)
+PREBUILT_PATH = _VENDOR_DIR / "prebuilt" / f"libkernels.{_PREBUILT_EXTENSION}"
+
+FLOAT_PTR = ctypes.POINTER(ctypes.c_float)
+INT_PTR = ctypes.POINTER(ctypes.c_int)
+
+
+class KernelBuildError(RuntimeError):
+    """Neither a bundled prebuilt library nor a from-source build was usable."""
+
+
+def _declare(library: ctypes.CDLL) -> ctypes.CDLL:
+    """Declare every entry point's argument types on a freshly loaded library.
+
+    ctypes does not check arity against the C signature, so a wrong list here
+    shifts every later argument and produces plausible nonsense rather than an
+    error. Keep these next to kernels.h.
+
+    Args:
+        library: the loaded shared library.
+
+    Returns:
+        The same library, with restype/argtypes set.
+    """
+    # The shell-major basis every kernel takes, in `physikmdb.binary`'s layout:
+    # Natoms, shells per atom, positions, then per shell l and primitive count,
+    # then the primitives themselves
+    basis_args = [
+        ctypes.c_int,  # Natoms
+        INT_PTR,  # Nshells per atom
+        FLOAT_PTR,
+        FLOAT_PTR,
+        FLOAT_PTR,  # Rx, Ry, Rz
+        INT_PTR,
+        INT_PTR,  # shell_l, shell_Nprim
+        FLOAT_PTR,
+        FLOAT_PTR,  # exponents, contractions
+    ]
+
+    signatures = {
+        "normalisation": [ctypes.c_int, FLOAT_PTR],
+        "symmetrisation": [ctypes.c_int, ctypes.c_int, FLOAT_PTR],
+        "polarisation_factor": [
+            ctypes.c_float,  # E_kin
+            ctypes.c_float,  # k0
+            ctypes.c_float,  # dk
+            ctypes.c_int,  # Nk
+            ctypes.c_float,  # polar
+            ctypes.c_float,  # azimuth
+            ctypes.c_int,  # polarisation
+            ctypes.c_float,  # s_share
+            ctypes.c_int,  # handedness
+            ctypes.c_float,  # gamma
+            FLOAT_PTR,
+        ],
+        "momentum_map": [
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_int,  # E_kin, k0, dk, Nk
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,  # phi, theta, psi
+            *basis_args,
+            FLOAT_PTR,
+            FLOAT_PTR,  # coefficients, out
+        ],
+        "momentum_map_sum": [
+            ctypes.c_int,
+            FLOAT_PTR,
+            FLOAT_PTR,
+            FLOAT_PTR,  # Norbitals, E_kin, weights, rows
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_int,  # k0, dk, Nk
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,  # phi, theta, psi
+            ctypes.c_int,
+            ctypes.c_int,  # substrate, apply_polarisation
+            ctypes.c_float,
+            ctypes.c_float,  # polar, azimuth
+            ctypes.c_int,
+            ctypes.c_float,
+            ctypes.c_int,  # polarisation, s_share, handedness
+            FLOAT_PTR,  # gamma (per orbital)
+            *basis_args,
+            FLOAT_PTR,  # out
+        ],
+        "scalar_field": [
+            ctypes.c_int,  # N
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,  # x0, y0, z0
+            ctypes.c_float,  # spacing
+            *basis_args,
+            FLOAT_PTR,
+            FLOAT_PTR,  # coefficients, field
+        ],
+        "charge_density_sum": [
+            ctypes.c_int,  # N
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_float,  # x0, y0, z0
+            ctypes.c_float,  # spacing
+            ctypes.c_int,
+            FLOAT_PTR,
+            FLOAT_PTR,  # Norbitals, weights, rows
+            *basis_args,
+            FLOAT_PTR,  # out
+        ],
+        "momentum_density": [
+            ctypes.c_int,
+            ctypes.c_float,
+            ctypes.c_float,  # N, k0, dk
+            *basis_args,
+            FLOAT_PTR,
+            FLOAT_PTR,  # coefficients, field
+        ],
+        "momentum_density_sum": [
+            ctypes.c_int,
+            ctypes.c_float,
+            ctypes.c_float,  # N, k0, dk
+            ctypes.c_int,
+            FLOAT_PTR,
+            FLOAT_PTR,  # Norbitals, weights, rows
+            *basis_args,
+            FLOAT_PTR,  # out
+        ],
+    }
+
+    for name, argtypes in signatures.items():
+        entry = getattr(library, name)
+        entry.restype = None
+        entry.argtypes = argtypes
+
+    return library
+
+
+def build(
+    source_dir: Path | None = None,
+    library_path: Path | None = None,
+    extra_flags=(),
+) -> ctypes.CDLL:
+    """Compile the kernels into a shared library and load it.
+
+    This is the fallback path - see the module docstring. Most installs never
+    call this; it only runs when no prebuilt binary shipped for the current
+    platform, or the bundled one failed to load.
+
+    Args:
+        source_dir: directory holding the .c and .h files; defaults to the
+            vendored copy in this package.
+        library_path: where to write the library; defaults to a temporary
+            file that lives as long as the process.
+        extra_flags: extra compiler flags, e.g. `["-fopenmp"]`.
+
+    Returns:
+        The loaded library, with every entry point declared.
+
+    Raises:
+        KernelBuildError: if no C compiler is on PATH, or the build fails.
+    """
+    source_dir = Path(source_dir) if source_dir is not None else KERNEL_SOURCE_DIR
+    if library_path is None:
+        library_path = Path(tempfile.mkdtemp(prefix="physikmdb-kernels-")) / "libkernels.so"
+
+    compiler = shutil.which("cc") or shutil.which("clang") or shutil.which("gcc")
+    if compiler is None:
+        raise KernelBuildError(
+            "physikmdb has no prebuilt kernel library for this platform, and no C "
+            "compiler (cc, clang, gcc) is on PATH to build one from source. Install a C "
+            "compiler (e.g. Xcode Command Line Tools on macOS, build-essential on Linux, "
+            "or MSVC/MinGW on Windows) and try again."
+        )
+
+    result = subprocess.run(
+        [
+            compiler,
+            "-shared",
+            "-fPIC",
+            "-O2",
+            "-std=c99",
+            *extra_flags,
+            *[str(source_dir / name) for name in KERNEL_SOURCES],
+            "-lm",
+            "-o",
+            str(library_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        flags = " ".join(extra_flags)
+        raise KernelBuildError(
+            f"Failed to build the kernels{f' with {flags}' if flags else ''}:\n{result.stderr}"
+        )
+
+    return _declare(ctypes.CDLL(str(library_path)))
+
+
+_cached: ctypes.CDLL | None = None
+
+
+def load() -> ctypes.CDLL:
+    """The kernels, built once per process: prebuilt if this wheel bundled
+    one for the current platform, compiled from the vendored source otherwise.
+
+    Returns:
+        The loaded library.
+
+    Raises:
+        KernelBuildError: if there is no usable prebuilt binary and the
+            fallback build also fails.
+    """
+    global _cached
+    if _cached is not None:
+        return _cached
+
+    if PREBUILT_PATH.exists():
+        try:
+            _cached = _declare(ctypes.CDLL(str(PREBUILT_PATH)))
+            return _cached
+        except OSError:
+            pass  # bundled binary present but unusable (e.g. glibc too old) - fall through
+
+    _cached = build()
+    return _cached

physikmdb-1.0.0.data/purelib/physikmdb/_vendor/kernels/basis.h

@@ -0,0 +1,199 @@
+/* The LCAO-GTO basis set, and how one shell is evaluated.
+ *
+ * All three kernels take the same nine flat arrays straight out of basis.bin
+ * (see docs/binary-format.md) and walked them with their own ishell/iprim/
+ * icoeff running counters - three copies of the same bookkeeping, and the
+ * largest index-bug surface in the kernels. `Basis` bundles the arrays;
+ * `radial_*` are the two per-shell radial amplitudes, which were written out
+ * twice each.
+ *
+ * The layout is shell-major: atoms in order, each atom's shells in order, and
+ * per shell one angular momentum l, one list of shell_Nprim primitives, and
+ * 2l+1 consecutive MO coefficients (m in ORCA's order). So walking it means
+ * carrying three offsets at once - the shell, its first primitive, and its
+ * first coefficient.
+ *
+ * Everything here is Hartree atomic units: Bohr, Bohr^-1, Bohr^-2.
+ */
+#ifndef PHYSIKMDB_BASIS_H
+#define PHYSIKMDB_BASIS_H
+
+#include <math.h>
+
+/**
+ * One orbital's basis set. Borrows the caller's arrays - it copies nothing and
+ * owns nothing, so they must outlive it.
+ */
+typedef struct
+{
+    int Natoms;
+    int Nshells; // total over all atoms, i.e. sum(Nshells_per_atom)
+    int Nbasis;  // sum of 2l+1 over all shells; the length of one coefficient row
+
+    const int *Nshells_per_atom; // length Natoms
+    const float *Rx;             // atom x-positions [Bohr]; length Natoms
+    const float *Ry;             // atom y-positions [Bohr]; length Natoms
+    const float *Rz;             // atom z-positions [Bohr]; length Natoms
+    const int *shell_l;          // angular momentum per shell; length Nshells
+    const int *shell_Nprim;      // primitives per shell; length Nshells
+    const float *exponents;      // alpha_p [Bohr^-2]; length sum(shell_Nprim)
+    const float *contractions;   // c_p per primitive; length sum(shell_Nprim)
+} Basis;
+
+/**
+ * Bundle the flat arrays, counting the shell and basis-function totals the
+ * kernels each used to count for themselves.
+ *
+ * @param Natoms number of atoms
+ * @param Nshells_per_atom shells per atom; length Natoms
+ * @param Rx x-positions [Bohr]; length Natoms
+ * @param Ry y-positions [Bohr]; length Natoms
+ * @param Rz z-positions [Bohr]; length Natoms
+ * @param shell_l angular momentum per shell
+ * @param shell_Nprim primitives per shell
+ * @param exponents alpha_p [Bohr^-2]
+ * @param contractions c_p per primitive
+ * @return the bundle, with Nshells and Nbasis filled in
+ */
+static inline Basis basis_from_arrays(
+    int Natoms,
+    const int *Nshells_per_atom,
+    const float *Rx, const float *Ry, const float *Rz,
+    const int *shell_l, const int *shell_Nprim,
+    const float *exponents, const float *contractions)
+{
+    Basis basis;
+    basis.Natoms = Natoms;
+    basis.Nshells_per_atom = Nshells_per_atom;
+    basis.Rx = Rx;
+    basis.Ry = Ry;
+    basis.Rz = Rz;
+    basis.shell_l = shell_l;
+    basis.shell_Nprim = shell_Nprim;
+    basis.exponents = exponents;
+    basis.contractions = contractions;
+
+    basis.Nshells = 0;
+    for (int a = 0; a < Natoms; a++)
+    {
+        basis.Nshells += Nshells_per_atom[a];
+    }
+
+    basis.Nbasis = 0;
+    for (int s = 0; s < basis.Nshells; s++)
+    {
+        basis.Nbasis += 2 * shell_l[s] + 1;
+    }
+
+    return basis;
+}
+
+/* The two approximations, shared by all three kernels.
+ *
+ * Both are RELATIVE AMPLITUDES: a contribution below this fraction of what it
+ * would otherwise be is dropped. So smaller is always closer to exact, and
+ * always slower - which is the only reason they exist, since most of a large
+ * basis set contributes nothing to any single orbital.
+ *
+ * They used to differ per kernel, and the difference was not a considered
+ * accuracy budget so much as drift: the momentum map applied no cutoff at all,
+ * momentumspace.c cut primitives at exp(-30) = 9e-14, and realspace.c at
+ * exp(-7) = 9e-4 - which, because it turns that into a cutoff radius
+ * sqrt(eps/alpha), discarded up to 5% of a g shell's peak amplitude. Being
+ * consistent and being right both point the same way here.
+ *
+ * The primitive cutoff was written as the exponent argument rather than the
+ * amplitude, which made it read backwards: larger meant more exact. Stating
+ * the amplitude and deriving the exponent is the same arithmetic under a name
+ * that means what it says. */
+#define PRIMITIVE_EPSILON 1e-13f  // exp(-x) below this: primitive dropped
+#define COEFFICIENT_EPSILON 1e-6f // |c_mu| below this: whole shell dropped
+
+/**
+ * The exponent argument at which a primitive reaches PRIMITIVE_EPSILON.
+ *
+ * `alpha_p * r^2` in real space, `k^2 / (4 alpha_p)` in momentum space; both
+ * enter as exp(-x). Derived rather than written down twice, so the two cannot
+ * drift apart.
+ *
+ * @return the cutoff in x, i.e. -log(PRIMITIVE_EPSILON)
+ */
+static inline float primitive_exponent_cutoff(void)
+{
+    return -logf(PRIMITIVE_EPSILON);
+}
+
+/**
+ * The radial amplitude of one shell in real space: sum_p c_p exp(-alpha_p r^2).
+ *
+ * The 2l+1 members of a shell share it, so it is evaluated once per shell and
+ * per point, not once per basis function.
+ *
+ * @param basis the basis set
+ * @param shell shell index, 0 .. Nshells-1
+ * @param first_primitive index of the shell's first primitive in `exponents`
+ * @param r2 squared distance from the shell's atom [Bohr^2]
+ * @param cutoff skip primitives whose alpha_p * r^2 reaches this; normally
+ *   primitive_exponent_cutoff()
+ * @return the radial amplitude
+ */
+static inline float radial_realspace(const Basis *basis, int shell,
+                                     int first_primitive, float r2, float cutoff)
+{
+    float radial = 0.0f;
+
+    for (int p = 0; p < basis->shell_Nprim[shell]; p++)
+    {
+        float exponent = basis->exponents[first_primitive + p] * r2;
+
+        // Skip primitives that have underflowed to zero anyway
+        if (exponent < cutoff)
+        {
+            radial += basis->contractions[first_primitive + p] * expf(-exponent);
+        }
+    }
+
+    return radial;
+}
+
+/**
+ * The radial amplitude of one shell in momentum space:
+ * (k/2)^l * sum_p c_p alpha_p^(-l-3/2) exp(-k^2 / 4 alpha_p).
+ *
+ * This is the closed-form radial Fourier integral of a contracted Gaussian
+ * (see theory/main.tex); the momentum map evaluates it once per shell at the
+ * hemisphere's fixed |k|, the momentum density tabulates it over k.
+ *
+ * @param basis the basis set
+ * @param shell shell index, 0 .. Nshells-1
+ * @param first_primitive index of the shell's first primitive in `exponents`
+ * @param k momentum magnitude [Bohr^-1]
+ * @param cutoff skip primitives whose k^2 / (4 alpha_p) reaches this;
+ *   normally primitive_exponent_cutoff()
+ * @return the radial amplitude
+ */
+static inline float radial_momentum(const Basis *basis, int shell,
+                                    int first_primitive, float k, float cutoff)
+{
+    int l = basis->shell_l[shell];
+    float k2 = k * k;
+    float radial = 0.0f;
+
+    for (int p = 0; p < basis->shell_Nprim[shell]; p++)
+    {
+        float exponent = k2 / (4.0f * basis->exponents[first_primitive + p]);
+
+        if (exponent < cutoff)
+        {
+            radial += basis->contractions[first_primitive + p] *
+                      powf(basis->exponents[first_primitive + p], -l - 1.5f) *
+                      expf(-exponent);
+        }
+    }
+
+    // Factor independent of alpha_p and c_p. Dividing by 2^l is exact, so it
+    // does not matter that the two callers used to bracket this differently.
+    return radial * (powf(k, l) / powf(2.0f, l));
+}
+
+#endif

physikmdb-1.0.0.data/purelib/physikmdb/_vendor/kernels/harmonics.h

@@ -0,0 +1,103 @@
+/* Real cubic harmonics, shared by all three kernels.
+ *
+ * The table was copy-pasted three times before this header. Two copies (the
+ * momentum map and the momentum density) wrote the unit-vector form, valid
+ * only on |k| = 1; the real-space copy wrote the general solid-harmonic form
+ * with an explicit r^2. They are the same polynomials - the general form
+ * evaluated at r^2 = 1 is the unit-vector form - so one helper covers all
+ * three, with the k-space callers passing the literal 1.0f.
+ *
+ * That literal matters. Passing kx^2 + ky^2 + kz^2 instead would be "the same"
+ * only in exact arithmetic; in float it differs from 1 in the last bits and
+ * shifts every d, f and g harmonic. tests/test_wasm_physics.py has a
+ * regression test for exactly that mistake.
+ *
+ * Normalisations follow ORCA's real solid harmonic convention:
+ * https://www.faccts.de/docs/orca/6.1/manual/contents/utilitiesvisualization/orca_2json.html#definition-of-the-real-solid-harmonic-orbitals
+ */
+#ifndef PHYSIKMDB_HARMONICS_H
+#define PHYSIKMDB_HARMONICS_H
+
+#define C_S 0.28209479177387814 // 1/2 * sqrt(1 / pi)
+#define C_P 0.4886025119029199  // 1/2 * sqrt(3 / pi)
+#define C_D 1.0925484305920792  // 1/2 * sqrt(15 / pi)
+#define C_F 2.890611442640554   // 1/2 * sqrt(105 / pi)
+#define C_G 5.006685883593409   // 3/2 * sqrt(35 / pi)
+
+// First cubic-harmonic index of each shell (s, p, d, f, g); a shell of angular
+// momentum l occupies SHELL_START[l] .. SHELL_START[l] + 2l
+static const int SHELL_START[5] = {0, 1, 4, 9, 16};
+
+// The highest angular momentum the table covers (g)
+#define MAX_ANGULAR_MOMENTUM 4
+
+/**
+ * Evaluate the real cubic harmonics at one point, up to a given shell.
+ *
+ * Filled cumulatively: only entries belonging to shells the caller actually
+ * needs are written, since for one orbital most of a basis set contributes
+ * nothing. `max_l` is a parameter rather than something derived here because
+ * the three kernels each decide it differently - over every shell, over the
+ * significant shells only, or per atom.
+ *
+ * @param x [Bohr or Bohr^-1] first Cartesian component
+ * @param y [Bohr or Bohr^-1] second Cartesian component
+ * @param z [Bohr or Bohr^-1] third Cartesian component
+ * @param r2 [x^2 + y^2 + z^2] in the same units squared; pass the literal
+ *   1.0f when x/y/z are already a unit vector
+ * @param max_l highest angular momentum to fill (0 = s only, 4 = through g)
+ * @param H out; entries SHELL_START[0] .. SHELL_START[max_l] + 2*max_l written
+ */
+static inline void cubic_harmonics(float x, float y, float z, float r2,
+                                   int max_l, float H[25])
+{
+    H[0] = C_S; // s
+
+    if (max_l >= 1)
+    {
+        H[1] = C_P * z; // pz
+        H[2] = C_P * x; // px
+        H[3] = C_P * y; // py
+    }
+
+    if (max_l >= 2)
+    {
+        float x2 = x * x;
+        float y2 = y * y;
+        float z2 = z * z;
+
+        H[4] = C_D * 0.28867513459481287f * (3.0f * z2 - r2); // dz2
+        H[5] = C_D * x * z;                                   // dxz
+        H[6] = C_D * y * z;                                   // dyz
+        H[7] = C_D * 0.5f * (x2 - y2);                        // dx2-y2
+        H[8] = C_D * x * y;                                   // dxy
+
+        if (max_l >= 3)
+        {
+            H[9] = C_F * 0.12909944487358058f * z * (5.0f * z2 - 3.0f * r2); // fz3
+            H[10] = C_F * 0.15811388300841897f * x * (5.0f * z2 - r2);       // fxz2
+            H[11] = C_F * 0.15811388300841897f * y * (5.0f * z2 - r2);       // fyz2
+            H[12] = C_F * 0.5f * z * (x2 - y2);                              // fz(x2-y2)
+            H[13] = C_F * x * y * z;                                         // fxyz
+            H[14] = -C_F * 0.20412414523193148f * x * (x2 - 3.0f * y2);      // fx(x2-3y2)
+            H[15] = -C_F * 0.20412414523193148f * y * (3.0f * x2 - y2);      // fy(3x2-y2)
+        }
+
+        if (max_l >= 4)
+        {
+            float r4 = r2 * r2;
+
+            H[16] = C_G * 0.021128856368212916f * (35.0f * z2 * z2 - 30.0f * z2 * r2 + 3.0f * r4); // gz4
+            H[17] = C_G * 0.1336306209562122f * x * z * (7.0f * z2 - 3.0f * r2);                   // gxz3
+            H[18] = C_G * 0.1336306209562122f * y * z * (7.0f * z2 - 3.0f * r2);                   // gyz3
+            H[19] = C_G * 0.09449111825230681f * (x2 - y2) * (7.0f * z2 - r2);                     // gx2-y2
+            H[20] = C_G * 0.18898223650461363f * x * y * (7.0f * z2 - r2);                         // gxy
+            H[21] = -C_G * 0.3535533905932738f * x * z * (x2 - 3.0f * y2);                         // gx(x2-3y2)
+            H[22] = -C_G * 0.3535533905932738f * y * z * (3.0f * x2 - y2);                         // gy(3x2-y2)
+            H[23] = -C_G * 0.125f * (x2 * x2 - 6.0f * x2 * y2 + y2 * y2);                          // gx4-6x2y2+y4
+            H[24] = -C_G * 0.5f * x * y * (x2 - y2);                                               // gxy(x2-y2)
+        }
+    }
+}
+
+#endif