ADComp / frequency_diagnostics /richardson.py
Bobchen1980's picture
Upload folder using huggingface_hub
68db0a3 verified
Raw History Blame Contribute Delete
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()