fullC/code/export_basis.py

"""Per-element basis set, ECP and effective nuclear charge, exported from the gbw with orca_2json.

Why from the gbw and not a library: the orbital basis is def2-TZVPD as ORCA 6 stores it, and
neither pyscf nor Basis Set Exchange carry the lanthanide entries. The export is exact for every
element and it is what makes S and H reconstructible from geometry alone.

Shell order: orca_2json lists an atom's shells in the order ORCA uses for its AO basis (verified on
XeCl4 against the exported orbital labels: def2-TZVP shells grouped by l, then the TZVPD
augmentation shells), so the per-element shell list here IS the AO layout of that element in
every matrix of the store. Spherical functions; m order p=(z,x,y), d=(z2,xz,yz,x2-y2,xy),
f=(0,+1,-1,+2,-2,+3,-3).

ECP-leak bug in orca_2json 6.0.0: an atom's ECP block is repeated onto the following atoms, so a
block is trusted only if ElementNumber - NuclearCharge > 0 and the block's N_core equals that
difference, and each ECP element is taken preferably from a molecule where it is the first
ECP-bearing atom. Blocks are cross-checked between two source molecules whenever possible.

    python export_basis.py --store $PSCRATCH/omol_100k --gbw-root $PSCRATCH/gbw_100k \
        --out $PSCRATCH/omol_100k/basis_def2-TZVPD_orca6.json
"""
from __future__ import annotations
import argparse, glob, json, os, shutil, struct, subprocess, sys, tempfile
import numpy as np
import zarr
import zstandard as zstd

ORCA = "/global/common/software/m5293/orca_6_0_0"
SYMBOLS = ("X H He Li Be B C N O F Ne Na Mg Al Si P S Cl Ar K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn "
           "Ga Ge As Se Br Kr Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Xe Cs Ba La Ce Pr "
           "Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg Tl Pb Bi Po At Rn").split()
ECP_Z_MIN = 37   # def2 ECPs start at Rb


def p1_shards(store):
    out = []
    for depth in ("*", "*/*/*"):
        out += glob.glob(os.path.join(store, "p1", depth, "*.zarr"))
    return sorted(set(out))


def candidates(store, gbw_root, per_element=3):
    """For each element, the smallest calculations containing it whose gbw is staged.
    For ECP elements prefer calculations where the element is the first ECP-bearing atom."""
    best = {}     # Z -> list of (rank, nbas, dataset, calc_id)
    for sp in p1_shards(store):
        g = zarr.open_group(sp, mode="r")
        ds = g.attrs["dataset"]
        ids = g.attrs["calc_id"]
        nbas = np.asarray(g["scalar_i"])[:, list(g.attrs["scalar_i_cols"]).index("nbas")]
        off = np.asarray(g["atom_offsets"])
        az = np.asarray(g["atom_z"])
        for i in range(len(ids)):
            zs = az[off[i]:off[i + 1]]
            heavy = zs >= ECP_Z_MIN
            first_heavy = int(zs[heavy][0]) if heavy.any() else None
            for Z in np.unique(zs):
                Z = int(Z)
                rank = 0 if (Z < ECP_Z_MIN or first_heavy == Z) else 1
                best.setdefault(Z, []).append((rank, int(nbas[i]), ds, ids[i]))
    out = {}
    for Z, lst in best.items():
        lst.sort()
        picked = []
        for rank, nb, ds, cid in lst:
            path = os.path.join(gbw_root, ds, cid + ".gbw.zstd0")
            if os.path.exists(path):
                picked.append((ds, cid, nb, rank, path))
            if len(picked) >= per_element:
                break
        out[Z] = picked
    return out


def gbw_base_path(raw):
    return raw[40:40 + 512].split(b"\x00", 1)[0].decode()


def run_orca_2json(gbw_zstd, workdir):
    raw = zstd.ZstdDecompressor().decompressobj().decompress(open(gbw_zstd, "rb").read())
    base = gbw_base_path(raw)
    if base:
        os.makedirs(os.path.dirname(base) or ".", exist_ok=True)
    name = os.path.join(workdir, "x")
    with open(name + ".gbw", "wb") as fh:
        fh.write(raw)
    with open(name + ".json.conf", "w") as fh:
        json.dump({"Basisset": True}, fh)
    env = dict(os.environ, LD_LIBRARY_PATH=ORCA + ":" + os.environ.get("LD_LIBRARY_PATH", ""))
    r = subprocess.run([os.path.join(ORCA, "orca_2json"), name + ".gbw", "-json"],
                       capture_output=True, text=True, env=env, cwd=workdir, timeout=600)
    if not os.path.exists(name + ".json"):
        raise RuntimeError(f"orca_2json failed: {r.stdout[-500:]} {r.stderr[-500:]}")
    d = json.load(open(name + ".json"))
    for f in glob.glob(name + "*"):
        os.remove(f)
    return d["Molecule"]["Atoms"]


