"""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()