Add files using upload-large-folder tool

fullC/b1_failures.tsv

@@ -0,0 +1,2 @@
+shard	calc_id	reason
+p2/ani1xbb/shard_t03_0005_00.zarr	ani1xbb__aniBB_022_377503_0_3	failed: fock_match

fullC/b1_summary.json

@@ -0,0 +1,25 @@
+{
+ "totals": {
+  "n": 99999,
+  "found": 99999,
+  "ok": 99998,
+  "fock_checked": 99954,
+  "bytes_cmo": 1521762062968,
+  "fail_gbw_found": 0,
+  "fail_nbas_match": 0,
+  "fail_nspin_match": 0,
+  "fail_nelec_match": 0,
+  "fail_spin_match": 0,
+  "fail_eps_checked": 0,
+  "fail_eps_match": 0,
+  "fail_occ_contiguous": 0,
+  "fail_fock_checked": 45,
+  "fail_fock_match": 1,
+  "fail_mo_ok": 1
+ },
+ "dtype": "f4",
+ "eps_err_max": 4.999999996257998e-07,
+ "fc_offdiag_max": 0.002244156607543126,
+ "wall_s": 1131.7759289741516,
+ "shard_failures": []
+}

fullC/code/build_index.py

@@ -0,0 +1,54 @@
+"""Write a flat per-calculation index for a store: one row per calculation with its shard, row
+number and the handful of columns most queries filter on. Lets a consumer find a calculation
+without opening every shard.
+
+    python build_index.py --store $PSCRATCH/omol_100k
+writes <store>/index.tsv
+"""
+from __future__ import annotations
+import argparse, glob, os
+import numpy as np
+import zarr
+
+
+def p2_shards(store):
+    out = []
+    for depth in ("*", "*/*/*"):
+        out += glob.glob(os.path.join(store, "p2", depth, "*.zarr"))
+    return sorted(set(out))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--store", required=True)
+    args = ap.parse_args()
+    shards = p2_shards(args.store)
+    out = os.path.join(args.store, "index.tsv")
+    n = 0
+    cols = ["calc_id", "dataset", "shard", "row", "n_atoms", "nbas", "nelec", "charge", "mult",
+            "is_uhf", "has_fock", "scf_converged", "mo_ok", "e_total", "conv_diiserr", "rel_path"]
+    with open(out, "w") as fh:
+        fh.write("\t".join(cols) + "\n")
+        for sp in shards:
+            g = zarr.open_group(sp, mode="r")
+            rel = os.path.relpath(sp, os.path.join(args.store, "p2"))
+            ids, rels, ds = g.attrs["calc_id"], g.attrs["rel_path"], g.attrs["dataset"]
+            si = np.asarray(g["scalar_i"]); ic = {k: j for j, k in enumerate(g.attrs["scalar_i_cols"])}
+            sf = np.asarray(g["scalar_f8"]); fc_ = {k: j for j, k in enumerate(g.attrs["scalar_f8_cols"])}
+            fl = np.asarray(g["flags"]); fc = {k: j for j, k in enumerate(g.attrs["flag_cols"])}
+            if g.attrs.get("has_mo"):
+                cf = np.asarray(g["mo_flags"])[:, g.attrs["mo_flag_cols"].index("mo_ok")]
+            else:
+                cf = np.full(len(ids), -1)
+            for i in range(len(ids)):
+                fh.write("\t".join(map(str, [
+                    ids[i], ds, rel, i, si[i, ic["n_atoms"]], si[i, ic["nbas"]], si[i, ic["nelec"]],
+                    si[i, ic["charge"]], si[i, ic["mult"]], int(fl[i, fc["is_uhf"]]),
+                    int(fl[i, fc["has_fock"]]), int(fl[i, fc["scf_converged"]]), int(cf[i]),
+                    f"{sf[i, fc_['e_total']]:.10f}", f"{sf[i, fc_['conv_diiserr']]:.3e}", rels[i]])) + "\n")
+                n += 1
+    print(f"wrote {out}: {n:,} rows from {len(shards)} shards")
+
+
+if __name__ == "__main__":
+    main()

fullC/code/check_overlap.py

@@ -0,0 +1,103 @@
+"""Verify ORCA's printed AO Fock matrix + pyscf overlap reproduces ORCA orbital energies.
+
+Established convention (ORCA 6.0, def2-TZVPD):
+  * AO order per atom = def2-TZVP shells grouped by l (s,p,d,f,g; basis order within l),
+    then the def2-TZVPD augmentation (diffuse) shells appended in l order.
+  * m order: p = (z, x, y); d = (z2, xz, yz, x2-y2, xy); f = (0,+1,-1,+2,-2,+3,-3); g = (0,+1,-1,...,+4,-4)
+  * relative to pyscf real solid harmonics, f(+3) and f(-3) have opposite sign (g signs searched if present).
+"""
+import re, sys, time, itertools
+import numpy as np
+from scipy.linalg import eigh
+from pyscf import gto
+
+def parse(path):
+    lines = open(path, errors="replace").read().split("\n")
+    i = lines.index("CARTESIAN COORDINATES (ANGSTROEM)")
+    atoms = []
+    for l in lines[i+2:]:
+        p = l.split()
+        if len(p) != 4: break
+        atoms.append((p[0], (float(p[1]), float(p[2]), float(p[3]))))
+    charge = int([l for l in lines if "Total Charge" in l][0].split("....")[1])
+    mult = int([l for l in lines if l.strip().startswith("Multiplicity") and "Mult " in l][0].split("....")[1])
+    hftyp = [l for l in lines if "Hartree-Fock type" in l][0].split("....")[1].strip()
+    nbas = int([l for l in lines if l.startswith("Number of basis functions")][0].split("...")[1])
+    k = lines.index("ORBITAL ENERGIES")
+    start = k + 4
+    eps = []
+    for l in lines[start:]:
+        p = l.split()
+        if len(p) != 4: break
+        eps.append(float(p[2]))
+    fi = lines.index("FOCK"); i = fi + 2
+    F = np.zeros((nbas, nbas)); done = 0
+    while done < nbas:
+        ncol = len(lines[i].split())
+        F[:, done:done+ncol] = np.fromstring("\n".join(lines[i+1:i+1+nbas]), sep=" ").reshape(nbas, ncol+1)[:, 1:]
+        done += ncol; i += 1 + nbas
+    return atoms, charge, mult, hftyp, nbas, np.array(eps), F
+
+ORCA_M = {l: [0] + [m for k in range(1, l+1) for m in (k, -k)] for l in range(6)}
+FLIP = {(3, 3), (3, -3)}   # sign flips relative to pyscf
+
+def orca_perm_and_sign(mol, extra_flips=()):
+    tzvp = {}
+    for ia in range(mol.natm):
+        el = mol.atom_symbol(ia)
+        if el not in tzvp:
+            tzvp[el] = {(sh[0], tuple(round(p[0], 6) for p in sh[1:])) for sh in gto.basis.load("def2-tzvp", el)}
+    perm = []; sgn = []; labels = []
+    ao = 0; table = {}
+    for ish in range(mol.nbas):
+        ia = mol.bas_atom(ish); l = mol.bas_angular(ish)
+        for c in range(mol.bas_nctr(ish)):
+            for m in ([1, -1, 0] if l == 1 else list(range(-l, l+1))):
+                table[(ish, c, m)] = ao; ao += 1
+    for ia in range(mol.natm):
+        el = mol.atom_symbol(ia)
+        shells = []
+        for ish in [i for i in range(mol.nbas) if mol.bas_atom(i) == ia]:
+            l = mol.bas_angular(ish); ex = tuple(round(float(e), 6) for e in mol.bas_exp(ish))
+            for c in range(mol.bas_nctr(ish)):
+                shells.append((l, ish, c, (l, ex) not in tzvp[el]))
+        shells = sorted([s for s in shells if not s[3]], key=lambda s: (s[0], s[1], s[2])) + \
+                 sorted([s for s in shells if s[3]], key=lambda s: (s[0], s[1], s[2]))
+        for l, ish, c, aug in shells:
+            for m in ORCA_M[l]:
+                perm.append(table[(ish, c, m)])
+                sgn.append(-1.0 if ((l, m) in FLIP) ^ ((l, m) in extra_flips) else 1.0)
+                labels.append((ia, el, l, m, aug))
+    return np.array(perm), np.array(sgn), labels
+
+def orca_overlap(mol, extra_flips=()):
+    perm, sgn, labels = orca_perm_and_sign(mol, extra_flips)
+    S = mol.intor("int1e_ovlp")[np.ix_(perm, perm)] * np.outer(sgn, sgn)
+    return S, labels
+
+if __name__ == "__main__":
+    for path in sys.argv[1:]:
+        t0 = time.time(); name = path.split("/samples/")[1].split("/")[0]
+        try:
+            atoms, charge, mult, hftyp, nbas, eps, F = parse(path)
+            mol = gto.M(atom=atoms, basis="def2-tzvpd", ecp="def2-tzvpd", unit="Angstrom", charge=charge, spin=mult-1, verbose=0)
+        except Exception as e:
+            print(f"{name:24s} SKIP: {type(e).__name__}: {str(e)[:120]}"); continue
+        if mol.nao != nbas:
+            print(f"{name:24s} SKIP: pyscf nao {mol.nao} != ORCA nbas {nbas}"); continue
+        nmo = int((eps != 0).sum()); nocc = (mol.nelectron + (mult-1)) // 2
+        S, labels = orca_overlap(mol)
+        w = eigh(F, S, eigvals_only=True); d = np.abs(w[:nmo] - eps[:nmo])
+        note = ""
+        has_g = any(l == 4 for _, _, l, _, _ in labels)
+        if d[:nocc].max() > 1e-4 and has_g:
+            gl = [(4, m) for m in ORCA_M[4] if m != 0]
+            for flips in itertools.product([0, 1], repeat=len(gl)):
+                ef = tuple(x for x, f in zip(gl, flips) if f)
+                S2, _ = orca_overlap(mol, ef)
+                w2 = eigh(F, S2, eigvals_only=True); d2 = np.abs(w2[:nmo] - eps[:nmo])
+                if d2[:nocc].max() < d[:nocc].max():
+                    d = d2; note = f" g-flips={ef}"
+                    if d[:nocc].max() < 1e-4: break
+        sS = np.linalg.eigvalsh(S)
+        print(f"{name:24s} {hftyp} nbas={nbas} nmo={nmo} Smin={sS.min():.1e} | occ max|de|={d[:nocc].max():.1e} all max={d.max():.1e} mean={d.mean():.1e}{note} | {time.time()-t0:.0f}s", flush=True)

fullC/code/copy_100k_share.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+#SBATCH --account=m5293
+#SBATCH --qos=xfer
+#SBATCH --time=12:00:00
+#SBATCH --job-name=omol_copy_100k_share
+#SBATCH --output=/global/cfs/projectdirs/m5293/ericqu/omol_elec_process/logs/copy_100k_share_%j.log
+# Copy the finished, verified 100k share (repacked Pass A + Pass B1 C_occ) from scratch to CFS.
+set -euo pipefail
+SRC="$PSCRATCH/omol_100k"
+DST="/global/cfs/projectdirs/m5293/ericqu/omol_elec_process/omol_elec_100k"
+mkdir -p "$DST"
+echo "copying $SRC -> $DST  $(date)"
+rsync -a --no-inc-recursive "$SRC/" "$DST/"
+echo "rsync finished $(date)"
+echo "files: $(find "$DST" -type f | wc -l)   bytes: $(du -sb "$DST" | cut -f1)"

fullC/code/derive_occ_store.py

@@ -0,0 +1,151 @@
+"""Derive the occupied-only variant of a full-C store.
+
+For every p2 shard the group directory is copied file for file (no decode or re-encode of the
+Fock and table arrays), except the `cmo_*` arrays, which are rewritten with only the occupied
+rows of each calculation's C^T block. Both variants share one schema: `mo_content` in the group
+attributes is "full" or "occupied", and `cmo_x[o[i]:o[i+1]].reshape(-1, nbas)` is C^T restricted to
+the stored orbitals either way. p1 and the root files are copied as they are.
+
+    python derive_occ_store.py --src $PSCRATCH/omol_100k --dst $PSCRATCH/omol_100k_occ --workers 64
+"""
+from __future__ import annotations
+import argparse, glob, os, shutil, sys, time, traceback
+import multiprocessing as mp
+import numpy as np
+import zarr
+
+zarr.config.set({"threading.max_workers": 1, "async.concurrency": 2})
+try:
+    import numcodecs.blosc
+    numcodecs.blosc.set_nthreads(1)
+    numcodecs.blosc.use_threads = False
+except Exception:
+    pass
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from omol_store import put_array
+
+CMO_CHUNK = 1 << 22
+
+
+def p2_shards(store):
+    out = []
+    for depth in ("*", "*/*/*"):
+        out += glob.glob(os.path.join(store, "p2", depth, "*.zarr"))
+    return sorted(set(out))
+
+
+def derive(args):
+    src, dst = args
+    t0 = time.time()
+    try:
+        if os.path.isdir(dst):
+            if zarr.open_group(dst, mode="r").attrs.get("occ_derived_verified"):
+                return dst, "skip", 0, 0.0, ""
+            shutil.rmtree(dst)
+        gs = zarr.open_group(src, mode="r")
+        if gs.attrs.get("mo_content", "full") != "full":
+            raise RuntimeError("source is not a full-C store")
+        skip = {n for n in gs.array_keys() if n.startswith("cmo_")}
+        shutil.copytree(src, dst, ignore=lambda d, names: [n for n in names if d == src and n in skip])
+        # the copied root zarr.json may carry consolidated metadata that still lists the excluded
+        # arrays; drop it and re-consolidate once the new arrays are in place
+        import json
+        meta_path = os.path.join(dst, "zarr.json")
+        meta = json.load(open(meta_path))
+        if "consolidated_metadata" in meta:
+            meta["consolidated_metadata"] = None
+            json.dump(meta, open(meta_path, "w"))
+        gd = zarr.open_group(dst, mode="r+", use_consolidated=False)
+        n = int(gs.attrs["n_calc"])
+        nbas = np.asarray(gs["scalar_i"])[:, list(gs.attrs["scalar_i_cols"]).index("nbas")].astype("i8")
+        mi = np.asarray(gs["mo_i"])
+        nocc = {s: mi[:, list(gs.attrs["mo_i_cols"]).index(f"nocc_{s}")].astype("i8") for s in "ab"}
+        written = 0
+        for s in "ab":
+            zsrc = gs[f"cmo_{s}"]
+            off_src = np.asarray(gs[f"cmo_{s}_offsets"])
+            lens = np.where(np.diff(off_src) > 0, nocc[s] * nbas, 0)
+            offs = np.zeros(n + 1, dtype="i8")
+            offs[1:] = np.cumsum(lens)
+            buf = np.empty(int(offs[-1]), dtype=zsrc.dtype)
+            for i in range(n):
+                if lens[i]:
+                    a = int(off_src[i])
+                    buf[offs[i]:offs[i + 1]] = zsrc[a:a + int(lens[i])]
+            put_array(gd, f"cmo_{s}", buf, codec=None,
+                      chunks=(max(1, min(len(buf), CMO_CHUNK)),), overwrite=True)
+            put_array(gd, f"cmo_{s}_offsets", offs, overwrite=True)
+            # verify: every stored block equals the source prefix
+            back = np.asarray(gd[f"cmo_{s}"][...])
+            if not np.array_equal(back, buf):
+                raise RuntimeError(f"read-back mismatch cmo_{s}")
+            written += buf.nbytes
+        # verify the copied arrays too (cheap ones fully, Fock by a spot check of the first calc)
+        for name in gs.array_keys():
+            if name in skip:
+                continue
+            if name.startswith("fock_") and not name.endswith("_offsets"):
+                k = min(int(gs[name].shape[0]), 200_000)
+                if not np.array_equal(np.asarray(gs[name][:k]), np.asarray(gd[name][:k])):
+                    raise RuntimeError(f"copy mismatch {name}")
+            else:
+                a, b = np.asarray(gs[name][...]), np.asarray(gd[name][...])
+                ok = np.array_equal(a, b, equal_nan=True) if a.dtype.kind == "f" else np.array_equal(a, b)
+                if not ok:
+                    raise RuntimeError(f"copy mismatch {name}")
+        gd.attrs.update({
+            "mo_content": "occupied",
+            "mo_layout": "cmo_x[o[i]:o[i+1]].reshape(nocc_x, nbas) = C_occ^T (row k = occupied MO k "
+                         "over AOs, ORCA AO order); derived from the full-C store",
+            "occ_derived_verified": True,
+        })
+        if gs.metadata.consolidated_metadata is not None:
+            zarr.consolidate_metadata(gd.store)
+        return dst, "ok", written, time.time() - t0, ""
+    except Exception:
+        return dst, "fail", 0, time.time() - t0, traceback.format_exc(limit=4)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True)
+    ap.add_argument("--dst", required=True)
+    ap.add_argument("--workers", type=int, default=64)
+    args = ap.parse_args()
+    src, dst = os.path.abspath(args.src), os.path.abspath(args.dst)
+    os.makedirs(dst, exist_ok=True)
+    # p1 and root files verbatim
+    if not os.path.isdir(os.path.join(dst, "p1")):
+        shutil.copytree(os.path.join(src, "p1"), os.path.join(dst, "p1"))
+    for name in os.listdir(src):
+        p = os.path.join(src, name)
+        if os.path.isfile(p):
+            shutil.copy2(p, dst)
+        elif name == "code":
+            shutil.copytree(p, os.path.join(dst, "code"), dirs_exist_ok=True)
+    shards = p2_shards(src)
+    jobs = [(s, os.path.join(dst, os.path.relpath(s, src))) for s in shards]
+    print(f"derive occupied-only store: {len(jobs)} p2 shards {src} -> {dst}", flush=True)
+    t0 = time.time()
+    n_ok = n_skip = n_fail = 0
+    written = 0
+    with mp.Pool(min(args.workers, len(jobs))) as pool:
+        for k, (path, status, w, dt, err) in enumerate(pool.imap_unordered(derive, jobs), 1):
+            if status == "ok":
+                n_ok += 1; written += w
+            elif status == "skip":
+                n_skip += 1
+            else:
+                n_fail += 1
+                print(f"FAIL {path}\n{err}", flush=True)
+            if k % 100 == 0 or k == len(jobs):
+                print(f"  {k}/{len(jobs)} ok={n_ok} skip={n_skip} fail={n_fail} "
+                      f"cocc {written/1e9:.1f} GB  {(time.time()-t0)/60:.1f} min", flush=True)
+    print(f"\ndone: ok {n_ok}, skipped {n_skip}, failed {n_fail}, occupied C {written/1e9:.1f} GB, "
+          f"wall {(time.time()-t0)/60:.1f} min")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("fork", force=True)
+    main()