def shell_key(basis):
    return json.dumps(basis, sort_keys=True)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--store", required=True)
    ap.add_argument("--gbw-root", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--per-element", type=int, default=2)
    args = ap.parse_args()

    cands = candidates(args.store, args.gbw_root, args.per_element)
    print(f"{len(cands)} elements present; "
          f"{sum(1 for v in cands.values() if not v)} without a staged gbw", flush=True)
    workdir = tempfile.mkdtemp(prefix="orca2json_", dir=os.environ.get("PSCRATCH", "/tmp"))
    cache = {}
    elements = {}
    problems = []
    for Z in sorted(cands):
        seen_basis, seen_ecp, zeff_seen, sources = [], [], set(), []
        for ds, cid, nb, rank, path in cands[Z]:
            if path not in cache:
                try:
                    cache[path] = run_orca_2json(path, workdir)
                except Exception as e:
                    problems.append(f"Z={Z} {cid}: {e}")
                    continue
            atoms = cache[path]
            prev_ecp_elem = None
            for a in atoms:
                zi = int(a["ElementNumber"])
                zeff = float(a["NuclearCharge"])
                has_ecp = zi - zeff > 0
                if zi == Z:
                    seen_basis.append(shell_key(a["Basis"]))
                    zeff_seen.add(zeff)
                    if has_ecp:
                        blk = a.get("ECPs")
                        ncore = int(round(zi - zeff))
                        # trust the block only when it cannot be a leak: consistent N_core and
                        # no different ECP element printed before this atom
                        if blk and int(blk.get("N_core", -1)) == ncore and prev_ecp_elem in (None, Z):
                            seen_ecp.append(shell_key(blk))
                    sources.append(cid)
                if has_ecp:
                    prev_ecp_elem = zi
        if not seen_basis:
            problems.append(f"Z={Z}: no basis exported")
            continue
        if len(set(seen_basis)) != 1:
            problems.append(f"Z={Z}: basis differs between occurrences ({len(set(seen_basis))} variants)")
        if len(zeff_seen) != 1:
            problems.append(f"Z={Z}: NuclearCharge differs between occurrences {sorted(zeff_seen)}")
        zeff = sorted(zeff_seen)[0]
        ecp = None
        if Z - zeff > 0:
            if not seen_ecp:
                problems.append(f"Z={Z}: ECP expected (Z_eff={zeff}) but no trustworthy block found")
            else:
                if len(set(seen_ecp)) != 1:
                    problems.append(f"Z={Z}: ECP block differs between sources")
                ecp = json.loads(seen_ecp[0])
        basis = json.loads(seen_basis[0])
        nao = sum({"s": 1, "p": 3, "d": 5, "f": 7, "g": 9, "h": 11}[s["Shell"]] for s in basis)
        elements[str(Z)] = {
            "symbol": SYMBOLS[Z], "Z": Z, "Z_eff": zeff, "n_core": int(round(Z - zeff)),
            "n_ao": nao, "shells": [s["Shell"] for s in basis], "basis": basis, "ecp": ecp,
            "n_sources": len(set(sources)), "n_ecp_blocks_checked": len(seen_ecp),
        }
        print(f"  Z={Z:3d} {SYMBOLS[Z]:2s} Z_eff={zeff:5.1f} shells={''.join(s['Shell'] for s in basis)} "
              f"nao={nao} ecp={'yes' if ecp else 'no'} sources={len(set(sources))}", flush=True)
    shutil.rmtree(workdir, ignore_errors=True)
    out = {
        "basis_name": "def2-TZVPD as stored by ORCA 6.0.0 (exported with orca_2json, Basisset only)",
        "conventions": {
            "functions": "spherical harmonics",
            "ao_order": "per atom, shells in the listed order; within a shell m order "
                        "p=(z,x,y) d=(z2,xz,yz,x2-y2,xy) f=(0,+1,-1,+2,-2,+3,-3)",
            "sign_vs_pyscf": "f(+3) and f(-3) carry the opposite sign to pyscf's real solid harmonics",
            "normalisation": "contraction coefficients exactly as orca_2json prints them",
            "ecp": "ECPs.potential: per l, ecp = [exponents, coefficients, powers]; N_core electrons replaced",
        },
        "elements": elements,
        "problems": problems,
    }
    with open(args.out, "w") as fh:
        json.dump(out, fh, indent=1)
    print(f"\nwrote {args.out}: {len(elements)} elements, {len(problems)} problems")
    for p in problems:
        print("  PROBLEM:", p)


if __name__ == "__main__":
    main()