Download frequency_diagnostics/richardson.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/frequency_diagnostics/richardson.py
- Command line
-
hf download hf://soundai2016/ADComp/frequency_diagnostics/richardson.py
-
curl -L -o richardson.py https://huggingface.co/soundai2016/ADComp/resolve/main/frequency_diagnostics/richardson.py
11.5 kB
| #!/usr/bin/env python3 | |
| """Compare fixed frequency interventions under h^2-extrapolated references.""" | |
| from __future__ import annotations | |
| import os | |
| for _key in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS"): | |
| os.environ[_key] = "2" | |
| import argparse | |
| import csv | |
| import hashlib | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| HERE = Path(__file__).resolve().parent | |
| SOURCE = HERE.parent | |
| MATERIALS = ("rotated_stripes", "double_inclusion", "smooth_checker") | |
| def load_npz(path): | |
| with np.load(path, allow_pickle=False) as z: | |
| return {key: z[key] for key in z.files} | |
| def write_json(path, value): | |
| path.write_text(json.dumps(value, indent=2, allow_nan=False) + "\n") | |
| 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 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 main(): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--output", type=Path, default=HERE / "results") | |
| args = parser.parse_args() | |
| out = args.output.resolve() | |
| out.mkdir(parents=True, exist_ok=True) | |
| rows, replay, inputs, formula_defects, margin_absolute, margin_scaled = [], [], [], [], [], [] | |
| for material in MATERIALS: | |
| print(f"Richardson reference comparison: {material}", flush=True) | |
| reference = {} | |
| for n in (256, 384, 512): | |
| path = SOURCE / "propagation/results" / f"{material}_n{n}.npz" | |
| data = load_npz(path) | |
| if reference: | |
| np.testing.assert_array_equal(data["time"], times) | |
| times = data["time"] | |
| reference[f"grid{n}"] = data["receiver_pressure"] | |
| inputs.append(path) | |
| reference["richardson512"] = reference["grid512"] + 9 / 7 * (reference["grid512"] - reference["grid384"]) | |
| reference["richardson384"] = reference["grid384"] + 4 / 5 * (reference["grid384"] - reference["grid256"]) | |
| formula_defects.extend([ | |
| float(np.max(abs(reference["richardson512"] - (16 * reference["grid512"] - 9 * reference["grid384"]) / 7))), | |
| float(np.max(abs(reference["richardson384"] - (9 * reference["grid384"] - 4 * reference["grid256"]) / 5)))]) | |
| rompath = SOURCE / "accuracy_cost/results" / f"{material}_n32_craig_bampton_m32.npz" | |
| coarsepath = SOURCE / "modal_diagnostics/results" / f"{material}_n32_spectrum.npz" | |
| rowpath = SOURCE / "modal_robustness/results" / f"{material}_finite_time.csv" | |
| model, coarse = load_npz(rompath), load_npz(coarsepath) | |
| np.testing.assert_array_equal(model["time"], times) | |
| inputs.extend((rompath, coarsepath, rowpath)) | |
| w = np.sqrt(np.maximum(model["reduced_eigenvalues"], 0.)) | |
| wh = np.sqrt(np.maximum(coarse["eigenvalues"], 0.)) | |
| modes = model["orthonormal_basis"] @ model["reduced_eigenvectors"] | |
| transform = coarse["eigenvectors"].T @ modes | |
| b = transform.T @ coarse["source_coupling"] | |
| c = coarse["receiver_coupling"] @ transform | |
| h = np.einsum("rj,js->jrs", c, b) | |
| yr = model["receiver_pressure"] | |
| direct = np.einsum("tj,jrs->trs", np.cos(np.outer(times, w)), h) | |
| model_defect = float(np.linalg.norm(direct - yr) / np.linalg.norm(yr)) | |
| old = list(csv.DictReader(rowpath.open())) | |
| for fine_grid in (128, 192): | |
| selection_path = SOURCE / "modal_robustness/results" / f"{material}_n{fine_grid}_craig_bampton_m32_gram.npz" | |
| selected = load_npz(selection_path) | |
| inputs.append(selection_path) | |
| ri, ci = selected["rom_modes"], selected["coarse_modes"] | |
| aa = np.einsum("tj,jrs->trs", np.cos(np.outer(times, w[ri])) - np.cos(np.outer(times, wh[ci])), h[ri]) | |
| own = [r for r in old if int(r["fine_grid"]) == fine_grid and r["method"] == "craig_bampton" and int(r["m"]) == 32] | |
| for prior in own: | |
| start, end = float(prior["start"]), float(prior["end"]) | |
| active = (times >= start) & (times <= end) | |
| if prior["window_kind"] == "successive" and start != 0: | |
| active = (times > start) & (times <= end) | |
| s, r = int(prior["source"]), int(prior["receiver"]) | |
| channels = np.ones((4, 3), dtype=bool) | |
| if prior["group"] == "channel": | |
| channels[:] = False | |
| channels[r - 1, s - 1] = True | |
| a = aa[active][:, channels] | |
| y = yr[active][:, channels] | |
| zbase = reference["grid512"][active][:, channels] | |
| denbase = float(np.sum(zbase ** 2)) | |
| ebase = y - zbase | |
| dbase = float((np.sum((ebase - a) ** 2) - np.sum(ebase ** 2)) / denbase) | |
| replay.append(abs(dbase - float(prior["exact_squared_error_change"]))) | |
| for comparator in ("grid512", "grid384", "richardson512", "richardson384"): | |
| z = reference[comparator][active][:, channels] | |
| den = float(np.sum(z ** 2)) | |
| e = y - z | |
| delta_numerator = float(np.sum((e - a) ** 2) - np.sum(e ** 2)) | |
| actual = delta_numerator / den | |
| original_error = float(np.linalg.norm(e) / np.sqrt(den)) | |
| replaced_error = float(np.linalg.norm(e - a) / np.sqrt(den)) | |
| difference = z - zbase | |
| cross = float(2 * np.sum(a * difference) / denbase) | |
| bound = float(2 * np.linalg.norm(a) * np.linalg.norm(difference) / denbase) | |
| same_denominator = delta_numerator / denbase | |
| margin = abs(dbase) / bound if bound > 0 else None | |
| if comparator == "grid384": | |
| old_margin = float(prior["reference_sign_margin"]) | |
| margin_absolute.append(abs(margin - old_margin)) | |
| # Use relative and absolute drift for the unbounded margin ratios. | |
| margin_scaled.append(abs(margin - old_margin) / max(1., abs(old_margin))) | |
| rows.append(dict(material=material, fine_grid=fine_grid, method="craig_bampton", m=32, | |
| matched_count=len(ri), window_kind=prior["window_kind"], start=start, end=end, | |
| group=prior["group"], source=s, receiver=r, comparator=comparator, | |
| original_error=original_error, replaced_error=replaced_error, | |
| change_percentage_points=100 * (replaced_error - original_error), | |
| delta_squared_error=actual, | |
| delta_squared_error_baseline_denominator=same_denominator, | |
| baseline_delta_squared_error=dbase, | |
| sign_agrees_with_grid512=bool(actual * dbase > 0) if abs(dbase) > 1e-12 else None, | |
| baseline_sign_margin_for_this_perturbation=margin, | |
| reference_change_exact_cross=cross, reference_change_cauchy_bound=bound, | |
| reference_change_identity_defect=abs((same_denominator - dbase) - cross), | |
| reference_relative_difference=float(np.linalg.norm(difference) / np.sqrt(denbase)), | |
| saved_model_modal_replay_relative_difference=model_defect, | |
| original_grid384_margin=float(prior["reference_sign_margin"]))) | |
| write_csv(out / "richardson_sign_checks.csv", rows) | |
| relevant = [r for r in rows if r["group"] == "channel" and r["window_kind"] != "short_cumulative"] | |
| summary = [] | |
| weakest = [] | |
| for material in MATERIALS: | |
| for fine_grid in (128, 192): | |
| own = [r for r in relevant if r["material"] == material and r["fine_grid"] == fine_grid] | |
| weakest_base = min((r for r in own if r["comparator"] == "grid512"), | |
| key=lambda r: r["original_grid384_margin"]) | |
| key = {k: weakest_base[k] for k in ("material", "fine_grid", "window_kind", "start", "end", "source", "receiver")} | |
| weaker = [r for r in own if all(r[k] == v for k, v in key.items())] | |
| weakest.extend(weaker) | |
| for comparator in ("grid384", "richardson512", "richardson384"): | |
| selected = [r for r in own if r["comparator"] == comparator] | |
| summary.append(dict(material=material, fine_grid=fine_grid, comparator=comparator, | |
| comparisons=len(selected), sign_agreements=sum(r["sign_agrees_with_grid512"] is True for r in selected), | |
| margins_greater_than_one=sum(r["baseline_sign_margin_for_this_perturbation"] > 1 for r in selected), | |
| minimum_margin=min(r["baseline_sign_margin_for_this_perturbation"] for r in selected), | |
| sign_changes=[r for r in selected if r["sign_agrees_with_grid512"] is False])) | |
| write_csv(out / "richardson_weakest_cases.csv", weakest) | |
| checks = dict(all_expected_rows=len(rows) == 3432, | |
| maximum_saved_budget_replay_absolute_difference=max(replay), | |
| maximum_saved_margin_scaled_difference=max(margin_scaled), | |
| maximum_reference_identity_defect=max(r["reference_change_identity_defect"] for r in rows), | |
| maximum_model_modal_replay_relative_difference=max(r["saved_model_modal_replay_relative_difference"] for r in rows), | |
| maximum_equivalent_richardson_formula_absolute_difference=max(formula_defects), | |
| all_reference_changes_within_cauchy_bound=all(abs(r["reference_change_exact_cross"]) <= r["reference_change_cauchy_bound"] + 1e-12 for r in rows)) | |
| passed = all(v if isinstance(v, bool) else v < 1e-10 for v in checks.values()) | |
| write_json(out / "richardson_verification.json", dict(passed=passed, checks=checks, | |
| maximum_saved_margin_absolute_difference=max(margin_absolute), | |
| margin_replay_metric="abs(new-old)/max(1,abs(old)); dimensionless margins are unbounded ratios", | |
| no_success_condition_on_scientific_signs=True, no_propagation_or_timing_repeated=True)) | |
| write_json(out / "richardson_summary.json", dict(passed=passed, | |
| formulas={"richardson512": "(16*Y512-9*Y384)/7", "richardson384": "(9*Y384-4*Y256)/5"}, | |
| scope="Fixed m32 Craig-Bampton responses on the 32-square grid, baseline matched sets against 128-square or 192-square modal references, all 13 output groups and 11 observation windows. Only the waveform error reference is changed. Extrapolants are conditional h^2 comparators, not exact solutions or certified continuum-error bounds.", | |
| counts=dict(all_comparator_rows=len(rows), ordinary_channel_windows=len(relevant) // 4), | |
| ordinary_channel_window_summary=summary, weakest_original_margin_cases=weakest, | |
| input_sha256={str(p.relative_to(SOURCE)): digest(p) for p in sorted(set(inputs))}, | |
| code_sha256=digest(Path(__file__).resolve()))) | |
| print(json.dumps(dict(passed=passed, checks=checks, ordinary_channel_window_summary=summary), indent=2)) | |
| if not passed: | |
| raise RuntimeError("Richardson replay verification failed; see richardson_verification.json") | |
| if __name__ == "__main__": | |
| main() | |