ADComp / grid_cost_diagnostics /reference_sensitivity.py
Bobchen1980's picture
Upload folder using huggingface_hub
68db0a3 verified
Raw History Blame Contribute Delete
10.9 kB
#!/usr/bin/env python3
"""Conditional h^2 Richardson comparators for the fixed receiver-cost sweep.
The extrapolated responses assume leading h^2 error; they do not certify
continuum error. Candidate waveforms and construction times are unchanged.
"""
import os
for name in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS"):
os.environ[name] = "1"
import argparse
import csv
import hashlib
import json
from pathlib import Path
import numpy as np
HERE = Path(__file__).resolve().parent
ROOT = HERE.parent
OUT = HERE / "results"
LABELS = ("grid512", "grid384", "richardson512", "richardson384")
def digest(path):
sha = hashlib.sha256()
with path.open("rb") as stream:
for block in iter(lambda: stream.read(1024 * 1024), b""):
sha.update(block)
return sha.hexdigest()
def relative(value, reference):
return float(np.sqrt(np.sum((value-reference)**2)/np.sum(reference**2)))
def write_csv(path, rows):
with path.open("w", newline="") as stream:
writer = csv.DictWriter(stream, fieldnames=list(rows[0]))
writer.writeheader()
writer.writerows(rows)
def dump(path, value):
path.write_text(json.dumps(value, indent=2, allow_nan=False)+"\n")
def key(row):
return (row["material"], row["grid"], row["method"], row["requested_cfl"])
def winner(rows, label, tolerance, family):
feasible = [r for r in rows if r[label+"_error"] <= tolerance
and r["family"] == family]
return min(feasible, key=lambda r: r["median_seconds"]) if feasible else None
def calculate():
cfg = json.loads((HERE/"config.json").read_text())
inputs = {}
references, differences = {}, []
formula_defects = []
times = np.linspace(0, cfg["time_end"], cfg["samples"])
for material in cfg["materials"]:
raw = {}
for n in (256, 384, 512):
path = ROOT/"propagation"/"results"/f"{material}_n{n}.npz"
with np.load(path) as data:
np.testing.assert_array_equal(data["time"], times)
raw[n] = data["receiver_pressure"].copy()
assert raw[n].shape == (len(times), 4, 3)
inputs[str(path.relative_to(ROOT))] = digest(path)
ext512 = raw[512]+(9/7)*(raw[512]-raw[384])
ext384 = raw[384]+(4/5)*(raw[384]-raw[256])
references[material] = {"grid512": raw[512], "grid384": raw[384],
"richardson512": ext512, "richardson384": ext384}
formula_defects.extend([relative(ext512, (16*raw[512]-9*raw[384])/7),
relative(ext384, (9*raw[384]-4*raw[256])/5)])
differences.append({
"material": material,
"extrapolant_difference_relative_to_richardson512": relative(ext384, ext512),
"grid512_difference_relative_to_richardson512": relative(raw[512], ext512),
"grid384_difference_relative_to_richardson384": relative(raw[384], ext384),
"largest_source_extrapolant_difference": max(relative(ext384[:,:,s], ext512[:,:,s]) for s in range(3)),
"largest_channel_extrapolant_difference": max(relative(ext384[:,r,s], ext512[:,r,s]) for r in range(4) for s in range(3)),
})
records = sorted((OUT/"candidates").glob("*_timing.json"))
prescribed = {(m,n,"full_stormer_verlet",c) for m in cfg["materials"]
for n in cfg["grids"] for c in cfg["explicit_cfl_values"]}
prescribed |= {(m,n,"craig_bampton",None) for m in cfg["materials"] for n in cfg["grids"]}
candidates = []
for path in records:
timing = json.loads(path.read_text())
rawpath = path.with_name(path.name.replace("_timing.json", ".npz"))
assert digest(rawpath) == timing["raw_sha256"]
inputs[str(path.relative_to(ROOT))] = digest(path)
inputs[str(rawpath.relative_to(ROOT))] = timing["raw_sha256"]
with np.load(rawpath) as data:
np.testing.assert_array_equal(data["time"], times)
y = data["receiver_pressure"].copy()
totals = [sum(r.values()) for r in timing["repetitions"]]
assert float(np.median(totals)) == timing["median"]["total_seconds"]
row = {name: timing[name] for name in ("material", "grid", "method", "modes_per_patch", "requested_cfl", "dimension")}
row.update(family="full" if timing["method"].startswith("full_") else "reduced",
median_seconds=float(np.median(totals)),
minimum_seconds=min(totals), maximum_seconds=max(totals))
for label in LABELS:
row[label+"_error"] = relative(y, references[row["material"]][label])
candidates.append(row)
assert {key(row) for row in candidates} == prescribed
assert len(candidates) == len(prescribed)
selections = []
for material in cfg["materials"]:
rows = [r for r in candidates if r["material"] == material]
for tolerance in cfg["receiver_tolerances"]:
primary = {f: winner(rows, "grid512", tolerance, f) for f in ("full", "reduced")}
for label in LABELS:
selected = {f: winner(rows, label, tolerance, f) for f in ("full", "reduced")}
row = {"material": material, "tolerance": tolerance, "comparator": label}
for family, candidate in selected.items():
row[family+"_feasible"] = candidate is not None
for attr in ("grid", "method", "dimension", "requested_cfl", "median_seconds", "minimum_seconds", "maximum_seconds"):
row[family+"_"+attr] = None if candidate is None else candidate[attr]
row[family+"_error"] = None if candidate is None else candidate[label+"_error"]
row[family+"_selection_changed_from_grid512"] = (
(None if candidate is None else key(candidate)) !=
(None if primary[family] is None else key(primary[family])))
samefamily = [r for r in rows if r["family"] == family]
row[family+"_pass_to_fail_from_grid512"] = sum(
r["grid512_error"] <= tolerance < r[label+"_error"] for r in samefamily)
row[family+"_fail_to_pass_from_grid512"] = sum(
r[label+"_error"] <= tolerance < r["grid512_error"] for r in samefamily)
full, reduced = selected["full"], selected["reduced"]
both = full is not None and reduced is not None
row["median_full_over_reduced"] = full["median_seconds"]/reduced["median_seconds"] if both else None
row["fastest_full_over_slowest_reduced"] = full["minimum_seconds"]/reduced["maximum_seconds"] if both else None
row["slowest_full_over_fastest_reduced"] = full["maximum_seconds"]/reduced["minimum_seconds"] if both else None
selections.append(row)
old = list(csv.DictReader((OUT/"receiver_errors.csv").open()))
old_by_key = {(r["material"], int(r["grid"]), r["method"], None if r["requested_cfl"] in ("", "None") else float(r["requested_cfl"])):r for r in old}
replay = max(abs(r[label+"_error"]-float(old_by_key[key(r)][column]))
for r in candidates for label,column in (("grid512","total_receiver_error"), ("grid384","alternative_reference_total_receiver_error")))
assert replay < 1e-13 and max(formula_defects) < 1e-14
inputs[str((OUT/"receiver_errors.csv").relative_to(ROOT))] = digest(OUT/"receiver_errors.csv")
summary = {
"scope": "Conditional Richardson comparators under a leading h^2 waveform-error expansion. Neither extrapolant is a known exact solution or a rigorous error bound.",
"formulas": {"richardson512": "Y512 + (9/7)*(Y512-Y384)", "richardson384": "Y384 + (4/5)*(Y384-Y256)"},
"norm": "Equal-weight Frobenius norm over all 641 times including t=0, four receivers and three sources. Each candidate error uses the corresponding comparator norm.",
"cost": "Unchanged median, minimum and maximum of the three original setup-inclusive stage sums. No construction or timing is repeated.",
"candidate_count": len(candidates), "reference_differences": differences,
"mean_extrapolant_difference": float(np.mean([r["extrapolant_difference_relative_to_richardson512"] for r in differences])),
"selections": selections, "input_sha256": inputs,
"config_sha256": digest(HERE/"config.json"), "analysis_code_sha256": digest(Path(__file__)),
"maximum_previous_error_replay_difference": replay,
"maximum_alternative_formula_difference": max(formula_defects),
}
return candidates, differences, selections, summary
def verify(candidates, differences, selections, summary):
previous = json.loads((OUT/"richardson_summary.json").read_text())
assert previous == summary
maximum = 0.0
for name, rows in (("candidate_errors",candidates), ("reference_differences",differences), ("selections",selections)):
saved = list(csv.DictReader((OUT/f"richardson_{name}.csv").open()))
assert len(saved) == len(rows)
for old, new in zip(saved, rows):
for k,v in new.items():
if isinstance(v, float):
maximum = max(maximum, abs(float(old[k])-v))
else:
assert old[k] == ("" if v is None else str(v))
assert maximum < 1e-13
# The two Richardson weight pairs preserve constants and cancel h^2.
h2_defect = max(abs(16/7/512**2-9/7/384**2), abs(9/5/384**2-4/5/256**2))
assert h2_defect < 1e-20
result = {"status":"pass", "candidate_errors_recomputed":len(candidates)*len(LABELS),
"least_cost_selections_recomputed":len(selections)*2,
"input_hashes_recomputed":len(summary["input_sha256"]),
"maximum_saved_numeric_difference":maximum,
"maximum_previous_error_replay_difference":summary["maximum_previous_error_replay_difference"],
"maximum_alternative_formula_difference":summary["maximum_alternative_formula_difference"],
"leading_h_squared_cancellation_defect":h2_defect,
"no_timing_repeated":True}
dump(OUT/"richardson_verification.json", result)
return result
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--verify", action="store_true", help="Recompute and compare the saved postprocessing outputs")
args = parser.parse_args()
candidates, differences, selections, summary = calculate()
if not args.verify:
for name,rows in (("candidate_errors",candidates), ("reference_differences",differences), ("selections",selections)):
write_csv(OUT/f"richardson_{name}.csv", rows)
dump(OUT/"richardson_summary.json", summary)
print(json.dumps(verify(candidates, differences, selections, summary), indent=2))
if __name__ == "__main__":
main()