Download grid_cost_diagnostics/reference_sensitivity.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 10.9 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/grid_cost_diagnostics/reference_sensitivity.py
- Command line
-
hf download hf://soundai2016/ADComp/grid_cost_diagnostics/reference_sensitivity.py
-
curl -L -o reference_sensitivity.py https://huggingface.co/soundai2016/ADComp/resolve/main/grid_cost_diagnostics/reference_sensitivity.py
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() | |