File size: 6,791 Bytes
39ea985 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | """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()
|