| """Round-trip verification of the TRIP50 release artefacts. |
| |
| Three checks, run in order: |
| |
| 1. MANIFEST.sha256 matches every payload file's actual digest. |
| 2. Recomputed per-method MAE table from species.parquet reproduces the |
| published trip50_dft_mae.csv to within 0.005 kcal/mol per cell. |
| 3. Extended-XYZ round-trip: every frame's species_id, atomic_numbers, and |
| positions agree with species.parquet to within 1e-7 Å (extxyz default |
| 8-digit precision). |
| |
| Run from the release root or the examples/ directory. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| from ase.io import read |
|
|
| ROOT = Path(__file__).resolve().parent.parent |
| DATA = ROOT / "data" |
| PRODUCTION = Path("/Users/rpaton/TRIP50/production") |
|
|
| sys.path.insert(0, str(ROOT / "scripts")) |
| from trip50_core import reaction_quantities |
|
|
| POSITION_TOL = 1e-7 |
| MAE_TOL = 0.005 |
|
|
|
|
| def check_manifest() -> int: |
| manifest = DATA / "MANIFEST.sha256" |
| failed = 0 |
| for line in manifest.read_text().strip().splitlines(): |
| digest, name = line.split(" ", 1) |
| actual = hashlib.sha256((DATA / name).read_bytes()).hexdigest() |
| ok = actual == digest |
| print(f" {'ok ' if ok else 'BAD'} {name}") |
| if not ok: |
| failed += 1 |
| return failed |
|
|
|
|
| def _build_series(species: pd.DataFrame, slug_to_canonical: dict[str, str]) -> dict[str, pd.Series]: |
| """For every method slug, return a Series indexed by species_id (post-alias |
| canonical names) with energies in Hartree.""" |
| out = {} |
| for slug, _display in slug_to_canonical.items(): |
| out[slug] = species.set_index("species_id")[slug] |
| return out |
|
|
|
|
| def check_mae_table() -> int: |
| species = pd.read_parquet(DATA / "species.parquet") |
| methods = pd.read_json(DATA / "methods.json")["energy_columns"] |
| slug_to_display = {m["slug"]: m["display_name"] for m in methods} |
| aliases_df = pd.read_parquet(DATA / "aliases.parquet") |
| alias_map = dict(zip(aliases_df["alias"], aliases_df["canonical"])) |
|
|
| sp_indexed = species.set_index("species_id") |
| dlpno = sp_indexed["energy_dlpno_ccsd_t"] |
| ref_rxn, ref_fwd, ref_rev = reaction_quantities(dlpno, dlpno, alias_map) |
|
|
| pub_path = PRODUCTION / "trip50_dft_mae.csv" |
| if not pub_path.exists(): |
| print(f" SKIP: {pub_path} not present (offline verification only)") |
| return 0 |
| pub = pd.read_csv(pub_path).set_index("Theory") |
|
|
| failed = 0 |
| for slug, display in slug_to_display.items(): |
| if display == "DLPNO-CCSD(T)" or display not in pub.index: |
| continue |
| col = sp_indexed[slug] |
| t_rxn, t_fwd, t_rev = reaction_quantities(col, dlpno, alias_map) |
| keys = sorted(set(ref_rxn) & set(t_rxn)) |
| mae_rxn = sum(abs(ref_rxn[k] - t_rxn[k]) for k in keys) / len(keys) |
| mae_fwd = sum(abs(ref_fwd[k] - t_fwd[k]) for k in keys) / len(keys) |
| mae_rev = sum(abs(ref_rev[k] - t_rev[k]) for k in keys) / len(keys) |
| diffs = [ |
| abs(round(mae_rxn, 3) - pub.loc[display, "ΔE_rxn (P-R)"]), |
| abs(round(mae_fwd, 3) - pub.loc[display, "ΔE_fwd (TS-R)"]), |
| abs(round(mae_rev, 3) - pub.loc[display, "ΔE_rev (TS-P)"]), |
| ] |
| ok = max(diffs) < MAE_TOL |
| if not ok: |
| failed += 1 |
| print(f" BAD {display}: max abs diff = {max(diffs):.4f} kcal/mol") |
| print(f" {'ok ' if failed == 0 else 'BAD'} MAE table reproduces " |
| f"trip50_dft_mae.csv (max tol {MAE_TOL})") |
| return failed |
|
|
|
|
| def check_extxyz_roundtrip() -> int: |
| frames = read(DATA / "trip50.extxyz", index=":") |
| species = pd.read_parquet(DATA / "species.parquet").set_index("species_id") |
| failed = 0 |
| for atoms in frames: |
| sid = atoms.info.get("species_id") |
| if sid is None or sid not in species.index: |
| print(f" BAD frame missing/unknown species_id: {sid!r}") |
| failed += 1 |
| continue |
| row = species.loc[sid] |
| if atoms.numbers.tolist() != list(row["atomic_numbers"]): |
| print(f" BAD {sid}: atomic_numbers mismatch") |
| failed += 1 |
| continue |
| pos = np.asarray(row["positions"].tolist()) |
| max_dev = float(np.abs(atoms.positions - pos).max()) |
| if max_dev > POSITION_TOL: |
| print(f" BAD {sid}: positions max dev {max_dev:.2e} Å > {POSITION_TOL}") |
| failed += 1 |
| print(f" {'ok ' if failed == 0 else 'BAD'} extxyz round-trip " |
| f"({len(frames)} frames, tol {POSITION_TOL} Å)") |
| return failed |
|
|
|
|
| def main() -> int: |
| print("MANIFEST") |
| f1 = check_manifest() |
| print("\nMAE table") |
| f2 = check_mae_table() |
| print("\nExtxyz round-trip") |
| f3 = check_extxyz_roundtrip() |
| total = f1 + f2 + f3 |
| print(f"\n{'PASS' if total == 0 else 'FAIL'} ({total} failure(s))") |
| return total |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