fullC/code/export_basis.py

@@ -0,0 +1,193 @@
+"""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()

fullC/code/gbw_reader.py

@@ -0,0 +1,69 @@
+"""Minimal reader for ORCA 6 .gbw files (reverse-engineered, validated against orca.out on OMol25 data).
+
+Layout: 64-byte header of little-endian int64 words; word 3 (byte 24) points to the MO block:
+  int32 n_operators (1 = RHF/RKS, 2 = UHF/UKS), int32 dim, then for each operator
+  dim*dim float64 coefficients stored so that reshape(dim, dim) gives C[ao, mo], dim float64 occupations,
+  dim float64 orbital energies (Eh), dim int32 irreps, dim int32 core flags.
+Returns C[ao, mo] (columns = MOs) in ORCA AO ordering; C^T S C = I verified to 1e-7 against pyscf S.
+"""
+import struct, numpy as np, zstandard as zstd
+
+def read_gbw(path):
+    b = open(path, "rb").read()
+    if path.endswith(".zstd0") or b[:4] == b"\x28\xb5\x2f\xfd":
+        b = zstd.ZstdDecompressor().decompressobj().decompress(b)
+    hdr = struct.unpack_from("<8q", b, 0)
+    ptr = hdr[3]
+    nop, dim = struct.unpack_from("<ii", b, ptr); off = ptr + 8
+    ops = []
+    for _ in range(nop):
+        C = np.frombuffer(b, dtype="<f8", count=dim*dim, offset=off).reshape(dim, dim).copy(); off += dim*dim*8
+        occ = np.frombuffer(b, dtype="<f8", count=dim, offset=off).copy(); off += dim*8
+        en = np.frombuffer(b, dtype="<f8", count=dim, offset=off).copy(); off += dim*8
+        irrep = np.frombuffer(b, dtype="<i4", count=dim, offset=off).copy(); off += dim*4
+        core = np.frombuffer(b, dtype="<i4", count=dim, offset=off).copy(); off += dim*4
+        ops.append(dict(C=C, occ=occ, energies=en, irrep=irrep, core=core))
+    return dict(nbas=dim, nop=nop, ops=ops, header=hdr)
+
+if __name__ == "__main__":
+    import sys
+    sys.path.insert(0, "/global/u1/e/ericqu/omol_elec_process")
+    from check_overlap import parse, orca_overlap
+    from pyscf import gto
+    G = "/global/cfs/projectdirs/m5293/ericqu/omol_elec_process/gbw_pilot"; S_ = "/global/cfs/projectdirs/m5293/ericqu/omol_elec_process/samples"
+    def inflate(v):
+        n = int((np.sqrt(8*len(v)+1)-1)//2); M = np.zeros((n,n)); M[np.triu_indices(n)] = v; return M + M.T - np.diag(M.diagonal())
+    for rel in sys.argv[1:]:
+        name = rel.split("/")[0]
+        g = read_gbw(f"{G}/{rel}/orca.gbw.zstd0"); z = np.load(f"{G}/{rel}/density_mat.npz")
+        atoms, charge, mult, hftyp, nbas, eps, F = parse(f"{S_}/{rel}/orca.out")
+        a = g["ops"][0]; C, occ, en = a["C"], a["occ"], a["energies"]
+        nmo = int((eps != 0).sum())
+        line = f"== {name:22s} {hftyp} nbas={g['nbas']} nop={g['nop']} | eps(gbw)-eps(printed) max {np.abs(en[:nmo]-eps[:nmo]).max():.1e} Eh | occ sum {occ.sum():.2f}"
+        # density from gbw vs npz
+        P_npz = inflate(z["orca.scfp"])
+        if g["nop"] == 2:
+            b_ = g["ops"][1]; Pg = C @ np.diag(occ) @ C.T + b_["C"] @ np.diag(b_["occ"]) @ b_["C"].T
+        else:
+            Pg = C @ np.diag(occ) @ C.T
+        line += f" | P(gbw)-P(npz) max {np.abs(Pg-P_npz).max():.1e}"
+        # S from C when no linear dependence: S = C^-T C^-1 ; F = C^-T diag(eps) C^-1
+        if nmo == nbas:
+            Ci = np.linalg.inv(C); F_rec = Ci.T @ np.diag(en) @ Ci; S_rec = Ci.T @ Ci
+            line += f" | F(gbw)-F(printed): max {np.abs(F_rec-F).max():.1e}, rms {np.sqrt(((F_rec-F)**2).mean()):.1e}"
+            try:
+                mol = gto.M(atom=atoms, basis="def2-tzvpd", ecp="def2-tzvpd", unit="Angstrom", charge=charge, spin=mult-1, verbose=0)
+                S, _ = orca_overlap(mol); line += f" | S(gbw)-S(pyscf) max {np.abs(S_rec-S).max():.1e}"
+            except Exception as e:
+                line += f" | pyscf basis unavailable ({type(e).__name__})"
+        else:
+            line += f" | {nbas-nmo} lin.dep. removed: C is {nbas}x{nmo}, F/S not invertible from C alone"
+            try:
+                mol = gto.M(atom=atoms, basis="def2-tzvpd", ecp="def2-tzvpd", unit="Angstrom", charge=charge, spin=mult-1, verbose=0)
+                S, _ = orca_overlap(mol); Ck = C[:, :nmo]
+                line += f" | C^T S C - I max {np.abs(Ck.T @ S @ Ck - np.eye(nmo)).max():.1e}"
+                F_rec = S @ Ck @ np.diag(en[:nmo]) @ Ck.T @ S
+                line += f" | F(S C e C^T S)-F(printed) max {np.abs(F_rec-F).max():.1e}"
+            except Exception as e:
+                line += f" | pyscf basis unavailable ({type(e).__name__})"
+        print(line, flush=True)

fullC/code/hf_upload.py

@@ -0,0 +1,31 @@
+"""Upload the merged 100k stores to the Hub dataset repo ericqu/OME.
+
+Layout in the repo: fullC/{p1,p2,index.tsv,basis json,...} and occC/{...}. No README (by request).
+upload_large_folder is resumable: re-running picks up where it stopped (state in .cache/ under the
+folder). Run from an xfer-queue job (network access, no node-hour charge).
+
+    python hf_upload.py --folder $PSCRATCH/hf_OME --repo ericqu/OME
+"""
+import argparse, time
+from huggingface_hub import HfApi
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--folder", required=True)
+    ap.add_argument("--repo", default="ericqu/OME")
+    ap.add_argument("--workers", type=int, default=16)
+    args = ap.parse_args()
+    api = HfApi()
+    print("user:", api.whoami()["name"], flush=True)
+    info = api.repo_info(args.repo, repo_type="dataset")
+    print(f"repo {args.repo}: private={info.private} gated={info.gated}", flush=True)
+    t0 = time.time()
+    api.upload_large_folder(repo_id=args.repo, repo_type="dataset", folder_path=args.folder,
+                            num_workers=args.workers, print_report=True, print_report_every=120,
+                            ignore_patterns=["README.md", "*/README.md", ".cache/*", "*/.cache/*"])
+    print(f"upload finished in {(time.time()-t0)/3600:.2f} h", flush=True)
+
+
+if __name__ == "__main__":
+    main()

fullC/code/make_subset.py

@@ -0,0 +1,87 @@
+"""Draw a uniform random subset of OMol25 calculations and check they exist on m5250.
+
+The population is the 4M-split path list shipped with the release (`4m_paths.txt`, 3,986,753 rows).
+Sampling is uniform over that list with a fixed seed, so the subset keeps the collection's natural
+dataset proportions and is exactly reproducible.
+
+Writes:
+  subset_<n>.txt        one relative path per line, present on m5250, shuffled
+  subset_<n>_missing.txt paths sampled but not found locally
+  subset_<n>_counts.tsv per-dataset counts, sampled vs population
+"""
+import argparse, os, random, sys
+from collections import Counter
+
+M5250 = "/global/cfs/projectdirs/m5250/OMol_elec"
+PATHS = ("/global/cfs/projectdirs/m5293/ericqu/omol_elec_process/gbw_pilot/"
+         "source_root/4m_paths.txt")
+OUTDIR = "/global/cfs/projectdirs/m5293/ericqu/omol_elec_process/subsets"
+
+
+def dataset_of(rel):
+    """Top-level dataset name; the omol/ tree is grouped by its second and third component."""
+    parts = rel.split("/")
+    if parts[0] == "omol" and len(parts) > 2:
+        return "/".join(parts[:3])
+    return parts[0]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-n", type=int, default=100_000)
+    ap.add_argument("--seed", type=int, default=20260903)
+    ap.add_argument("--paths", default=PATHS)
+    ap.add_argument("--outdir", default=OUTDIR)
+    ap.add_argument("--check", type=int, default=5000,
+                    help="how many sampled paths to stat for a miss-rate estimate (0 = none)")
+    args = ap.parse_args()
+
+    with open(args.paths) as fh:
+        pop = [l.strip() for l in fh if l.strip()]
+    print(f"population: {len(pop):,} paths", flush=True)
+
+    rng = random.Random(args.seed)
+    n = min(args.n, len(pop))
+    sample = rng.sample(pop, n)
+    print(f"sampled uniformly: {n:,} (seed {args.seed})", flush=True)
+
+    os.makedirs(args.outdir, exist_ok=True)
+    # Stat-ing every path is slow on CFS (huge directories), and Pass A detects a missing archive
+    # for free, so only a subsample is checked here to estimate the miss rate.
+    missing = []
+    ncheck = min(args.check, n)
+    for i, rel in enumerate(sample[:ncheck]):
+        if not os.path.exists(os.path.join(M5250, rel, "orca.tar.zst")):
+            missing.append(rel)
+        if (i + 1) % 1000 == 0:
+            print(f"  checked {i+1:,}/{ncheck:,}: {len(missing):,} missing", flush=True)
+    present = sample
+    rng.shuffle(present)
+    base = os.path.join(args.outdir, f"subset_{n//1000}k")
+    with open(base + ".txt", "w") as fh:
+        fh.write("\n".join(present) + "\n")
+    with open(base + "_missing.txt", "w") as fh:
+        fh.write("\n".join(missing) + ("\n" if missing else ""))
+
+    pop_counts = Counter(dataset_of(p) for p in pop)
+    got_counts = Counter(dataset_of(p) for p in present)
+    with open(base + "_counts.tsv", "w") as fh:
+        fh.write("dataset\tpopulation\tsampled\tpct_of_dataset\n")
+        for ds in sorted(pop_counts, key=lambda d: -pop_counts[d]):
+            fh.write(f"{ds}\t{pop_counts[ds]}\t{got_counts.get(ds,0)}\t"
+                     f"{100*got_counts.get(ds,0)/pop_counts[ds]:.3f}\n")
+
+    rate = (100 * len(missing) / ncheck) if ncheck else float("nan")
+    print(f"\nsubset {len(present):,} paths; miss rate on {ncheck:,} checked: "
+          f"{len(missing):,} ({rate:.2f}%)")
+    print(f"datasets covered: {len(got_counts)}/{len(pop_counts)}")
+    zero = [d for d in pop_counts if d not in got_counts]
+    if zero:
+        print("datasets with no sampled member:")
+        for d in zero:
+            print(f"   {d}  (population {pop_counts[d]:,})")
+    print(f"\nwrote {base}.txt / _missing.txt / _counts.tsv")
+
+
+if __name__ == "__main__":
+    main()

fullC/code/merge_store.py

@@ -0,0 +1,265 @@
+"""Merge the many small Pass A/B1 shard groups of a store into a few large ones.
+
+Pass A flushed a shard group whenever a worker had buffered ~1.2 GB of Fock data, which bounds
+parser memory but leaves hundreds of groups per 100k calculations and tens of thousands of
+metadata files for a loader to touch. This rewrites a store as, per dataset, the smallest number
+of groups whose on-disk size stays under --group-bytes (measured on the p2 side, so p1 and p2 get
+the same row layout), and writes consolidated metadata so opening a group is one JSON read.
+
+Row order inside a merged group is the concatenation of the source groups in name order; every
+ragged array is concatenated and its offsets rebased; the per-calculation attrs lists are
+concatenated. Chunk shapes and codecs come from the source arrays; shard files hold
+--chunks-per-shard chunks. Writing is done in whole-shard blocks by a pool of workers (one task
+per destination array per block), so memory per worker stays around one shard.
+
+    python merge_store.py --src $PSCRATCH/omol_100k --dst $PSCRATCH/omol_100k_m --group-bytes 32e9
+"""
+from __future__ import annotations
+import argparse, glob, json, os, shutil, sys, time, traceback
+import multiprocessing as mp
+import numpy as np
+import zarr
+
+zarr.config.set({"threading.max_workers": 1, "async.concurrency": 2})
+try:
+    import numcodecs.blosc
+    numcodecs.blosc.set_nthreads(1)
+    numcodecs.blosc.use_threads = False
+except Exception:
+    pass
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+DROP_ATTRS = {"repack_verified", "occ_derived_verified", "mo_gbw_root", "n_calc", "calc_id",
+              "rel_path", "hftyp"}
+LIST_ATTRS = ("calc_id", "rel_path", "hftyp")
+
+
+def groups_by_dataset(root, side):
+    out = {}
+    for depth in ("*", "*/*/*"):
+        for gp in glob.glob(os.path.join(root, side, depth, "*.zarr")):
+            ds = os.path.relpath(os.path.dirname(gp), os.path.join(root, side))
+            out.setdefault(ds, []).append(gp)
+    return {ds: sorted(v) for ds, v in out.items()}
+
+
+def dir_bytes(path):
+    return sum(os.path.getsize(os.path.join(r, f)) for r, _, fs in os.walk(path) for f in fs)
+
+
+def plan_groups(src, group_bytes):
+    """Split each dataset's shard list (sorted by name) into runs whose p2 bytes stay under budget."""
+    p2 = groups_by_dataset(src, "p2")
+    plan = []
+    for ds, shards in sorted(p2.items()):
+        run, run_b = [], 0
+        for gp in shards:
+            b = dir_bytes(gp)
+            if run and run_b + b > group_bytes:
+                plan.append((ds, run)); run, run_b = [], 0
+            run.append(os.path.basename(gp)); run_b += b
+        if run:
+            plan.append((ds, run))
+    return plan
+
+
+def make_group(args):
+    """Create one destination group (both sides): metadata, attrs, offsets. Returns write tasks."""
+    src, dst, side, ds, gname, members, cps = args
+    try:
+        srcs = [zarr.open_group(os.path.join(src, side, ds, m), mode="r") for m in members]
+        out_path = os.path.join(dst, side, ds, gname)
+        if os.path.isdir(out_path):
+            shutil.rmtree(out_path)
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
+        gd = zarr.open_group(out_path, mode="w")
+        attrs = {k: v for k, v in dict(srcs[0].attrs).items() if k not in DROP_ATTRS}
+        for g in srcs[1:]:
+            for k, v in attrs.items():
+                if g.attrs.get(k) != v:
+                    raise RuntimeError(f"attr {k} differs between source groups of {ds}")
+        for k in LIST_ATTRS:
+            attrs[k] = sum((list(g.attrs[k]) for g in srcs), [])
+        attrs["n_calc"] = int(sum(int(g.attrs["n_calc"]) for g in srcs))
+        attrs["merged_from"] = members
+        gd.attrs.update(attrs)
+        names = sorted(srcs[0].array_keys())
+        for g in srcs[1:]:
+            if sorted(g.array_keys()) != names:
+                raise RuntimeError(f"array list differs between source groups of {ds}")
+        tasks = []
+        for name in names:
+            arrs = [g[name] for g in srcs]
+            if name.endswith("_offsets"):
+                parts, base = [np.asarray(arrs[0][...])], int(arrs[0][-1])
+                for a in arrs[1:]:
+                    o = np.asarray(a[...])
+                    parts.append(o[1:] + base); base += int(o[-1])
+                offs = np.concatenate(parts)
+                z = gd.create_array(name=name, shape=offs.shape, chunks=offs.shape, shards=offs.shape,
+                                    dtype=offs.dtype, compressors=arrs[0].compressors)
+                z[...] = offs
+                continue
+            lens = [int(a.shape[0]) for a in arrs]
+            total = sum(lens)
+            shape = (total,) + tuple(arrs[0].shape[1:])
+            chunk0 = int(arrs[0].chunks[0])
+            chunks = (max(1, min(total, chunk0)),) + tuple(arrs[0].shape[1:])
+            n_chunks = max(1, -(-total // chunks[0]))
+            shard_len = chunks[0] * min(cps, n_chunks)
+            shards = (shard_len,) + tuple(arrs[0].shape[1:])
+            gd.create_array(name=name, shape=shape, chunks=chunks, shards=shards,
+                            dtype=arrs[0].dtype, compressors=arrs[0].compressors)
+            if total == 0:
+                continue
+            starts = np.concatenate([[0], np.cumsum(lens)[:-1]])
+            for a0 in range(0, total, shard_len):
+                a1 = min(total, a0 + shard_len)
+                pieces = []
+                for m, s0, n in zip(members, starts, lens):
+                    lo, hi = max(a0, s0), min(a1, s0 + n)
+                    if hi > lo:
+                        pieces.append((m, int(lo - s0), int(hi - s0)))
+                tasks.append((src, side, ds, out_path, name, int(a0), int(a1), pieces))
+        return out_path, tasks, ""
+    except Exception:
+        return os.path.join(dst, side, ds, gname), [], traceback.format_exc(limit=4)
+
+
+def write_block(args):
+    src, side, ds, out_path, name, a0, a1, pieces = args
+    t0 = time.time()
+    try:
+        chunks = [np.asarray(zarr.open_group(os.path.join(src, side, ds, m), mode="r")[name][lo:hi])
+                  for m, lo, hi in pieces]
+        block = np.concatenate(chunks) if len(chunks) > 1 else chunks[0]
+        z = zarr.open_array(out_path + "/" + name, mode="r+")
+        z[a0:a1] = block
+        return name, block.nbytes, time.time() - t0, ""
+    except Exception:
+        return name, 0, time.time() - t0, traceback.format_exc(limit=4)
+
+
+def verify_group(args):
+    """Every array of the merged group equals the concatenation of its sources (full compare for
+    arrays under 4 M elements, 3 random 200k windows otherwise); then consolidate metadata."""
+    src, dst, side, ds, gname = args
+    try:
+        gd = zarr.open_group(os.path.join(dst, side, ds, gname), mode="r+")
+        members = gd.attrs["merged_from"]
+        srcs = [zarr.open_group(os.path.join(src, side, ds, m), mode="r") for m in members]
+        rng = np.random.default_rng(abs(hash(gname)) % (2**32))
+        for name in gd.array_keys():
+            if name.endswith("_offsets"):
+                parts, base = [np.asarray(srcs[0][name][...])], int(srcs[0][name][-1])
+                for g in srcs[1:]:
+                    o = np.asarray(g[name][...]); parts.append(o[1:] + base); base += int(o[-1])
+                if not np.array_equal(np.asarray(gd[name][...]), np.concatenate(parts)):
+                    raise RuntimeError(f"{name} offsets differ")
+                continue
+            lens = [int(g[name].shape[0]) for g in srcs]
+            starts = np.concatenate([[0], np.cumsum(lens)[:-1]])
+            total = int(gd[name].shape[0])
+            if total != sum(lens):
+                raise RuntimeError(f"{name} length {total} != {sum(lens)}")
+            if total == 0:
+                continue
+            if gd[name].size <= 4_000_000:
+                windows = [(0, total)]
+            else:
+                windows = [(int(s), int(min(total, s + 200_000))) for s in rng.integers(0, total, 3)]
+            for w0, w1 in windows:
+                got = np.asarray(gd[name][w0:w1])
+                exp = []
+                for g, s0, n in zip(srcs, starts, lens):
+                    lo, hi = max(w0, s0), min(w1, s0 + n)
+                    if hi > lo:
+                        exp.append(np.asarray(g[name][lo - s0:hi - s0]))
+                exp = np.concatenate(exp)
+                ok = np.array_equal(got, exp, equal_nan=True) if got.dtype.kind == "f" else np.array_equal(got, exp)
+                if not ok:
+                    raise RuntimeError(f"{name} content differs in [{w0},{w1})")
+        n_ids = len(gd.attrs["calc_id"])
+        if n_ids != sum(len(g.attrs["calc_id"]) for g in srcs) or n_ids != int(gd.attrs["n_calc"]):
+            raise RuntimeError("calc_id list length")
+        zarr.consolidate_metadata(gd.store)
+        return gname, side, ds, "ok", ""
+    except Exception:
+        return gname, side, ds, "fail", traceback.format_exc(limit=4)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True)
+    ap.add_argument("--dst", required=True)
+    ap.add_argument("--group-bytes", type=float, default=32e9)
+    ap.add_argument("--chunks-per-shard", type=int, default=64)
+    ap.add_argument("--workers", type=int, default=96)
+    ap.add_argument("--datasets", default="", help="comma list to restrict (smoke tests)")
+    args = ap.parse_args()
+    src, dst = os.path.abspath(args.src), os.path.abspath(args.dst)
+    t0 = time.time()
+    plan = plan_groups(src, args.group_bytes)
+    if args.datasets:
+        keep = set(args.datasets.split(","))
+        plan = [p for p in plan if p[0] in keep]
+    counter = {}
+    named = []
+    for ds, members in plan:
+        k = counter.get(ds, 0); counter[ds] = k + 1
+        named.append((ds, f"group_{k:03d}.zarr", members))
+    print(f"plan: {sum(len(m) for _, _, m in named)} source groups -> {len(named)} merged groups "
+          f"over {len(counter)} datasets  ({(time.time()-t0)/60:.1f} min)", flush=True)
+    for ds, n in sorted(counter.items(), key=lambda kv: -kv[1])[:8]:
+        print(f"   {ds}: {n} groups", flush=True)
+
+    # phase 1: create groups and gather write tasks (parallel over groups)
+    jobs = [(src, dst, side, ds, g, m, args.chunks_per_shard) for ds, g, m in named for side in ("p1", "p2")]
+    tasks = []
+    with mp.Pool(min(32, len(jobs))) as pool:
+        for out_path, t, err in pool.imap_unordered(make_group, jobs):
+            if err:
+                print(f"FAIL creating {out_path}\n{err}", flush=True); sys.exit(1)
+            tasks.extend(t)
+    # biggest blocks first so the tail is short
+    tasks.sort(key=lambda t: -(t[6] - t[5]))
+    print(f"phase 1 done: {len(jobs)} groups created, {len(tasks)} write blocks  "
+          f"({(time.time()-t0)/60:.1f} min)", flush=True)
+
+    # phase 2: write blocks
+    n_ok = n_fail = 0; nbytes = 0
+    with mp.Pool(min(args.workers, max(1, len(tasks)))) as pool:
+        for k, (name, nb, dt, err) in enumerate(pool.imap_unordered(write_block, tasks), 1):
+            if err:
+                n_fail += 1; print(f"FAIL block {name}\n{err}", flush=True)
+            else:
+                n_ok += 1; nbytes += nb
+            if k % 500 == 0 or k == len(tasks):
+                el = time.time() - t0
+                print(f"  blocks {k}/{len(tasks)} ok={n_ok} fail={n_fail} {nbytes/1e12:.3f} TB "
+                      f"{el/60:.1f} min", flush=True)
+    if n_fail:
+        print("write failures, stopping before verification"); sys.exit(1)
+
+    # phase 3: verify and consolidate
+    vjobs = [(src, dst, side, ds, g) for ds, g, _ in named for side in ("p1", "p2")]
+    v_ok = v_fail = 0
+    with mp.Pool(min(args.workers, len(vjobs))) as pool:
+        for gname, side, ds, status, err in pool.imap_unordered(verify_group, vjobs):
+            if status == "ok":
+                v_ok += 1
+            else:
+                v_fail += 1; print(f"VERIFY FAIL {side}/{ds}/{gname}\n{err}", flush=True)
+    for f in glob.glob(os.path.join(src, "*")):
+        if os.path.isfile(f):
+            shutil.copy2(f, dst)
+    if os.path.isdir(os.path.join(src, "code")):
+        shutil.copytree(os.path.join(src, "code"), os.path.join(dst, "code"), dirs_exist_ok=True)
+    print(f"\ndone: {len(named)} merged groups per side, verify ok {v_ok} fail {v_fail}, "
+          f"{nbytes/1e12:.3f} TB written, wall {(time.time()-t0)/60:.1f} min")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("fork", force=True)
+    main()

fullC/code/omol_parse.py

@@ -0,0 +1,612 @@
+"""Pass A parser: one ORCA 6.0 calculation (orca.out + orca.engrad) -> a plain-python record.
+
+Design notes
+------------
+* Single forward scan over orca.out. The file can be 600 MB, so nothing is loaded whole: the FOCK
+  block is consumed straight from the line iterator into its final numpy array.
+* The scanner is a pushback iterator, so a sub-parser that reads one line too far can hand it back;
+  otherwise a section's terminating line (often the *next* section's header) would be swallowed.
+* Every section is optional. Datasets differ (NBO on/off, RHF/UHF, ECPs, linear dependencies), so a
+  missing section leaves its fields as None rather than raising.
+* The Fock matrix is returned as an int32 upper triangle in micro-Hartree, which is the storage
+  encoding and is lossless with respect to ORCA's 6-decimal print.
+* Reduced orbital populations are aggregated to shell totals (s, p, d, f, g) per atom; the
+  individual components (pz, dxy, ...) are voluminous and low value, so they are skipped.
+
+Returns a dict with keys grouped as: meta / system / atoms / pairs / orbitals / fock.
+"""
+from __future__ import annotations
+import io, os, re, subprocess, tarfile
+import numpy as np
+
+SHELLS = ("s", "p", "d", "f", "g")
+EH_TO_UEH = 1e6
+_COLHDR = re.compile(r"^\s+0(\s+\d+)+\s*$")
+_BOND = re.compile(r"B\(\s*(\d+)-\s*(\w+)\s*,\s*(\d+)-\s*(\w+)\s*\)\s*:\s*(-?\d+\.\d+)")
+
+
+class _PB:
+    """Line iterator with one-line pushback."""
+
+    def __init__(self, it):
+        self._it = iter(it)
+        self._buf = []
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._buf:
+            return self._buf.pop()
+        return next(self._it)
+
+    def next(self, default=""):
+        try:
+            return self.__next__()
+        except StopIteration:
+            return default
+
+    def push(self, line):
+        self._buf.append(line)
+
+
+def _f(tok):
+    try:
+        return float(tok)
+    except (TypeError, ValueError):
+        return None
+
+
+def _after(line, sep):
+    _, _, rest = line.partition(sep)
+    return rest.strip()
+
+
+def _num_after_colon(line):
+    return _f(line.split(":")[-1].split()[0]) if ":" in line else None
+
+
+def _is_rule(t):
+    return bool(t) and set(t) <= set("-=*")
+
+
+# ----------------------------------------------------------------------------- Fock block
+def _read_matrix(pb, nbas, hdr):
+    """Read one nbas x nbas matrix printed in column blocks, given its first header line."""
+    F = np.zeros((nbas, nbas), dtype=np.float64)
+    done = 0
+    while done < nbas:
+        while hdr.strip() == "":
+            hdr = next(pb)
+        ncol = len(hdr.split())
+        rows = [next(pb) for _ in range(nbas)]
+        blk = np.fromstring(" ".join(rows), sep=" ", dtype=np.float64)
+        blk = blk.reshape(nbas, ncol + 1)[:, 1:]
+        F[:, done:done + ncol] = blk
+        done += ncol
+        if done < nbas:
+            hdr = next(pb)
+    return F
+
+
+def _tri_u_eh(F):
+    iu = np.triu_indices(F.shape[0])
+    return np.rint(F[iu] * EH_TO_UEH).astype(np.int32)
+
+
+def _next_matrix_header(pb, max_skip=6):
+    """Look for a column header, skipping blank and rule lines ('----', '****').
+    Anything else is pushed back and None is returned."""
+    for _ in range(max_skip + 1):
+        line = pb.next(None)
+        if line is None:
+            return None
+        t = line.strip()
+        if t == "" or _is_rule(t):
+            continue
+        if _COLHDR.match(line):
+            return line
+        pb.push(line)
+        return None
+    return None
+
+
+# ----------------------------------------------------------------------------- sub-parsers
+def _atom_charges(pb):
+    """'   0 Xe:    1.277884 [spin]' rows. Returns (charge, spin|None)."""
+    q, sp = [], []
+    for l2 in pb:
+        t = l2.strip()
+        if _is_rule(t):
+            continue
+        if not t:
+            if q:
+                break
+            continue
+        if ":" not in t:
+            pb.push(l2)
+            break
+        head, _, rest = l2.partition(":")
+        hp = head.split()
+        if not hp or not hp[0].isdigit():
+            pb.push(l2)
+            break
+        vals = rest.split()
+        if not vals:
+            break
+        q.append(float(vals[0]))
+        if len(vals) > 1:
+            sp.append(float(vals[1]))
+    return (np.array(q) if q else None, np.array(sp) if sp else None)
+
+
+def _reduced_shells(pb, natm):
+    """Per-atom shell totals from a REDUCED ORBITAL CHARGES block. Returns (charge, spin|None),
+    each (natm, len(SHELLS)) or None."""
+    if not natm:
+        return None, None
+    charge = np.zeros((natm, len(SHELLS)))
+    spin = None
+    target = charge
+    atom = -1
+    for l2 in pb:
+        t = l2.strip()
+        if not t or _is_rule(t):
+            continue
+        if t == "CHARGE":
+            target = charge
+            continue
+        if t == "SPIN":
+            spin = np.zeros((natm, len(SHELLS)))
+            target = spin
+            continue
+        if ":" not in t:                       # next section banner
+            pb.push(l2)
+            break
+        parts = l2.split(":")
+        head = parts[0].split()
+        if head and head[0].isdigit():
+            atom = int(head[0])
+        if len(parts) >= 3 and 0 <= atom < natm:
+            tail = parts[1].split()
+            if tail and tail[-1] in SHELLS:
+                v = _f(parts[2].split()[0])
+                if v is not None:
+                    target[atom, SHELLS.index(tail[-1])] = v
+    return charge, spin
+
+
+def _bond_list(pb):
+    """'B(  0-Xe,  1-Cl) :   0.1834' three per line, ending at a blank line."""
+    out = []
+    for l2 in pb:
+        t = l2.strip()
+        if _is_rule(t):
+            continue
+        if not t:
+            if out:
+                break
+            continue
+        found = _BOND.findall(l2)
+        if not found:
+            pb.push(l2)
+            break
+        for i, _, j, _, v in found:
+            out.append((int(i), int(j), float(v)))
+    return out
+
+
+def _mayer_table(pb):
+    cols = {k: [] for k in ("NA", "ZA", "QA", "VA", "BVA", "FA")}
+    for l2 in pb:
+        p = l2.split()
+        if len(p) != 8 or not p[0].isdigit():
+            pb.push(l2)
+            break
+        for k, v in zip(("NA", "ZA", "QA", "VA", "BVA", "FA"), p[2:]):
+            cols[k].append(float(v))
+    return {k: (np.array(v) if v else None) for k, v in cols.items()}
+
+
+def _npa_summary(pb, r, natm):
+    """RHF rows have 7 fields (El, No, Charge, Core, Valence, Rydberg, Total); UHF rows have an
+    eighth, the natural spin density."""
+    if not natm:
+        return
+    q = np.full(natm, np.nan)
+    core = np.full(natm, np.nan)
+    val = np.full(natm, np.nan)
+    ryd = np.full(natm, np.nan)
+    spin = np.full(natm, np.nan)
+    for l2 in pb:
+        t = l2.strip()
+        if not t or _is_rule(t):
+            continue
+        p = t.split()
+        if t.startswith("* Total *"):
+            if len(p) >= 7:
+                r["npa_core"], r["npa_valence"], r["npa_rydberg"] = (
+                    float(p[4]), float(p[5]), float(p[6]))
+            break
+        if len(p) in (7, 8) and p[1].isdigit() and _f(p[2]) is not None:
+            i = int(p[1]) - 1
+            if 0 <= i < natm:
+                q[i], core[i], val[i], ryd[i] = (float(p[2]), float(p[3]),
+                                                 float(p[4]), float(p[5]))
+                if len(p) == 8:
+                    spin[i] = float(p[7])
+            continue
+        if not np.isnan(q).all():
+            pb.push(l2)
+            break
+    if not np.isnan(q).all():
+        r["npa_q"], r["npa_atom_core"] = q, core
+        r["npa_atom_val"], r["npa_atom_ryd"] = val, ryd
+        if not np.isnan(spin).all():
+            r["npa_spin"] = spin
+
+
+_CONFIG_SHELL = re.compile(r"(\d)([spdfg])\(\s*([\d.]+)\)")
+
+
+def _natural_config(pb, natm):
+    """'Xe  1      [core]5s( 2.00)5p( 4.39)4f( 0.02)5d( 0.15)' -> per-atom occupancy by l."""
+    if not natm:
+        return None
+    out = np.zeros((natm, len(SHELLS)))
+    seen = False
+    for l2 in pb:
+        t = l2.strip()
+        if not t or _is_rule(t):
+            continue
+        p = t.split()
+        if len(p) >= 3 and p[1].isdigit() and ("[core]" in t or _CONFIG_SHELL.search(t)):
+            i = int(p[1]) - 1
+            if 0 <= i < natm:
+                for _, l, v in _CONFIG_SHELL.findall(t):
+                    out[i, SHELLS.index(l)] += float(v)
+                seen = True
+            continue
+        if seen:
+            pb.push(l2)
+            break
+    return out if seen else None
+
+
+def _orbital_energies(pb):
+    """Returns (eps_a, occ_a, eps_b, occ_b); the beta pair is None for RHF."""
+    eps_a = occ_a = eps_b = occ_b = None
+    eps, occ = [], []
+    spin = 0
+    for l2 in pb:
+        t = l2.strip()
+        if not t or _is_rule(t):
+            continue
+        if "SPIN UP" in t:
+            spin = 0
+            continue
+        if "SPIN DOWN" in t:
+            eps_a, occ_a = np.array(eps), np.array(occ)
+            eps, occ = [], []
+            spin = 1
+            continue
+        if t.startswith("NO") and "OCC" in t:
+            continue
+        p = t.split()
+        if len(p) == 4:
+            o, e = _f(p[1]), _f(p[2])
+            if o is not None and e is not None:
+                occ.append(o)
+                eps.append(e)
+                continue
+        pb.push(l2)
+        break
+    if spin == 0:
+        eps_a, occ_a = np.array(eps), np.array(occ)
+    else:
+        eps_b, occ_b = np.array(eps), np.array(occ)
+    return eps_a, occ_a, eps_b, occ_b
+
+
+def _dipole(pb, r):
+    for l2 in pb:
+        t = l2.strip()
+        if t.startswith("Electronic contribution"):
+            r["dipole_elec"] = [float(x) for x in t.split(":")[1].split()]
+        elif t.startswith("Nuclear contribution"):
+            r["dipole_nuc"] = [float(x) for x in t.split(":")[1].split()]
+        elif t.startswith("Total Dipole Moment"):
+            r["dipole_total"] = [float(x) for x in t.split(":")[1].split()]
+        elif t.startswith("Magnitude (a.u.)"):
+            r["dipole_au"] = _num_after_colon(t)
+        elif t.startswith("Magnitude (Debye)"):
+            r["dipole_debye"] = _num_after_colon(t)
+            return
+
+
+def _quadrupole(pb, r):
+    for l2 in pb:
+        t = l2.strip()
+        p = t.split()
+        if t.startswith("NUC") and len(p) >= 7:
+            r["quad_nuc"] = [float(x) for x in p[1:7]]
+        elif t.startswith("EL") and len(p) >= 7:
+            r["quad_elec"] = [float(x) for x in p[1:7]]
+        elif t.startswith("TOT") and len(p) >= 7:
+            r["quad_total"] = [float(x) for x in p[1:7]]
+        elif t.startswith("diagonalized tensor"):
+            nxt = next(pb).split()
+            if len(nxt) >= 3:
+                r["quad_diag"] = [float(x) for x in nxt[:3]]
+        elif t.startswith("Isotropic quadrupole"):
+            r["quad_iso"] = _num_after_colon(t)
+            return
+
+
+# ----------------------------------------------------------------------------- main parser
+def _blank_record():
+    return {
+        "version": None, "hftyp": None, "charge": None, "mult": None, "nelec": None,
+        "nbas": None, "naux": None, "smallest_ovlp_eig": None, "n_lindep": None,
+        "e_total": None, "e_nuc_rep": None, "e_one_elec": None, "e_two_elec": None,
+        "e_kinetic": None, "virial_ratio": None, "e_xc": None, "e_nl": None, "e_exchange": None,
+        "n_alpha_int": None, "n_beta_int": None,
+        "s2": None, "s2_ideal": None, "s2_dev": None,
+        "scf_converged": False, "scf_cycles": None,
+        "conv_denergy": None, "conv_maxdp": None, "conv_rmsdp": None, "conv_diiserr": None,
+        "dipole_elec": None, "dipole_nuc": None, "dipole_total": None,
+        "dipole_au": None, "dipole_debye": None,
+        "quad_nuc": None, "quad_elec": None, "quad_total": None, "quad_diag": None,
+        "quad_iso": None, "rot_const_cm": None, "rot_const_mhz": None,
+        "grad_norm": None, "grad_rms": None, "grad_max": None,
+        "run_time_s": None, "terminated_normally": False,
+        "nbo_available": False, "npa_available": False,
+        "npa_core": None, "npa_valence": None, "npa_rydberg": None,
+        "nbo_lewis": None, "nbo_nonlewis": None,
+        "elements": [], "coords": None, "ecp_ncore": {},
+        "mulliken_q": None, "mulliken_s": None, "loewdin_q": None, "loewdin_s": None,
+        "mayer_NA": None, "mayer_ZA": None, "mayer_QA": None,
+        "mayer_VA": None, "mayer_BVA": None, "mayer_FA": None,
+        "npa_q": None, "npa_atom_core": None, "npa_atom_val": None, "npa_atom_ryd": None,
+        "npa_spin": None, "natural_config": None,
+        "mulliken_shell_q": None, "loewdin_shell_q": None,
+        "mulliken_shell_s": None, "loewdin_shell_s": None,
+        "mayer_bo": [], "loewdin_bo": [], "mulliken_ovlp": [],
+        "eps_a": None, "occ_a": None, "eps_b": None, "occ_b": None,
+        "fock_a": None, "fock_b": None,
+    }
+
+
+def parse_orca_out(fh):
+    r = _blank_record()
+    pb = _PB(fh)
+    coords = []
+    for line in pb:
+        s = line.strip()
+
+        # ---------------- header / settings
+        if r["version"] is None and "Program Version" in line:
+            r["version"] = line.split("Program Version")[1].split()[0]
+        elif "Hartree-Fock type" in line:
+            r["hftyp"] = _after(line, "....")
+        elif "Total Charge" in line and "...." in line:
+            r["charge"] = int(float(_after(line, "....")))
+        elif s.startswith("Multiplicity") and "Mult " in line:
+            r["mult"] = int(float(_after(line, "....")))
+        elif "Number of Electrons" in line and "...." in line:
+            r["nelec"] = int(float(_after(line, "....")))
+        elif line.startswith("Number of basis functions") and r["nbas"] is None:
+            r["nbas"] = int(_after(line, "..."))
+        elif "# of basis functions in Aux-J" in line:
+            r["naux"] = int(_after(line, "..."))
+        elif "Smallest eigenvalue" in line and r["smallest_ovlp_eig"] is None:
+            r["smallest_ovlp_eig"] = _f(_after(line, "..."))
+        elif "Number of eigenvalues below threshold" in line:
+            r["n_lindep"] = int(_after(line, "..."))
+        elif "ECP" in line and "replacing" in line and "core electrons" in line:
+            m = re.search(r"Type\s+(\S+)\s+ECP.*replacing\s+(\d+)\s+core electrons", line)
+            if m:
+                r["ecp_ncore"][m.group(1)] = int(m.group(2))
+
+        # ---------------- geometry
+        elif s == "CARTESIAN COORDINATES (ANGSTROEM)" and not r["elements"]:
+            next(pb)
+            for l2 in pb:
+                p = l2.split()
+                if len(p) != 4:
+                    pb.push(l2)
+                    break
+                r["elements"].append(p[0])
+                coords.append([float(p[1]), float(p[2]), float(p[3])])
+
+        # ---------------- energies
+        elif s.startswith("Total Energy") and ":" in line and r["e_total"] is None:
+            r["e_total"] = _num_after_colon(line)
+        elif s.startswith("Nuclear Repulsion") and ":" in line:
+            r["e_nuc_rep"] = _num_after_colon(line)
+        elif s.startswith("One Electron Energy"):
+            r["e_one_elec"] = _num_after_colon(line)
+        elif s.startswith("Two Electron Energy"):
+            r["e_two_elec"] = _num_after_colon(line)
+        elif s.startswith("Kinetic Energy"):
+            r["e_kinetic"] = _num_after_colon(line)
+        elif s.startswith("Virial Ratio"):
+            r["virial_ratio"] = _num_after_colon(line)
+        elif s.startswith("E(XC)"):
+            r["e_xc"] = _num_after_colon(line)
+        elif s.startswith("NL Energy, E(C,NL)"):
+            r["e_nl"] = _num_after_colon(line)
+        elif s.startswith("New exchange energy"):
+            r["e_exchange"] = _num_after_colon(line)
+        elif s.startswith("N(Alpha)"):
+            r["n_alpha_int"] = _num_after_colon(line)
+        elif s.startswith("N(Beta)"):
+            r["n_beta_int"] = _num_after_colon(line)
+        elif s.startswith("FINAL SINGLE POINT ENERGY") and r["e_total"] is None:
+            r["e_total"] = _f(s.split()[-1])
+
+        # ---------------- SCF convergence
+        elif "SCF CONVERGED AFTER" in line:
+            r["scf_converged"] = True
+            m = re.search(r"AFTER\s+(\d+)\s+CYCLES", line)
+            if m:
+                r["scf_cycles"] = int(m.group(1))
+        elif s.startswith("Last Energy change"):
+            r["conv_denergy"] = _f(_after(line, "...").split()[0])
+        elif s.startswith("Last MAX-Density change"):
+            r["conv_maxdp"] = _f(_after(line, "...").split()[0])
+        elif s.startswith("Last RMS-Density change"):
+            r["conv_rmsdp"] = _f(_after(line, "...").split()[0])
+        elif s.startswith("Last DIIS Error"):
+            r["conv_diiserr"] = _f(_after(line, "...").split()[0])
+        elif s.startswith("Expectation value of <S**2>"):
+            r["s2"] = _num_after_colon(line)
+        elif s.startswith("Ideal value S*(S+1)"):
+            r["s2_ideal"] = _num_after_colon(line)
+        elif s.startswith("Deviation") and r["s2"] is not None and r["s2_dev"] is None:
+            r["s2_dev"] = _num_after_colon(line)
+
+        # ---------------- orbitals and Fock
+        elif s == "ORBITAL ENERGIES":
+            ea, oa, eb, ob = _orbital_energies(pb)
+            r["eps_a"], r["occ_a"] = ea, oa
+            if eb is not None:
+                r["eps_b"], r["occ_b"] = eb, ob
+        elif s == "FOCK" and r["nbas"]:
+            hdr = _next_matrix_header(pb, max_skip=6)
+            if hdr is not None:
+                F = _read_matrix(pb, r["nbas"], hdr)
+                r["fock_a"] = _tri_u_eh(F)
+                del F
+                hdr_b = _next_matrix_header(pb, max_skip=6)
+                if hdr_b is not None:
+                    Fb = _read_matrix(pb, r["nbas"], hdr_b)
+                    r["fock_b"] = _tri_u_eh(Fb)
+                    del Fb
+
+        # ---------------- population analyses
+        elif s.startswith("MULLIKEN ATOMIC CHARGES"):
+            r["mulliken_q"], r["mulliken_s"] = _atom_charges(pb)
+        elif s.startswith("LOEWDIN ATOMIC CHARGES"):
+            r["loewdin_q"], r["loewdin_s"] = _atom_charges(pb)
+        elif s.startswith("MULLIKEN REDUCED ORBITAL CHARGES"):
+            r["mulliken_shell_q"], r["mulliken_shell_s"] = _reduced_shells(pb, len(r["elements"]))
+        elif s.startswith("LOEWDIN REDUCED ORBITAL CHARGES"):
+            r["loewdin_shell_q"], r["loewdin_shell_s"] = _reduced_shells(pb, len(r["elements"]))
+        elif s.startswith("MULLIKEN OVERLAP CHARGES"):
+            r["mulliken_ovlp"] = _bond_list(pb)
+        elif s.startswith("LOEWDIN BOND ORDERS"):
+            r["loewdin_bo"] = _bond_list(pb)
+        elif s.startswith("ATOM") and "BVA" in s and "ZA" in s:
+            for k, v in _mayer_table(pb).items():
+                r[f"mayer_{k}"] = v
+        elif s.startswith("Mayer bond orders larger than"):
+            r["mayer_bo"] = _bond_list(pb)
+
+        # ---------------- NBO / NPA
+        elif "Now starting NBO" in line:
+            r["nbo_available"] = True
+        elif s.startswith("Summary of Natural Population Analysis") and r["npa_q"] is None:
+            r["npa_available"] = True
+            _npa_summary(pb, r, len(r["elements"]))
+        elif s.startswith("Atom No") and "Natural Electron Configuration" in s and r["natural_config"] is None:
+            r["natural_config"] = _natural_config(pb, len(r["elements"]))
+        elif s.startswith("Total Lewis") and r["nbo_lewis"] is None:
+            p = s.split()
+            if len(p) > 2:
+                r["nbo_lewis"] = _f(p[2])
+        elif s.startswith("Total non-Lewis") and r["nbo_nonlewis"] is None:
+            p = s.split()
+            if len(p) > 2:
+                r["nbo_nonlewis"] = _f(p[2])
+
+        # ---------------- properties
+        elif s == "DIPOLE MOMENT" and r["dipole_total"] is None:
+            _dipole(pb, r)
+        elif s == "QUADRUPOLE MOMENT" and r["quad_total"] is None:
+            _quadrupole(pb, r)
+        elif s.startswith("Rotational constants in cm-1"):
+            r["rot_const_cm"] = [float(x) for x in s.split(":")[1].split()]
+        elif s.startswith("Rotational constants in MHz"):
+            r["rot_const_mhz"] = [float(x) for x in s.split(":")[1].split()]
+        elif s.startswith("Norm of the Cartesian gradient"):
+            r["grad_norm"] = _f(_after(line, "..."))
+        elif s.startswith("RMS gradient"):
+            r["grad_rms"] = _f(_after(line, "..."))
+        elif s.startswith("MAX gradient"):
+            r["grad_max"] = _f(_after(line, "..."))
+        elif "ORCA TERMINATED NORMALLY" in line:
+            r["terminated_normally"] = True
+        elif s.startswith("TOTAL RUN TIME"):
+            m = re.search(r"(\d+) days (\d+) hours (\d+) minutes (\d+) seconds (\d+) msec", s)
+            if m:
+                d, h, mi, sec, ms = (int(x) for x in m.groups())
+                r["run_time_s"] = d * 86400 + h * 3600 + mi * 60 + sec + ms / 1000
+
+    r["coords"] = np.array(coords, dtype=np.float64) if coords else None
+    return r
+
+
+# ----------------------------------------------------------------------------- engrad
+def parse_engrad(fh):
+    """Returns (n_atoms, energy, gradient (n,3) Eh/bohr, Z (n,), coords_bohr (n,3))."""
+    lines = [l for l in fh if not l.lstrip().startswith("#") and l.strip()]
+    it = iter(lines)
+    n = int(next(it).split()[0])
+    energy = float(next(it).split()[0])
+    vals = [float(next(it).split()[0]) for _ in range(3 * n)]
+    zs, xyz = [], []
+    for _ in range(n):
+        p = next(it).split()
+        zs.append(int(p[0]))
+        xyz.append([float(x) for x in p[1:4]])
+    return n, energy, np.array(vals).reshape(n, 3), np.array(zs), np.array(xyz)
+
+
+def iter_lines(fb, encoding="utf-8", chunk=1 << 20):
+    """Yield decoded lines from a binary stream. tarfile's stream mode ('r|') hands back objects
+    that TextIOWrapper rejects (no seekable()), so decoding is done here."""
+    buf = b""
+    while True:
+        data = fb.read(chunk)
+        if not data:
+            break
+        buf += data
+        parts = buf.split(b"\n")
+        buf = parts.pop()
+        for part in parts:
+            yield part.decode(encoding, "replace")
+    if buf:
+        yield buf.decode(encoding, "replace")
+
+
+# ----------------------------------------------------------------------------- archive entry
+def parse_archive(tar_path):
+    """Stream an orca.tar.zst and parse the members we need. Never writes to disk."""
+    proc = subprocess.Popen(["zstd", "-dc", tar_path], stdout=subprocess.PIPE,
+                            stderr=subprocess.DEVNULL)
+    rec, grad = None, None
+    try:
+        with tarfile.open(fileobj=proc.stdout, mode="r|") as tf:
+            for member in tf:
+                name = os.path.basename(member.name)
+                if name == "orca.out":
+                    rec = parse_orca_out(iter_lines(tf.extractfile(member)))
+                elif name == "orca.engrad":
+                    grad = parse_engrad(iter_lines(tf.extractfile(member)))
+    finally:
+        if proc.stdout:
+            proc.stdout.close()
+        proc.wait()
+    if rec is None:
+        raise ValueError(f"no orca.out in {tar_path}")
+    if grad is not None:
+        n, e_grad, g, z, xyz_bohr = grad
+        rec["forces"] = -g
+        rec["atomic_numbers"] = z
+        rec["coords_bohr"] = xyz_bohr
+        rec["e_total_engrad"] = e_grad
+    else:
+        rec["forces"] = rec["atomic_numbers"] = None
+        rec["coords_bohr"] = rec["e_total_engrad"] = None
+    return rec

fullC/code/omol_store.py

@@ -0,0 +1,374 @@
+"""Zarr v3 shard writer for Pass A.
+
+Layout
+------
+Each worker writes self-contained *shards*, so there is no write contention and no resize logic:
+
+    store/p1/<dataset>/shard_<nnnn>_<nn>.zarr   scalars + per-atom + per-pair
+    store/p2/<dataset>/shard_<nnnn>_<nn>.zarr   the same, plus fock/, eps/, occ/
+
+p2 duplicates the p1 arrays on purpose: the tables are tiny next to the matrices (<0.2 TB for the
+whole collection) and it keeps p1 independently usable without the 6 TB matrix store.
+
+Columns are *packed*: all float scalars live in one (n_calc, n_col) array, all per-atom floats in
+one (n_atom_total, n_col) array, and so on, with the column names recorded in group attrs. Writing
+one array per column meant ~80 Zarr arrays per shard, and zarr-python's sync wrapper costs enough
+per array that shard writes dominated the run; packing cuts that to ~15 arrays.
+
+Ragged quantities are a concatenated array plus an int64 offsets array of length n_calc+1, so
+calculation i occupies [off[i], off[i+1]).
+
+Codecs follow the benchmark: Blosc zstd 9 + bit-shuffle for the int32 Fock triangles (4.5x), Blosc
+zstd 5 + byte-shuffle elsewhere.
+"""
+from __future__ import annotations
+import os
+import numpy as np
+import zarr
+from zarr.codecs import BloscCodec
+
+SHELLS = ("s", "p", "d", "f", "g")
+
+FOCK_CODEC = [BloscCodec(cname="zstd", clevel=9, shuffle="bitshuffle")]
+DATA_CODEC = [BloscCodec(cname="zstd", clevel=5, shuffle="shuffle")]
+
+SCALARS_F8 = (
+    "e_total", "e_total_engrad", "e_nuc_rep", "e_one_elec", "e_two_elec", "e_kinetic",
+    "virial_ratio", "e_xc", "e_nl", "e_exchange", "n_alpha_int", "n_beta_int",
+    "s2", "s2_ideal", "s2_dev", "conv_denergy", "conv_maxdp", "conv_rmsdp", "conv_diiserr",
+    "smallest_ovlp_eig", "grad_norm", "grad_rms", "grad_max", "run_time_s",
+    "dipole_au", "dipole_debye", "quad_iso", "npa_core", "npa_valence", "npa_rydberg",
+    "nbo_lewis", "nbo_nonlewis", "homo_a", "lumo_a", "gap_a", "homo_b", "lumo_b", "gap_b",
+)
+SCALARS_I = ("charge", "mult", "nelec", "nbas", "naux", "n_lindep", "scf_cycles", "n_atoms")
+FLAGS = ("scf_converged", "terminated_normally", "nbo_available", "npa_available",
+         "is_uhf", "has_fock")
+VEC = (("dipole_elec", 3), ("dipole_nuc", 3), ("dipole_total", 3), ("rot_const_cm", 3),
+       ("rot_const_mhz", 3), ("quad_diag", 3), ("quad_nuc", 6), ("quad_elec", 6),
+       ("quad_total", 6))
+
+ATOM_1D = ("mulliken_q", "mulliken_s", "loewdin_q", "loewdin_s",
+           "mayer_NA", "mayer_ZA", "mayer_QA", "mayer_VA", "mayer_BVA", "mayer_FA",
+           "npa_q", "npa_atom_core", "npa_atom_val", "npa_atom_ryd", "npa_spin")
+ATOM_VEC3 = ("coords", "forces")
+ATOM_SHELL = ("mulliken_shell_q", "mulliken_shell_s", "loewdin_shell_q", "loewdin_shell_s",
+              "natural_config")
+PAIRS = ("mayer_bo", "loewdin_bo", "mulliken_ovlp")
+
+ATOM_F8_COLS = [f"{k}_{ax}" for k in ATOM_VEC3 for ax in "xyz"] + list(ATOM_1D)
+VEC_COLS = [f"{name}_{i}" for name, w in VEC for i in range(w)]
+SHELL_COLS = [f"{k}_{sh}" for k in ATOM_SHELL for sh in SHELLS]
+
+
+def frontier(eps, occ):
+    """HOMO, LUMO and gap in Eh. Orbitals removed for linear dependence print as exactly 0.0."""
+    if eps is None or occ is None or len(eps) == 0:
+        return np.nan, np.nan, np.nan
+    occupied = np.flatnonzero(occ > 0)
+    if occupied.size == 0:
+        return np.nan, np.nan, np.nan
+    h = int(occupied[-1])
+    homo = float(eps[h])
+    lumo = np.nan
+    for k in range(h + 1, len(eps)):
+        if eps[k] != 0.0:
+            lumo = float(eps[k])
+            break
+    return homo, lumo, (lumo - homo if lumo == lumo else np.nan)
+
+
+def _fock_chunk_elems(median_nbas):
+    if median_nbas < 600:
+        return 65_536
+    if median_nbas <= 2000:
+        return 1_000_000
+    return 4_194_304
+
+
+CHUNKS_PER_SHARD = 256
+
+
+def put_array(g, name, data, codec=DATA_CODEC, chunks=None, overwrite=False):
+    """Create array `name` in group `g` holding `data`, using Zarr's sharding codec.
+
+    With sharding an array is a handful of files no matter how many chunks it holds. Without it
+    each chunk is a file: the first full run produced 1.5 to 4.7 files per calculation, on course
+    to exhaust the 10 M-inode scratch quota. One shard file holds CHUNKS_PER_SHARD chunks (capped
+    at the array itself), and the shard length is always a multiple of the chunk length as Zarr
+    requires. `codec=None` stores the bytes uncompressed (for incompressible fp32 coefficients).
+    """
+    data = np.ascontiguousarray(data)
+    if chunks is None:
+        if data.ndim == 1:
+            chunks = (max(1, min(data.shape[0], 1 << 22)),)
+        else:
+            chunks = (max(1, min(data.shape[0], 1 << 18)),) + data.shape[1:]
+    chunks = tuple(int(c) for c in chunks)
+    n_chunks = max(1, -(-data.shape[0] // chunks[0]))          # ceil
+    shards = (chunks[0] * min(CHUNKS_PER_SHARD, n_chunks),) + tuple(data.shape[1:])
+    if overwrite and name in g:
+        del g[name]
+    z = g.create_array(name=name, shape=data.shape, chunks=chunks, shards=shards,
+                       dtype=data.dtype, compressors=codec)
+    if data.size:
+        z[...] = data
+    return z
+
+
+def write_shard(records, out_dir, shard_name, include_matrices):
+    """Write one shard group. Records are parser outputs augmented with calc_id/rel_path/dataset."""
+    os.makedirs(out_dir, exist_ok=True)
+    path = os.path.join(out_dir, shard_name)
+    g = zarr.open_group(path, mode="w")
+    n = len(records)
+    natom = [r["n_atoms"] for r in records]
+    atom_off = np.cumsum([0] + natom).astype("i8")
+
+    def put(name, data, codec=DATA_CODEC, chunks=None):
+        put_array(g, name, data, codec=codec, chunks=chunks)
+
+    # ---- identity and column names live in attrs: JSON, portable, no bytes dtype
+    g.attrs.update({
+        "schema": "omol_elec/pass_a/2",
+        "n_calc": n,
+        "shells": list(SHELLS),
+        "scalar_f8_cols": list(SCALARS_F8),
+        "scalar_i_cols": list(SCALARS_I),
+        "flag_cols": list(FLAGS),
+        "vec_cols": VEC_COLS,
+        "atom_f8_cols": ATOM_F8_COLS,
+        "atom_shell_cols": SHELL_COLS,
+        "pair_names": list(PAIRS),
+        "calc_id": [r["calc_id"] for r in records],
+        "rel_path": [r["rel_path"] for r in records],
+        "dataset": records[0]["dataset"] if n else "",
+        "hftyp": [(r.get("hftyp") or "?") for r in records],
+        "has_matrices": bool(include_matrices),
+    })
+
+    # ---- packed scalars
+    sf = np.full((n, len(SCALARS_F8)), np.nan)
+    for i, r in enumerate(records):
+        for j, k in enumerate(SCALARS_F8):
+            v = r.get(k)
+            if v is not None:
+                sf[i, j] = v
+    put("scalar_f8", sf)
+
+    si = np.full((n, len(SCALARS_I)), -1, dtype="i8")
+    for i, r in enumerate(records):
+        for j, k in enumerate(SCALARS_I):
+            v = r.get(k)
+            if v is not None:
+                si[i, j] = v
+    put("scalar_i", si)
+
+    fl = np.zeros((n, len(FLAGS)), dtype="i1")
+    for i, r in enumerate(records):
+        for j, k in enumerate(FLAGS):
+            if k == "is_uhf":
+                fl[i, j] = bool(r.get("hftyp") == "UHF")
+            elif k == "has_fock":
+                fl[i, j] = r.get("fock_a") is not None
+            else:
+                fl[i, j] = bool(r.get(k))
+    put("flags", fl)
+
+    vv = np.full((n, len(VEC_COLS)), np.nan)
+    for i, r in enumerate(records):
+        c = 0
+        for name, w in VEC:
+            v = r.get(name)
+            if v is not None and len(v) == w:
+                vv[i, c:c + w] = v
+            c += w
+    put("vec", vv)
+
+    # ---- per-atom, packed
+    put("atom_offsets", atom_off)
+    tot = int(atom_off[-1])
+    az = np.zeros(tot, dtype="i2")
+    af = np.full((tot, len(ATOM_F8_COLS)), np.nan)
+    ash = np.full((tot, len(SHELL_COLS)), np.nan, dtype="f4")
+    for i, r in enumerate(records):
+        a, b = int(atom_off[i]), int(atom_off[i + 1])
+        z = r.get("atomic_numbers")
+        if z is not None:
+            az[a:b] = np.asarray(z, dtype="i2")
+        c = 0
+        for k in ATOM_VEC3:
+            v = r.get(k)
+            if v is not None:
+                af[a:b, c:c + 3] = np.asarray(v, dtype="f8").reshape(-1, 3)
+            c += 3
+        for k in ATOM_1D:
+            v = r.get(k)
+            if v is not None:
+                af[a:b, c] = np.asarray(v, dtype="f8")
+            c += 1
+        c = 0
+        for k in ATOM_SHELL:
+            v = r.get(k)
+            if v is not None:
+                ash[a:b, c:c + len(SHELLS)] = np.asarray(v, dtype="f4").reshape(-1, len(SHELLS))
+            c += len(SHELLS)
+    put("atom_z", az)
+    put("atom_f8", af)
+    put("atom_shell", ash)
+
+    # ---- per-pair: one offsets/index/value triple per bond-order flavour
+    for key in PAIRS:
+        idx, val, offs = [], [], [0]
+        for r in records:
+            for i, j, v in (r.get(key) or []):
+                idx.append((i, j))
+                val.append(v)
+            offs.append(len(val))
+        put(f"pair_{key}_offsets", np.array(offs, dtype="i8"))
+        put(f"pair_{key}_index", np.array(idx, dtype="i4").reshape(-1, 2))
+        put(f"pair_{key}_value", np.array(val, dtype="f4"))
+
+    # ---- orbitals and matrices (p2 only)
+    if include_matrices:
+        med = int(np.median([r["nbas"] for r in records])) if n else 1000
+        fchunk = _fock_chunk_elems(med)
+        for spin in ("a", "b"):
+            eps_parts, occ_parts, offs = [], [], [0]
+            for r in records:
+                e, o = r.get(f"eps_{spin}"), r.get(f"occ_{spin}")
+                if e is None:
+                    e, o = np.zeros(0), np.zeros(0)
+                eps_parts.append(np.asarray(e, dtype="f8"))
+                occ_parts.append(np.asarray(o, dtype="f8"))
+                offs.append(offs[-1] + len(e))
+            put(f"eps_{spin}_offsets", np.array(offs, dtype="i8"))
+            put(f"eps_{spin}", np.concatenate(eps_parts) if eps_parts else np.zeros(0))
+            put(f"occ_{spin}", np.concatenate(occ_parts) if occ_parts else np.zeros(0))
+
+            fparts, foffs = [], [0]
+            for r in records:
+                f = r.get(f"fock_{spin}")
+                f = np.zeros(0, dtype="i4") if f is None else np.asarray(f, dtype="i4")
+                fparts.append(f)
+                foffs.append(foffs[-1] + len(f))
+            flat = np.concatenate(fparts) if fparts else np.zeros(0, dtype="i4")
+            put(f"fock_{spin}_offsets", np.array(foffs, dtype="i8"))
+            put(f"fock_{spin}", flat, codec=FOCK_CODEC,
+                chunks=(max(1, min(len(flat), fchunk)),))
+    return path
+
+
+def shard_bytes(rec):
+    """Rough in-memory footprint, used to decide when to flush a shard."""
+    b = 0
+    for k in ("fock_a", "fock_b", "eps_a", "eps_b", "occ_a", "occ_b"):
+        v = rec.get(k)
+        if v is not None:
+            b += v.nbytes
+    return b + 4096
+
+
+# ----------------------------------------------------------------------------- reading
+def read_calc(g, i):
+    """Unpack calculation i from an open shard group into a dict."""
+    out = {}
+    sf = g["scalar_f8"][i]
+    for j, k in enumerate(g.attrs["scalar_f8_cols"]):
+        out[k] = float(sf[j])
+    si = g["scalar_i"][i]
+    for j, k in enumerate(g.attrs["scalar_i_cols"]):
+        out[k] = int(si[j])
+    fl = g["flags"][i]
+    for j, k in enumerate(g.attrs["flag_cols"]):
+        out[k] = bool(fl[j])
+    vv = g["vec"][i]
+    c = 0
+    for name, w in VEC:
+        out[name] = np.asarray(vv[c:c + w])
+        c += w
+    out["calc_id"] = g.attrs["calc_id"][i]
+    out["rel_path"] = g.attrs["rel_path"][i]
+    out["hftyp"] = g.attrs["hftyp"][i]
+    out["dataset"] = g.attrs["dataset"]
+
+    a, b = int(g["atom_offsets"][i]), int(g["atom_offsets"][i + 1])
+    out["atomic_numbers"] = np.asarray(g["atom_z"][a:b])
+    af = np.asarray(g["atom_f8"][a:b])
+    cols = g.attrs["atom_f8_cols"]
+    out["coords"] = af[:, [cols.index(f"coords_{x}") for x in "xyz"]]
+    out["forces"] = af[:, [cols.index(f"forces_{x}") for x in "xyz"]]
+    for k in ATOM_1D:
+        out[k] = af[:, cols.index(k)]
+    ash = np.asarray(g["atom_shell"][a:b])
+    for j, k in enumerate(ATOM_SHELL):
+        out[k] = ash[:, j * len(SHELLS):(j + 1) * len(SHELLS)]
+    for key in PAIRS:
+        p0 = int(g[f"pair_{key}_offsets"][i])
+        p1 = int(g[f"pair_{key}_offsets"][i + 1])
+        out[key] = (np.asarray(g[f"pair_{key}_index"][p0:p1]),
+                    np.asarray(g[f"pair_{key}_value"][p0:p1]))
+    if g.attrs.get("has_matrices"):
+        for spin in ("a", "b"):
+            e0 = int(g[f"eps_{spin}_offsets"][i])
+            e1 = int(g[f"eps_{spin}_offsets"][i + 1])
+            out[f"eps_{spin}"] = np.asarray(g[f"eps_{spin}"][e0:e1])
+            out[f"occ_{spin}"] = np.asarray(g[f"occ_{spin}"][e0:e1])
+            f0 = int(g[f"fock_{spin}_offsets"][i])
+            f1 = int(g[f"fock_{spin}_offsets"][i + 1])
+            out[f"fock_{spin}"] = np.asarray(g[f"fock_{spin}"][f0:f1])
+    return out
+
+
+def inflate_fock(tri, nbas):
+    """int32 micro-Hartree upper triangle -> symmetric float64 matrix in Eh."""
+    M = np.zeros((nbas, nbas))
+    M[np.triu_indices(nbas)] = tri.astype(np.float64) * 1e-6
+    return M + M.T - np.diag(M.diagonal())
+
+
+def read_mo(g, i, spin="a"):
+    """MO coefficient matrix C[ao, mo] of calculation i for one spin channel (after Pass B1).
+
+    Stored MO-major (C^T) so the occupied block is a contiguous prefix; this returns the
+    (nbas, n_stored) matrix with columns = MOs in ORCA AO order: all nbas orbitals in a full-C
+    store, the nocc occupied ones in an occupied-only store (see attrs["mo_content"]). Empty
+    (nbas, 0) when the channel is absent (beta of an RHF run) or the gbw was not paired.
+    """
+    nbas = int(g["scalar_i"][i][list(g.attrs["scalar_i_cols"]).index("nbas")])
+    o0, o1 = int(g[f"cmo_{spin}_offsets"][i]), int(g[f"cmo_{spin}_offsets"][i + 1])
+    if o1 == o0:
+        return np.zeros((nbas, 0), dtype=g[f"cmo_{spin}"].dtype)
+    # (nbas, nbas) in a full-C store, (nbas, nocc) in an occupied-only one (attrs["mo_content"])
+    return np.asarray(g[f"cmo_{spin}"][o0:o1]).reshape(-1, nbas).T
+
+
+def read_cocc(g, i):
+    """Occupied MO coefficients and gbw orbital data for calculation i (after Pass B1).
+
+    Returns C_a (nbas, nocc_a) and C_b (nbas, nocc_b) in ORCA AO order, the occupations of those
+    columns, the full gbw orbital energies and occupations, and the B1 flags. Empty arrays when the
+    gbw was not paired; check flags['mo_ok'] before trusting the pairing.
+    """
+    out = {}
+    nbas = int(g["scalar_i"][i][list(g.attrs["scalar_i_cols"]).index("nbas")])
+    mi = g["mo_i"][i]
+    for j, k in enumerate(g.attrs["mo_i_cols"]):
+        out[k] = int(mi[j])
+    mf = g["mo_f8"][i]
+    for j, k in enumerate(g.attrs["mo_f8_cols"]):
+        out[k] = float(mf[j])
+    fl = g["mo_flags"][i]
+    out["flags"] = {k: bool(fl[j]) for j, k in enumerate(g.attrs["mo_flag_cols"])}
+    for s in "ab":
+        nocc = out[f"nocc_{s}"]
+        o0, o1 = int(g[f"cmo_{s}_offsets"][i]), int(g[f"cmo_{s}_offsets"][i + 1])
+        if o1 > o0 and nocc:
+            # first nocc rows of C^T, read without touching the virtual block
+            out[f"C_{s}"] = np.asarray(g[f"cmo_{s}"][o0:o0 + nocc * nbas]).reshape(nocc, nbas).T
+        else:
+            out[f"C_{s}"] = np.zeros((nbas, 0), dtype=g[f"cmo_{s}"].dtype)
+        for name in ("gbw_eps", "gbw_occ"):
+            a, b = int(g[f"{name}_{s}_offsets"][i]), int(g[f"{name}_{s}_offsets"][i + 1])
+            out[f"{name}_{s}"] = np.asarray(g[f"{name}_{s}"][a:b])
+        out[f"cocc_occ_{s}"] = out[f"gbw_occ_{s}"][:nocc]
+    return out

fullC/code/pass_a.py

@@ -0,0 +1,150 @@
+"""Pass A driver: parse a list of OMol25 calculations and write Zarr shards.
+
+Usage (one node, all cores):
+    python pass_a.py --list subsets/subset_100k.txt --out store_100k --workers 64
+
+Usage (sbatch array): add --task-id N --n-tasks M to process a contiguous stripe.
+
+Each worker buffers records per dataset and flushes a shard once the buffer exceeds --shard-bytes,
+so shard files stay a manageable size whether the systems are 15 atoms or 250.
+"""
+from __future__ import annotations
+import argparse, os, sys, time, traceback
+import multiprocessing as mp
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from omol_parse import parse_archive
+from omol_store import write_shard, shard_bytes, frontier
+
+M5250 = "/global/cfs/projectdirs/m5250/OMol_elec"
+
+
+def dataset_of(rel):
+    parts = rel.split("/")
+    if parts[0] == "omol" and len(parts) > 2:
+        return "/".join(parts[:3])
+    return parts[0]
+
+
+def _prepare(rec, rel):
+    """Attach identity and derived scalars; drop what the store does not keep."""
+    rec["rel_path"] = rel
+    rec["calc_id"] = rel.replace("/", "__")
+    rec["dataset"] = dataset_of(rel)
+    rec["n_atoms"] = len(rec["elements"])
+    rec["homo_a"], rec["lumo_a"], rec["gap_a"] = frontier(rec.get("eps_a"), rec.get("occ_a"))
+    rec["homo_b"], rec["lumo_b"], rec["gap_b"] = frontier(rec.get("eps_b"), rec.get("occ_b"))
+    return rec
+
+
+def worker(args):
+    """Process one (dataset, chunk) unit and write exactly one p1 and one p2 shard.
+
+    Work is grouped by dataset upstream so each shard is large. Writing many small Zarr groups is
+    metadata-bound on CFS (roughly 80 arrays per shard), so few-and-large is far faster.
+    """
+    (wid, ds, chunk_idx, rels, out_root, shard_budget, task_id) = args
+    p1_root = os.path.join(out_root, "p1")
+    p2_root = os.path.join(out_root, "p2")
+    recs, buffered, n_sub = [], 0, 0
+    n_ok = n_fail = 0
+    failures = []
+    t0 = time.time()
+
+    def flush():
+        nonlocal recs, buffered, n_sub
+        if not recs:
+            return
+        name = f"shard_t{task_id:02d}_{chunk_idx:04d}_{n_sub:02d}.zarr"
+        write_shard(recs, os.path.join(p1_root, ds), name, include_matrices=False)
+        write_shard(recs, os.path.join(p2_root, ds), name, include_matrices=True)
+        n_sub += 1
+        recs, buffered = [], 0
+
+    for rel in rels:
+        tar = os.path.join(M5250, rel, "orca.tar.zst")
+        try:
+            rec = _prepare(parse_archive(tar), rel)
+            # A Fock matrix is not universal: some inputs omit Print[P_Fockian] entirely
+            # (about a quarter of omol/redo_orca6). Those rows are still complete for Project 1,
+            # so they are kept and flagged rather than dropped.
+            if rec["nbas"] is None or not rec["elements"]:
+                raise ValueError("incomplete record (nbas or geometry missing)")
+            recs.append(rec)
+            buffered += shard_bytes(rec)
+            n_ok += 1
+            if buffered > shard_budget:
+                flush()
+        except Exception as e:
+            n_fail += 1
+            failures.append(f"{rel}\t{type(e).__name__}\t{str(e)[:200]}")
+    flush()
+    dt = time.time() - t0
+    print(f"[w{wid:03d}] {ds}/{chunk_idx:04d}: ok={n_ok} fail={n_fail} "
+          f"{dt/max(len(rels),1):.2f}s/calc", flush=True)
+    return wid, n_ok, n_fail, failures, dt
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--list", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--workers", type=int, default=32)
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--task-id", type=int, default=0)
+    ap.add_argument("--n-tasks", type=int, default=1)
+    ap.add_argument("--shard-bytes", type=float, default=1.5e9)
+    ap.add_argument("--calcs-per-chunk", type=int, default=1500,
+                    help="calculations per work unit; one unit writes one shard")
+    args = ap.parse_args()
+
+    with open(args.list) as fh:
+        rels = [l.strip() for l in fh if l.strip()]
+    if args.limit:
+        rels = rels[:args.limit]
+    if args.n_tasks > 1:
+        rels = rels[args.task_id::args.n_tasks]
+    os.makedirs(args.out, exist_ok=True)
+    print(f"pass A: {len(rels):,} calculations, {args.workers} workers -> {args.out}", flush=True)
+
+    by_ds = {}
+    for rel in rels:
+        by_ds.setdefault(dataset_of(rel), []).append(rel)
+    units = []
+    for ds in sorted(by_ds):
+        lst = by_ds[ds]
+        for c, start in enumerate(range(0, len(lst), args.calcs_per_chunk)):
+            units.append((ds, c, lst[start:start + args.calcs_per_chunk]))
+    units.sort(key=lambda u: -len(u[2]))          # longest first, so the tail is short
+    jobs = [(i % args.workers, ds, c, lst, args.out, args.shard_bytes, args.task_id)
+            for i, (ds, c, lst) in enumerate(units)]
+    print(f"{len(by_ds)} datasets -> {len(jobs)} work units "
+          f"(<= {args.calcs_per_chunk} calcs each)", flush=True)
+    t0 = time.time()
+    n_ok = n_fail = 0
+    all_fail = []
+    with mp.Pool(min(args.workers, len(jobs))) as pool:
+        done = 0
+        for wid, ok, fail, failures, dt in pool.imap_unordered(worker, jobs):
+            n_ok += ok
+            n_fail += fail
+            all_fail.extend(failures)
+            done += 1
+            el = time.time() - t0
+            print(f"  units {done}/{len(jobs)}  ok={n_ok:,} fail={n_fail:,}  "
+                  f"elapsed {el/60:.1f} min  eta {el/done*(len(jobs)-done)/60:.1f} min", flush=True)
+    dt = time.time() - t0
+    fail_path = os.path.join(args.out, f"failures_task{args.task_id}.tsv")
+    if all_fail:
+        with open(fail_path, "w") as fh:
+            fh.write("rel_path\terror\tdetail\n" + "\n".join(all_fail) + "\n")
+    print(f"\nok {n_ok:,}  failed {n_fail:,}  wall {dt/60:.1f} min  "
+          f"({dt*args.workers/max(n_ok,1):.2f} core-s per calc)")
+    if all_fail:
+        print(f"failures written to {fail_path}")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("fork", force=True)   # forkserver hangs under srun on Perlmutter
+    main()

fullC/code/pass_b1.py

@@ -0,0 +1,361 @@
+"""Pass B1: molecular-orbital coefficients from the gbw files into the p2 store.
+
+For every p2 shard the worker reads each calculation's gbw (staged by Globus at
+<gbw_root>/<dataset>/<calc_id>.gbw.zstd0), takes the FULL coefficient matrix of both spin
+channels, checks that the gbw and the Pass A text describe the same calculation, and appends the
+result to the shard group. Zarr lets arrays be added to an existing group, so p2 keeps its layout
+and row order; every new array is row-aligned with the shard's existing calculations.
+
+Added arrays:
+
+    cmo_a, cmo_a_offsets        MO coefficients, MO-major: calculation i is
+                                cmo_a[o[i]:o[i+1]].reshape(nbas, nbas) = C^T, i.e. row k is MO k
+                                over the AOs (ORCA AO order). Occupied orbitals are the first
+                                nocc rows, so C_occ is a contiguous prefix. float32 by default.
+    cmo_b, cmo_b_offsets        the same for the beta channel (empty for RHF)
+    gbw_eps_a/b (+_offsets)     fp64 orbital energies of all nbas orbitals from the gbw
+    gbw_occ_a/b (+_offsets)     fp64 occupations of all nbas orbitals from the gbw
+    mo_i                        int columns: nocc_a, nocc_b, gbw_nbas, gbw_nop
+    mo_f8                       diagnostics: occ_sum_a/b; eps_err_a/b = max |gbw - printed| over
+                                the printed orbital energies; fc_offdiag_a/b = largest
+                                off-diagonal of C_occ^T F C_occ (Eh); fc_diag_err_a/b =
+                                max |diag(C_occ^T F C_occ) - eps_occ| (Eh); fc_bound_a/b = what
+                                the 5e-7 Eh print rounding of F can do to that block
+    mo_flags                    gbw_found, nbas_match, nspin_match, nelec_match, spin_match,
+                                eps_checked, eps_match, occ_contiguous, fock_checked, fock_match,
+                                mo_ok
+
+mo_ok is the conjunction of every check that could be run. fock_match is only meaningful when
+fock_checked is set (a Fock matrix was printed and nbas agreed); it asks that the printed Fock
+matrix be diagonal in the gbw's occupied orbitals to 1e-2 Eh. A mismatched pair is off by
+0.1 to 1 Eh, so the flag is a pairing test, not a convergence test. Typical values are ~1e-6 Eh,
+but in near-linearly-dependent bases (smallest overlap eigenvalue ~1e-6, not removed by ORCA)
+the 5e-7 Eh print rounding of F is amplified by the large MO coefficients into ~1e-3 Eh on the
+occupied block even though F_print agrees with C^-T diag(e) C^-1 to 1e-5 in the AO basis. The
+fc_bound columns give that rounding amplification per calculation (5e-7 x max_i ||C_i||_1^2);
+compare fc_diag_err against it before reading a large value as an inconsistency.
+
+Usage:
+    python pass_b1.py --store $PSCRATCH/omol_100k --gbw-root $PSCRATCH/gbw_100k --workers 48
+"""
+from __future__ import annotations
+import argparse, glob, json, os, sys, time, traceback
+import multiprocessing as mp
+import numpy as np
+import zarr
+
+# One thread per worker process: zarr's default pool (os.cpu_count() threads) times 64 to 96
+# forked workers thrashed a 128-core node, cutting throughput several-fold.
+zarr.config.set({"threading.max_workers": 1, "async.concurrency": 2})
+try:
+    import numcodecs.blosc
+    numcodecs.blosc.set_nthreads(1)
+    numcodecs.blosc.use_threads = False
+except Exception:
+    pass
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from gbw_reader import read_gbw
+from omol_store import put_array, inflate_fock
+
+MO_I = ("nocc_a", "nocc_b", "gbw_nbas", "gbw_nop")
+MO_F8 = ("occ_sum_a", "occ_sum_b", "eps_err_a", "eps_err_b",
+         "fc_offdiag_a", "fc_offdiag_b", "fc_diag_err_a", "fc_diag_err_b",
+         "fc_bound_a", "fc_bound_b")
+MO_FLAGS = ("gbw_found", "nbas_match", "nspin_match", "nelec_match", "spin_match",
+            "eps_checked", "eps_match", "occ_contiguous", "fock_checked", "fock_match", "mo_ok")
+INFORMATIONAL = ("eps_checked", "fock_checked", "mo_ok")
+EPS_TOL = 5e-6      # printed to 6 decimals; rounding alone gives 5e-7
+FOCK_TOL = 1e-2     # Eh; see the docstring on why the occupied block can be off by ~1e-3
+CMO_CHUNK = 1 << 22
+OLD_ARRAYS = ("cocc_a", "cocc_a_offsets", "cocc_b", "cocc_b_offsets", "cocc_occ_a",
+              "cocc_occ_a_offsets", "cocc_occ_b", "cocc_occ_b_offsets", "cocc_i", "cocc_f8",
+              "cocc_flags")
+
+
+def p2_shards(store):
+    out = []
+    for depth in ("*", "*/*/*"):
+        out += glob.glob(os.path.join(store, "p2", depth, "*.zarr"))
+    return sorted(set(out))
+
+
+def fock_check(F, C, eps):
+    """Largest off-diagonal of C^T F C and largest |diag - eps|, in Eh."""
+    M = C.T @ (F @ C)
+    d = np.diag(M).copy()
+    np.fill_diagonal(M, 0.0)
+    return float(np.abs(M).max()) if M.size else 0.0, float(np.abs(d - eps).max()) if d.size else 0.0
+
+
+def process_shard(args):
+    sp, gbw_root, force, dtype = args
+    t0 = time.time()
+    try:
+        g = zarr.open_group(sp, mode="r+")
+        if g.attrs.get("has_mo") and g.attrs.get("mo_dtype") == dtype and not force:
+            return sp, "skip", {}, [], 0.0, ""
+        n = int(g.attrs["n_calc"])
+        ids = g.attrs["calc_id"]
+        ds = g.attrs["dataset"]
+        si = np.asarray(g["scalar_i"])
+        ic = {k: j for j, k in enumerate(g.attrs["scalar_i_cols"])}
+        fl = np.asarray(g["flags"]).astype(bool)
+        fc = {k: j for j, k in enumerate(g.attrs["flag_cols"])}
+        eps = {s: np.asarray(g[f"eps_{s}"]) for s in "ab"}
+        eoff = {s: np.asarray(g[f"eps_{s}_offsets"]) for s in "ab"}
+        foff = {s: np.asarray(g[f"fock_{s}_offsets"]) for s in "ab"}
+        nbas_all = si[:, ic["nbas"]].astype("i8")
+        nsp_all = np.where(fl[:, fc["is_uhf"]], 2, 1)
+
+        # Preallocate the coefficient buffers from the text's nbas (verified against the gbw
+        # below; a mismatch leaves that calculation's slot empty and flagged).
+        cap = {s: np.zeros(n + 1, dtype="i8") for s in "ab"}
+        cap["a"][1:] = np.cumsum(nbas_all ** 2)
+        cap["b"][1:] = np.cumsum(np.where(nsp_all == 2, nbas_all ** 2, 0))
+        buf = {s: np.zeros(int(cap[s][-1]), dtype=dtype) for s in "ab"}
+        filled = {s: np.zeros(n, dtype=bool) for s in "ab"}
+        geps = {s: [] for s in "ab"}
+        gocc = {s: [] for s in "ab"}
+        mi = np.zeros((n, len(MO_I)), dtype="i8")
+        mf = np.full((n, len(MO_F8)), np.nan)
+        mfl = np.zeros((n, len(MO_FLAGS)), dtype="i1")
+        failures = []
+
+        for i in range(n):
+            nbas = int(nbas_all[i])
+            nelec = int(si[i, ic["nelec"]])
+            mult = int(si[i, ic["mult"]])
+            is_uhf = bool(fl[i, fc["is_uhf"]])
+            has_fock = bool(fl[i, fc["has_fock"]])
+            flags = dict.fromkeys(MO_FLAGS, False)
+            path = os.path.join(gbw_root, ds, ids[i] + ".gbw.zstd0")
+            gb = None
+            if os.path.exists(path):
+                try:
+                    gb = read_gbw(path)
+                    flags["gbw_found"] = True
+                except Exception as e:
+                    failures.append((ids[i], f"gbw read error: {type(e).__name__}: {str(e)[:120]}"))
+            else:
+                failures.append((ids[i], "gbw missing"))
+            if gb is None:
+                for s in "ab":
+                    geps[s].append(np.zeros(0)); gocc[s].append(np.zeros(0))
+                mfl[i] = [flags[k] for k in MO_FLAGS]
+                continue
+
+            dim, nop = gb["nbas"], gb["nop"]
+            mi[i, MO_I.index("gbw_nbas")] = dim
+            mi[i, MO_I.index("gbw_nop")] = nop
+            flags["nbas_match"] = dim == nbas
+            flags["nspin_match"] = nop == (2 if is_uhf else 1)
+            occ_sum = {}
+            contiguous = True
+            eps_ok = True
+            eps_checked = False
+            fock_checked = fock_ok = True
+            for k, s in enumerate("ab"):
+                if k >= nop:
+                    geps[s].append(np.zeros(0)); gocc[s].append(np.zeros(0))
+                    occ_sum[s] = 0.0
+                    continue
+                op = gb["ops"][k]
+                occ_v, en_v, C = op["occ"], op["energies"], op["C"]
+                mask = occ_v > 0
+                nocc = int(mask.sum())
+                idx = np.flatnonzero(mask)
+                if nocc and (idx[-1] != nocc - 1):
+                    contiguous = False
+                if dim == nbas and (s == "a" or is_uhf):
+                    # MO-major (C^T) so the occupied block is a contiguous prefix
+                    buf[s][cap[s][i]:cap[s][i + 1]] = C.T.ravel().astype(dtype, copy=False)
+                    filled[s][i] = True
+                geps[s].append(en_v.copy())
+                gocc[s].append(occ_v.copy())
+                mi[i, MO_I.index(f"nocc_{s}")] = nocc
+                occ_sum[s] = float(occ_v.sum())
+                mf[i, MO_F8.index(f"occ_sum_{s}")] = occ_sum[s]
+                # printed orbital energies (6 decimals) against the gbw. A reduced print level
+                # (the no-Fock metal_organics inputs) lists only the first few hundred orbitals,
+                # so compare over the printed prefix; energies of removed orbitals print as 0.
+                e_txt = eps[s][eoff[s][i]:eoff[s][i + 1]]
+                if 0 < len(e_txt) <= dim:
+                    eps_checked = True
+                    m = e_txt != 0.0
+                    err = float(np.abs(en_v[:len(e_txt)][m] - e_txt[m]).max()) if m.any() else 0.0
+                    mf[i, MO_F8.index(f"eps_err_{s}")] = err
+                    if err > EPS_TOL:
+                        eps_ok = False
+                elif len(e_txt) > dim:
+                    eps_checked = True
+                    eps_ok = False
+                # printed Fock diagonal in the gbw occupied orbitals
+                if has_fock and dim == nbas and nocc:
+                    f0, f1 = int(foff[s][i]), int(foff[s][i + 1])
+                    if f1 > f0:
+                        Co = np.ascontiguousarray(C[:, mask])
+                        F = inflate_fock(np.asarray(g[f"fock_{s}"][f0:f1]), nbas)
+                        od, de = fock_check(F, Co, en_v[mask])
+                        mf[i, MO_F8.index(f"fc_offdiag_{s}")] = od
+                        mf[i, MO_F8.index(f"fc_diag_err_{s}")] = de
+                        mf[i, MO_F8.index(f"fc_bound_{s}")] = 5e-7 * float(
+                            (np.abs(Co).sum(axis=0) ** 2).max())
+                        if od > FOCK_TOL or de > FOCK_TOL:
+                            fock_ok = False
+                        del F, Co
+                    else:
+                        fock_checked = False
+                else:
+                    fock_checked = False
+            tot = occ_sum["a"] + occ_sum["b"]
+            flags["nelec_match"] = abs(tot - nelec) < 1e-6
+            if nop == 2:
+                flags["spin_match"] = abs((occ_sum["a"] - occ_sum["b"]) - (mult - 1)) < 1e-6
+            else:
+                flags["spin_match"] = mult == 1 and abs(occ_sum["a"] - nelec) < 1e-6
+            flags["eps_checked"] = eps_checked
+            flags["eps_match"] = eps_ok
+            flags["occ_contiguous"] = contiguous
+            flags["fock_checked"] = fock_checked
+            flags["fock_match"] = fock_ok
+            flags["mo_ok"] = all(flags[k] for k in MO_FLAGS if k not in INFORMATIONAL)
+            mfl[i] = [flags[k] for k in MO_FLAGS]
+            if not flags["mo_ok"]:
+                bad = [k for k in MO_FLAGS if k not in INFORMATIONAL and not flags[k]]
+                failures.append((ids[i], "failed: " + ",".join(bad)))
+
+        def ragged(parts, dt):
+            offs = np.zeros(len(parts) + 1, dtype="i8")
+            offs[1:] = np.cumsum([len(p) for p in parts])
+            flat = np.concatenate(parts).astype(dt) if parts else np.zeros(0, dt)
+            return flat, offs
+
+        for name in OLD_ARRAYS:
+            if name in g:
+                del g[name]
+        for s in "ab":
+            # offsets follow the filled slots; an unfilled slot (gbw missing or nbas mismatch)
+            # gets a zero-length block so the array stays dense
+            lens = np.where(filled[s], np.diff(cap[s]), 0)
+            offs = np.zeros(n + 1, dtype="i8")
+            offs[1:] = np.cumsum(lens)
+            if filled[s].all():
+                flat = buf[s]
+            else:
+                flat = np.concatenate([buf[s][cap[s][i]:cap[s][i + 1]] for i in range(n) if filled[s][i]]
+                                      ) if filled[s].any() else np.zeros(0, dtype)
+            put_array(g, f"cmo_{s}", flat, codec=None,
+                      chunks=(max(1, min(len(flat), CMO_CHUNK)),), overwrite=True)
+            put_array(g, f"cmo_{s}_offsets", offs, overwrite=True)
+            flat, offs = ragged(geps[s], "f8")
+            put_array(g, f"gbw_eps_{s}", flat, overwrite=True)
+            put_array(g, f"gbw_eps_{s}_offsets", offs, overwrite=True)
+            flat, offs = ragged(gocc[s], "f8")
+            put_array(g, f"gbw_occ_{s}", flat, overwrite=True)
+            put_array(g, f"gbw_occ_{s}_offsets", offs, overwrite=True)
+        put_array(g, "mo_i", mi, overwrite=True)
+        put_array(g, "mo_f8", mf, overwrite=True)
+        put_array(g, "mo_flags", mfl, overwrite=True)
+        for k in ("has_cocc", "cocc_schema", "cocc_i_cols", "cocc_f8_cols", "cocc_flag_cols",
+                  "cocc_layout", "cocc_gbw_root"):
+            g.attrs.pop(k, None)
+        g.attrs.update({
+            "has_mo": True,
+            "mo_schema": "omol_elec/pass_b1/2",
+            "mo_dtype": dtype,
+            "mo_i_cols": list(MO_I),
+            "mo_f8_cols": list(MO_F8),
+            "mo_flag_cols": list(MO_FLAGS),
+            "mo_layout": "cmo_x[o[i]:o[i+1]].reshape(nbas, nbas) = C^T (row k = MO k over AOs, "
+                         "ORCA AO order); occupied MOs are the first nocc_x rows",
+            "mo_gbw_root": gbw_root,
+        })
+        stats = {
+            "n": n,
+            "found": int(mfl[:, MO_FLAGS.index("gbw_found")].sum()),
+            "ok": int(mfl[:, MO_FLAGS.index("mo_ok")].sum()),
+            "fock_checked": int(mfl[:, MO_FLAGS.index("fock_checked")].sum()),
+            "bytes_cmo": int(sum(int(g[f"cmo_{s}"].shape[0]) for s in "ab") * np.dtype(dtype).itemsize),
+            "eps_err_max": float(np.nanmax(mf[:, [2, 3]])) if np.isfinite(mf[:, [2, 3]]).any() else float("nan"),
+            "fc_offdiag_max": float(np.nanmax(mf[:, [4, 5]])) if np.isfinite(mf[:, [4, 5]]).any() else float("nan"),
+            "fc_offdiag_p50": float(np.nanmedian(mf[:, [4, 5]])) if np.isfinite(mf[:, [4, 5]]).any() else float("nan"),
+        }
+        for k in MO_FLAGS:
+            stats["fail_" + k] = int(n - mfl[:, MO_FLAGS.index(k)].sum())
+        return sp, "ok", stats, failures, time.time() - t0, ""
+    except Exception:
+        return sp, "fail", {}, [], time.time() - t0, traceback.format_exc(limit=4)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--store", required=True)
+    ap.add_argument("--gbw-root", required=True)
+    ap.add_argument("--workers", type=int, default=48)
+    ap.add_argument("--dtype", default="f4", choices=("f4", "f8"))
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--force", action="store_true", help="recompute shards that already have MOs")
+    args = ap.parse_args()
+    shards = p2_shards(args.store)
+    if args.limit:
+        shards = shards[:args.limit]
+    print(f"pass B1 (full C, {args.dtype}): {len(shards)} p2 shards in {args.store}, "
+          f"gbw from {args.gbw_root}", flush=True)
+    jobs = [(s, args.gbw_root, args.force, args.dtype) for s in shards]
+    t0 = time.time()
+    tot = {}
+    all_fail, shard_fail = [], []
+    n_skip = 0
+    eps_max = fc_max = 0.0
+    fc_p50 = []
+    with mp.Pool(min(args.workers, len(jobs))) as pool:
+        for k, (sp, status, st, failures, dt, err) in enumerate(pool.imap_unordered(process_shard, jobs), 1):
+            if status == "ok":
+                for key, v in st.items():
+                    if key.startswith(("n", "found", "ok", "fock_checked", "bytes", "fail_")):
+                        tot[key] = tot.get(key, 0) + v
+                if st["eps_err_max"] == st["eps_err_max"]:
+                    eps_max = max(eps_max, st["eps_err_max"])
+                if st["fc_offdiag_max"] == st["fc_offdiag_max"]:
+                    fc_max = max(fc_max, st["fc_offdiag_max"])
+                if st["fc_offdiag_p50"] == st["fc_offdiag_p50"]:
+                    fc_p50.append(st["fc_offdiag_p50"])
+                all_fail.extend((sp, cid, why) for cid, why in failures)
+            elif status == "skip":
+                n_skip += 1
+            else:
+                shard_fail.append((sp, err))
+                print(f"SHARD FAIL {sp}\n{err}", flush=True)
+            if k % 50 == 0 or k == len(jobs):
+                el = time.time() - t0
+                print(f"  {k}/{len(jobs)}  calcs {tot.get('n',0):,} found {tot.get('found',0):,} "
+                      f"ok {tot.get('ok',0):,}  {tot.get('bytes_cmo',0)/1e9:.0f} GB  {el/60:.1f} min  "
+                      f"eta {el/k*(len(jobs)-k)/60:.1f} min", flush=True)
+    dt = time.time() - t0
+    print(f"\nB1 done in {dt/60:.1f} min: shards ok {len(jobs)-n_skip-len(shard_fail)}, "
+          f"skipped {n_skip}, failed {len(shard_fail)}")
+    print(f"calculations {tot.get('n',0):,}: gbw found {tot.get('found',0):,}, "
+          f"mo_ok {tot.get('ok',0):,}, fock checked {tot.get('fock_checked',0):,}")
+    for k in MO_FLAGS:
+        print(f"  not {k:15s}: {tot.get('fail_'+k, 0):,}")
+    print(f"C bytes {tot.get('bytes_cmo',0)/1e12:.3f} TB  "
+          f"({tot.get('bytes_cmo',0)/max(tot.get('n',1),1)/1e6:.2f} MB/calc, {args.dtype})")
+    print(f"max eps error (gbw vs printed) {eps_max:.2e} Eh; "
+          f"C_occ^T F C_occ off-diagonal: median-of-shard-medians "
+          f"{np.median(fc_p50) if fc_p50 else float('nan'):.2e}, max {fc_max:.2e} Eh")
+    out = os.path.join(args.store, "b1_failures.tsv")
+    with open(out, "w") as fh:
+        fh.write("shard\tcalc_id\treason\n")
+        for sp, cid, why in all_fail:
+            fh.write(f"{os.path.relpath(sp, args.store)}\t{cid}\t{why}\n")
+    print(f"{len(all_fail)} per-calculation problems written to {out}")
+    with open(os.path.join(args.store, "b1_summary.json"), "w") as fh:
+        json.dump({"totals": tot, "dtype": args.dtype, "eps_err_max": eps_max,
+                   "fc_offdiag_max": fc_max, "wall_s": dt,
+                   "shard_failures": [s for s, _ in shard_fail]}, fh, indent=1)
+
+
+if __name__ == "__main__":
+    mp.set_start_method("fork", force=True)
+    main()

fullC/code/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "omol-elec-process"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "basis-set-exchange>=0.12",
+    "hdf5plugin>=7.1.0",
+    "numpy>=2.5.2",
+    "pandas>=3.0.5",
+    "pyarrow>=25.0.1",
+    "pyscf>=2.14.0",
+    "scipy>=1.18.1",
+    "tqdm>=4.70.0",
+    "zarr>=3.3.0",
+    "zstandard>=0.25.0",
+]

fullC/code/repack_store.py

@@ -0,0 +1,130 @@
+"""Re-pack a Pass A store into the sharded Zarr layout.
+
+Shards written before the 2026-09-04 fix hold one file per chunk (1.5 to 4.7 files per
+calculation); the fixed writer groups 256 chunks per file. This copies every shard group of a
+store array by array, keeping dtype, chunk shape and codecs and adding the sharding codec, and
+verifies each copy element for element before marking it done. Groups already in the sharded
+layout are copied unchanged. Safe to re-run: a destination group carrying the `repack_verified`
+attribute is skipped.
+
+    python repack_store.py --src $PSCRATCH/omol_store_100k --dst $PSCRATCH/omol_100k --workers 64
+"""
+from __future__ import annotations
+import argparse, glob, os, shutil, sys, time, traceback
+import multiprocessing as mp
+import numpy as np
+import zarr
+
+# One thread per worker process: zarr's default pool (os.cpu_count() threads) times 64 to 96
+# forked workers thrashed a 128-core node, cutting throughput several-fold.
+zarr.config.set({"threading.max_workers": 1, "async.concurrency": 2})
+try:
+    import numcodecs.blosc
+    numcodecs.blosc.set_nthreads(1)
+    numcodecs.blosc.use_threads = False
+except Exception:
+    pass
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from omol_store import CHUNKS_PER_SHARD
+
+
+def shard_paths(root):
+    out = []
+    for side in ("p1", "p2"):
+        for depth in ("*", "*/*/*"):
+            out += glob.glob(os.path.join(root, side, depth, "*.zarr"))
+    return sorted(set(out))
+
+
+def count_files(path):
+    return sum(len(fs) for _, _, fs in os.walk(path))
+
+
+def equal(a, b):
+    if a.shape != b.shape or a.dtype != b.dtype:
+        return False
+    if a.dtype.kind == "f":
+        return bool(np.array_equal(a, b, equal_nan=True))
+    return bool(np.array_equal(a, b))
+
+
+def repack_group(args):
+    src, dst = args
+    t0 = time.time()
+    try:
+        if os.path.isdir(dst):
+            if zarr.open_group(dst, mode="r").attrs.get("repack_verified"):
+                return dst, "skip", 0, 0, 0.0, ""
+            shutil.rmtree(dst)
+        gs = zarr.open_group(src, mode="r")
+        attrs = dict(gs.attrs)
+        gd = zarr.open_group(dst, mode="w")
+        gd.attrs.update(attrs)
+        for name in sorted(gs.array_keys()):
+            zs = gs[name]
+            data = np.asarray(zs[...])
+            chunks = tuple(int(c) for c in zs.chunks)
+            n_chunks = max(1, -(-zs.shape[0] // chunks[0]))
+            shards = zs.shards or ((chunks[0] * min(CHUNKS_PER_SHARD, n_chunks),)
+                                   + tuple(zs.shape[1:]))
+            zd = gd.create_array(name=name, shape=zs.shape, chunks=chunks, shards=shards,
+                                 dtype=zs.dtype, compressors=zs.compressors)
+            if data.size:
+                zd[...] = data
+            if not equal(data, np.asarray(zd[...])):
+                raise RuntimeError(f"read-back mismatch in {name}")
+        gd = zarr.open_group(dst, mode="r+")
+        if dict(gd.attrs) != attrs or sorted(gd.array_keys()) != sorted(gs.array_keys()):
+            raise RuntimeError("attrs or array list differ after copy")
+        gd.attrs["repack_verified"] = True
+        return dst, "ok", count_files(src), count_files(dst), time.time() - t0, ""
+    except Exception:
+        return dst, "fail", 0, 0, time.time() - t0, traceback.format_exc(limit=3)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--src", required=True)
+    ap.add_argument("--dst", required=True)
+    ap.add_argument("--workers", type=int, default=64)
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--pattern", default="", help="only shards whose basename contains this")
+    args = ap.parse_args()
+    src = os.path.abspath(args.src)
+    dst = os.path.abspath(args.dst)
+    shards = shard_paths(src)
+    if args.pattern:
+        shards = [s for s in shards if args.pattern in os.path.basename(s)]
+    if args.limit:
+        shards = shards[:args.limit]
+    jobs = [(s, os.path.join(dst, os.path.relpath(s, src))) for s in shards]
+    print(f"repack {len(jobs)} shard groups: {src} -> {dst}", flush=True)
+    os.makedirs(dst, exist_ok=True)
+    for f in glob.glob(os.path.join(src, "*.tsv")):
+        shutil.copy2(f, dst)
+    t0 = time.time()
+    n_ok = n_skip = n_fail = 0
+    files_in = files_out = 0
+    with mp.Pool(min(args.workers, len(jobs))) as pool:
+        for k, (path, status, fi, fo, dt, err) in enumerate(pool.imap_unordered(repack_group, jobs), 1):
+            if status == "ok":
+                n_ok += 1
+                files_in += fi
+                files_out += fo
+            elif status == "skip":
+                n_skip += 1
+            else:
+                n_fail += 1
+                print(f"FAIL {path}\n{err}", flush=True)
+            if k % 100 == 0 or k == len(jobs):
+                el = time.time() - t0
+                print(f"  {k}/{len(jobs)}  ok={n_ok} skip={n_skip} fail={n_fail}  "
+                      f"files {files_in:,} -> {files_out:,}  {el/60:.1f} min", flush=True)
+    print(f"\ndone: ok {n_ok}, skipped {n_skip}, failed {n_fail}, "
+          f"files {files_in:,} -> {files_out:,}, wall {(time.time()-t0)/60:.1f} min")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("fork", force=True)
+    main()

fullC/code/verify_store.py

@@ -0,0 +1,196 @@
+"""Verify a Pass A Zarr store: structural checks on every shard, plus a full re-parse comparison
+for a random sample of calculations. This is the gate before scaling to the full run.
+"""
+from __future__ import annotations
+import argparse, glob, os, random, sys
+import numpy as np
+import zarr
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from omol_parse import parse_archive
+from omol_store import (read_calc, inflate_fock, frontier, SCALARS_F8, SCALARS_I, FLAGS,
+                        ATOM_1D, ATOM_SHELL, PAIRS)
+
+M5250 = "/global/cfs/projectdirs/m5250/OMol_elec"
+
+
+def shard_paths(root, side):
+    out = []
+    for depth in ("*", "*/*/*"):
+        out += glob.glob(os.path.join(root, side, depth, "*.zarr"))
+    return sorted(set(out))
+
+
+def close(a, b, tol=0.0):
+    if a is None or b is None:
+        return a is None and b is None
+    a = np.asarray(a, dtype=float)
+    b = np.asarray(b, dtype=float)
+    if a.shape != b.shape:
+        return False
+    return bool(np.all((np.isnan(a) & np.isnan(b)) | (np.abs(a - b) <= tol)))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--store", required=True)
+    ap.add_argument("--sample", type=int, default=30)
+    ap.add_argument("--seed", type=int, default=7)
+    args = ap.parse_args()
+
+    p1 = shard_paths(args.store, "p1")
+    p2 = shard_paths(args.store, "p2")
+    print(f"shards: p1 {len(p1)}, p2 {len(p2)}")
+    if len(p1) != len(p2):
+        print("  ERROR: p1 and p2 shard counts differ")
+
+    total = 0
+    problems = []
+    nbas_all, natm_all, uhf_n, nofock = [], [], 0, 0
+    for sp in p2:
+        g = zarr.open_group(sp, mode="r")
+        n = int(g.attrs["n_calc"])
+        total += n
+        si = np.asarray(g["scalar_i"])
+        icol = {k: j for j, k in enumerate(g.attrs["scalar_i_cols"])}
+        nbas = si[:, icol["nbas"]]
+        natm = si[:, icol["n_atoms"]]
+        nbas_all.append(nbas)
+        natm_all.append(natm)
+        for nm, key in (("atom", "atom_offsets"), ("fock_a", "fock_a_offsets"),
+                        ("fock_b", "fock_b_offsets"), ("eps_a", "eps_a_offsets")):
+            o = np.asarray(g[key])
+            if len(o) != n + 1 or o[0] != 0 or np.any(np.diff(o) < 0):
+                problems.append(f"{os.path.basename(sp)}: bad {nm} offsets")
+        if not np.array_equal(np.diff(np.asarray(g["atom_offsets"])), natm):
+            problems.append(f"{os.path.basename(sp)}: atom offsets != n_atoms")
+        want = nbas.astype("i8") * (nbas.astype("i8") + 1) // 2
+        flags = np.asarray(g["flags"])
+        fcol = {k: j for j, k in enumerate(g.attrs["flag_cols"])}
+        is_uhf = flags[:, fcol["is_uhf"]].astype(bool)
+        has_f = flags[:, fcol["has_fock"]].astype(bool)
+        uhf_n += int(is_uhf.sum())
+        nofock += int((~has_f).sum())
+        fa = np.diff(np.asarray(g["fock_a_offsets"]))
+        if not np.array_equal(fa[has_f], want[has_f]):
+            problems.append(f"{os.path.basename(sp)}: fock_a length != nbas(nbas+1)/2")
+        if np.any(fa[~has_f] != 0):
+            problems.append(f"{os.path.basename(sp)}: fock_a stored where has_fock is false")
+        fb = np.diff(np.asarray(g["fock_b_offsets"]))
+        if np.any((fb > 0) != (is_uhf & has_f)):
+            problems.append(f"{os.path.basename(sp)}: beta Fock presence != is_uhf & has_fock")
+        if not np.array_equal(fb[is_uhf & has_f], want[is_uhf & has_f]):
+            problems.append(f"{os.path.basename(sp)}: beta Fock length wrong")
+        if len(g.attrs["calc_id"]) != n or len(g.attrs["rel_path"]) != n:
+            problems.append(f"{os.path.basename(sp)}: attrs length != n_calc")
+        if np.any(~np.asarray(g["flags"])[:, fcol["terminated_normally"]].astype(bool)):
+            problems.append(f"{os.path.basename(sp)}: some runs not terminated normally")
+    nbas_all = np.concatenate(nbas_all) if nbas_all else np.zeros(0)
+    natm_all = np.concatenate(natm_all) if natm_all else np.zeros(0)
+    print(f"calculations: {total:,}  ({uhf_n:,} UHF, {total-uhf_n:,} RHF, "
+          f"{nofock:,} without a Fock matrix)")
+    if total:
+        print(f"  nbas  min {nbas_all.min()} median {int(np.median(nbas_all))} max {nbas_all.max()}")
+        print(f"  atoms min {natm_all.min()} median {int(np.median(natm_all))} max {natm_all.max()}")
+    for p in problems[:12]:
+        print("  STRUCT ERROR:", p)
+    if not problems:
+        print("  structural checks passed on every shard")
+
+    rng = random.Random(args.seed)
+    picks = []
+    for sp in p2:
+        g = zarr.open_group(sp, mode="r")
+        n = int(g.attrs["n_calc"])
+        if n:
+            picks.append((sp, rng.randrange(n)))
+    rng.shuffle(picks)
+    picks = picks[:args.sample]
+    print(f"\nre-parse comparison on {len(picks)} calculations:")
+
+    nbad = 0
+    for sp, i in picks:
+        g = zarr.open_group(sp, mode="r")
+        stored = read_calc(g, i)
+        rel = stored["rel_path"]
+        fresh = parse_archive(os.path.join(M5250, rel, "orca.tar.zst"))
+        fresh["n_atoms"] = len(fresh["elements"])
+        fresh["homo_a"], fresh["lumo_a"], fresh["gap_a"] = frontier(fresh["eps_a"], fresh["occ_a"])
+        fresh["homo_b"], fresh["lumo_b"], fresh["gap_b"] = frontier(fresh["eps_b"], fresh["occ_b"])
+        bad = []
+        for k in SCALARS_F8:
+            a, b = stored[k], fresh.get(k)
+            if b is None:
+                continue
+            if not close(a, b, tol=abs(float(b)) * 1e-12 + 1e-12):
+                bad.append(f"{k}: {a} vs {b}")
+        for k in SCALARS_I:
+            b = fresh.get(k)
+            if b is not None and stored[k] != int(b):
+                bad.append(f"{k}: {stored[k]} vs {b}")
+        for k in ("scf_converged", "terminated_normally", "nbo_available", "npa_available"):
+            if stored[k] != bool(fresh.get(k)):
+                bad.append(f"{k}: {stored[k]} vs {fresh.get(k)}")
+        if stored["is_uhf"] != (fresh["hftyp"] == "UHF"):
+            bad.append("is_uhf mismatch")
+        if not close(stored["coords"], fresh["coords"], 1e-9):
+            bad.append("coords differ")
+        if fresh["forces"] is not None and not close(stored["forces"], fresh["forces"], 1e-12):
+            bad.append("forces differ")
+        if fresh["atomic_numbers"] is not None and not np.array_equal(
+                stored["atomic_numbers"], fresh["atomic_numbers"]):
+            bad.append("atomic numbers differ")
+        for k in ATOM_1D:
+            if fresh.get(k) is not None and not close(stored[k], fresh[k], 1e-9):
+                bad.append(f"{k} differs")
+        for k in ATOM_SHELL:
+            if fresh.get(k) is not None and not close(stored[k], fresh[k], 2e-5):
+                bad.append(f"{k} differs")
+        for k in PAIRS:
+            idx, val = stored[k]
+            ref = fresh.get(k) or []
+            if len(val) != len(ref):
+                bad.append(f"{k} count {len(val)} vs {len(ref)}")
+            elif ref:
+                if (not np.array_equal(idx, np.array([[a, b] for a, b, _ in ref]))
+                        or not close(val, np.array([v for _, _, v in ref]), 1e-4)):
+                    bad.append(f"{k} content differs")
+        if fresh["fock_a"] is None:
+            if stored["has_fock"] or len(stored["fock_a"]):
+                bad.append("fock_a stored but source has none")
+        elif not np.array_equal(stored["fock_a"], fresh["fock_a"]):
+            bad.append("fock_a differs")
+        fb = fresh.get("fock_b")
+        if fb is None:
+            if len(stored["fock_b"]):
+                bad.append("fock_b present but should be absent")
+        elif not np.array_equal(stored["fock_b"], fb):
+            bad.append("fock_b differs")
+        if not close(stored["eps_a"], fresh["eps_a"], 1e-12):
+            bad.append("eps_a differs")
+        if stored["has_fock"]:
+            F = inflate_fock(stored["fock_a"], stored["nbas"])
+            if np.abs(F - F.T).max() != 0:
+                bad.append("inflated Fock not symmetric")
+        if bad:
+            nbad += 1
+            print(f"  MISMATCH {rel}")
+            for b in bad[:6]:
+                print(f"      {b}")
+        else:
+            print(f"  ok  {rel[:76]}")
+    print(f"\n{len(picks)-nbad}/{len(picks)} exact, {len(problems)} structural problems")
+
+    def du(p):
+        return sum(os.path.getsize(os.path.join(r, f)) for r, _, fs in os.walk(p) for f in fs)
+    b1 = sum(du(p) for p in p1)
+    b2 = sum(du(p) for p in p2)
+    print(f"\nsize: p1 {b1/1e9:.3f} GB ({b1/max(total,1)/1e3:.1f} kB/calc), "
+          f"p2 {b2/1e9:.3f} GB ({b2/max(total,1)/1e6:.3f} MB/calc)")
+    if total:
+        print(f"extrapolated to 3.73 M: p1 {b1/total*3.73e6/1e12:.2f} TB, "
+              f"p2 {b2/total*3.73e6/1e12:.2f} TB")
+
+
+if __name__ == "__main__":
+    main()

fullC/failures_task3.tsv

@@ -0,0 +1,2 @@
+rel_path	error	detail
+pdb_fragments_400K/4d42_EBS02_state0_0_1_ZINC000004179832_ligstate0_-1_1	ReadError	empty file

fullC/p2/ml_elytes/group_000.zarr/atom_shell/zarr.json

@@ -0,0 +1,68 @@
+{
+  "shape": [
+    80773,
+    25
+  ],
+  "data_type": "float32",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        81880,
+        25
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          8188,
+          25
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 4,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/atom_z/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    80773
+  ],
+  "data_type": "int16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        81880
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          8188
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 2,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/cmo_a_offsets/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    563
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        563
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          563
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/cmo_b/zarr.json

@@ -0,0 +1,55 @@
+{
+  "shape": [
+    304516765
+  ],
+  "data_type": "float32",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        268435456
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          4194304
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/eps_b_offsets/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    563
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        563
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          563
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/fock_a_offsets/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    563
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        563
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          563
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/gbw_eps_a/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    1750480
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1809760
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          180976
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/gbw_eps_b/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    94663
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        95705
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          19141
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/gbw_occ_a/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    1750480
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1809760
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          180976
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/gbw_occ_b/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    94663
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        95705
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          19141
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/mo_f8/zarr.json

@@ -0,0 +1,68 @@
+{
+  "shape": [
+    562,
+    10
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        600,
+        10
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          60,
+          10
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/occ_a/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    1750480
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1809760
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          180976
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/pair_loewdin_bo_value/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    238967
+  ],
+  "data_type": "float32",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        245930
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          24593
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 4,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/pair_mayer_bo_value/zarr.json

@@ -0,0 +1,65 @@
+{
+  "shape": [
+    159446
+  ],
+  "data_type": "float32",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        164350
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          16435
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 4,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/pair_mulliken_ovlp_index/zarr.json

@@ -0,0 +1,68 @@
+{
+  "shape": [
+    534826,
+    2
+  ],
+  "data_type": "int32",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        557680,
+        2
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          55768,
+          2
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 4,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/p2/ml_elytes/group_000.zarr/scalar_f8/zarr.json

@@ -0,0 +1,68 @@
+{
+  "shape": [
+    562,
+    38
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        600,
+        38
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "sharding_indexed",
+      "configuration": {
+        "chunk_shape": [
+          60,
+          38
+        ],
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "blosc",
+            "configuration": {
+              "typesize": 8,
+              "cname": "zstd",
+              "clevel": 5,
+              "shuffle": "shuffle",
+              "blocksize": 0
+            }
+          }
+        ],
+        "index_codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "crc32c"
+          }
+        ],
+        "index_location": "end"
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}

fullC/subset_100k_counts.tsv

@@ -0,0 +1,45 @@
+dataset	population	sampled	pct_of_dataset
+ani1xbb	737210	18494	2.509
+omol/metal_organics/restart5to6	364470	9309	2.554
+omol/solvated_protein/outputs_240923	335669	8373	2.494
+omol/electrolytes/solvated_090624	302916	7609	2.512
+ani2x	215642	5480	2.541
+trans1x	213731	5309	2.484
+geom_orca6	199805	5055	2.530
+omol/electrolytes/md_based	165660	4183	2.525
+tm_react	158190	3910	2.472
+omol/metal_organics/outputs_low_spin_241118	97884	2570	2.626
+pdb_fragments_300K	93334	2369	2.538
+pdb_fragments_400K	92698	2209	2.383
+ml_mo	77603	1955	2.519
+rgd_uks	75316	1902	2.525
+electrolytes_reactivity	66974	1651	2.465
+ml_protein_interface	61859	1473	2.381
+omol/metal_organics/outputs_072324	60890	1531	2.514
+scaled_separations_exp	53219	1326	2.492
+ml_elytes	51599	1320	2.558
+orbnet_denali	51102	1275	2.495
+pmechdb	49832	1228	2.464
+omol/solvated_protein/outputs_241002	46667	1188	2.546
+electrolytes_redox	46081	1183	2.567
+protein_interface	44972	1140	2.535
+spice	44450	1143	2.571
+protein_core	35406	874	2.469
+rna	34745	841	2.420
+electrolytes_scaled_sep	30769	782	2.542
+omol/electrolytes/outputs_unsolvated_120424	29054	722	2.485
+dna	24647	585	2.374
+droplet	18694	433	2.316
+rpmd	18652	449	2.407
+pdb_pockets_300K	16927	459	2.712
+5A_elytes	14202	353	2.486
+omol/metal_organics/outputs_ln_082524	14195	360	2.536
+low_spin_23	12939	282	2.179
+omol/redo_orca6/metal_organics	7555	161	2.131
+nakb	5606	137	2.444
+omol/torsion_profiles/outputs_120324	4248	98	2.307
+mo_hydrides	3396	93	2.739
+pdb_pockets_400K	3210	64	1.994
+rmechdb	2803	70	2.497
+noble_gas	1915	52	2.715
+noble_gas_compounds	18	0	0.000

occC/b1_failures.tsv

@@ -0,0 +1,2 @@
+shard	calc_id	reason
+p2/ani1xbb/shard_t03_0005_00.zarr	ani1xbb__aniBB_022_377503_0_3	failed: fock_match

occC/b1_summary.json

@@ -0,0 +1,25 @@
+{
+ "totals": {
+  "n": 99999,
+  "found": 99999,
+  "ok": 99998,
+  "fock_checked": 99954,
+  "bytes_cmo": 1521762062968,
+  "fail_gbw_found": 0,
+  "fail_nbas_match": 0,
+  "fail_nspin_match": 0,
+  "fail_nelec_match": 0,
+  "fail_spin_match": 0,
+  "fail_eps_checked": 0,
+  "fail_eps_match": 0,
+  "fail_occ_contiguous": 0,
+  "fail_fock_checked": 45,
+  "fail_fock_match": 1,
+  "fail_mo_ok": 1
+ },
+ "dtype": "f4",
+ "eps_err_max": 4.999999996257998e-07,
+ "fc_offdiag_max": 0.002244156607543126,
+ "wall_s": 1131.7759289741516,
+ "shard_failures": []
+}

occC/failures_task3.tsv

@@ -0,0 +1,2 @@
+rel_path	error	detail
+pdb_fragments_400K/4d42_EBS02_state0_0_1_ZINC000004179832_ligstate0_-1_1	ReadError	empty file

occC/subset_100k_counts.tsv

@@ -0,0 +1,45 @@
+dataset	population	sampled	pct_of_dataset
+ani1xbb	737210	18494	2.509
+omol/metal_organics/restart5to6	364470	9309	2.554
+omol/solvated_protein/outputs_240923	335669	8373	2.494
+omol/electrolytes/solvated_090624	302916	7609	2.512
+ani2x	215642	5480	2.541
+trans1x	213731	5309	2.484
+geom_orca6	199805	5055	2.530
+omol/electrolytes/md_based	165660	4183	2.525
+tm_react	158190	3910	2.472
+omol/metal_organics/outputs_low_spin_241118	97884	2570	2.626
+pdb_fragments_300K	93334	2369	2.538
+pdb_fragments_400K	92698	2209	2.383
+ml_mo	77603	1955	2.519
+rgd_uks	75316	1902	2.525
+electrolytes_reactivity	66974	1651	2.465
+ml_protein_interface	61859	1473	2.381
+omol/metal_organics/outputs_072324	60890	1531	2.514
+scaled_separations_exp	53219	1326	2.492
+ml_elytes	51599	1320	2.558
+orbnet_denali	51102	1275	2.495
+pmechdb	49832	1228	2.464
+omol/solvated_protein/outputs_241002	46667	1188	2.546
+electrolytes_redox	46081	1183	2.567
+protein_interface	44972	1140	2.535
+spice	44450	1143	2.571
+protein_core	35406	874	2.469
+rna	34745	841	2.420
+electrolytes_scaled_sep	30769	782	2.542
+omol/electrolytes/outputs_unsolvated_120424	29054	722	2.485
+dna	24647	585	2.374
+droplet	18694	433	2.316
+rpmd	18652	449	2.407
+pdb_pockets_300K	16927	459	2.712
+5A_elytes	14202	353	2.486
+omol/metal_organics/outputs_ln_082524	14195	360	2.536
+low_spin_23	12939	282	2.179
+omol/redo_orca6/metal_organics	7555	161	2.131
+nakb	5606	137	2.444
+omol/torsion_profiles/outputs_120324	4248	98	2.307
+mo_hydrides	3396	93	2.739
+pdb_pockets_400K	3210	64	1.994
+rmechdb	2803	70	2.497
+noble_gas	1915	52	2.715
+noble_gas_compounds	18	0	0.000