Download modal_robustness/run.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 26.9 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/modal_robustness/run.py
- Command line
-
hf download hf://soundai2016/ADComp/modal_robustness/run.py
-
curl -L -o run.py https://huggingface.co/soundai2016/ADComp/resolve/main/modal_robustness/run.py
26.9 kB
| #!/usr/bin/env python3 | |
| """Modal matching, reference sensitivity, residue paths, and finite-time diagnostics.""" | |
| 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 importlib.util | |
| import json | |
| import platform | |
| import sys | |
| import time as clock | |
| from pathlib import Path | |
| import numpy as np | |
| import scipy | |
| from scipy import linalg | |
| from scipy.optimize import linear_sum_assignment | |
| from scipy.sparse.linalg import eigsh | |
| HERE = Path(__file__).resolve().parent | |
| SOURCE = HERE.parent | |
| OUT = HERE / "results" | |
| CACHE = HERE / "cache" | |
| CFG = json.loads((HERE / "config.json").read_text()) | |
| sys.path.insert(0, str(SOURCE)) | |
| from acoustic_core import build_sparse, ports, CONFIG as CORE | |
| def module(name, path): | |
| spec = importlib.util.spec_from_file_location(name, path) | |
| value = importlib.util.module_from_spec(spec) | |
| spec.loader.exec_module(value) | |
| return value | |
| MODAL = module("original_modal_diagnostics", SOURCE / "modal_diagnostics/run.py") | |
| ACCURACY = module("original_accuracy_cost", SOURCE / "accuracy_cost/run.py") | |
| def digest(path): | |
| h = hashlib.sha256() | |
| with Path(path).open("rb") as stream: | |
| for block in iter(lambda: stream.read(1024 * 1024), b""): | |
| h.update(block) | |
| return h.hexdigest() | |
| def dump(path, value): | |
| Path(path).write_text(json.dumps(value, indent=2, allow_nan=False) + "\n") | |
| def csvwrite(path, rows): | |
| if not rows: | |
| return | |
| with Path(path).open("w", newline="") as stream: | |
| writer = csv.DictWriter(stream, fieldnames=list(rows[0])) | |
| writer.writeheader() | |
| writer.writerows(rows) | |
| def scalar(value): | |
| return float(np.asarray(value)) | |
| def norm(value): | |
| return float(np.linalg.norm(value)) | |
| def residue(b, c): | |
| return MODAL.residue(b, c) | |
| def response(t, w, h): | |
| if len(w) == 0: | |
| return np.zeros((len(t), 4, 3)) | |
| return MODAL.response(t, w, h) | |
| def cached_spectrum(n, name, checks): | |
| """Read supplied spectrum first; create new fine references locally.""" | |
| old = SOURCE / "modal_diagnostics/results" / f"{name}_n{n}_spectrum.npz" | |
| own = CACHE / f"{name}_n{n}_spectrum.npz" | |
| path = old if old.exists() else own | |
| X, Y, rho, bulk, mass, C, _ = build_sparse(n, name) | |
| A = (C @ C.T).tocsr() | |
| B = ports(X, Y, bulk, CORE["source_centres"], True) | |
| R = ports(X, Y, bulk, CORE["receiver_centres"], False) | |
| start = clock.perf_counter() | |
| if path.exists(): | |
| with np.load(path) as z: | |
| lam, V = z["eigenvalues"].copy(), z["eigenvectors"].copy() | |
| origin = "supplied" if path == old else "new_cached" | |
| else: | |
| print(f"Eigensolve {name} n={n}", flush=True) | |
| if n == CFG["coarse_grid"]: | |
| lam, V = linalg.eigh(A.toarray(), check_finite=False, driver="evd") | |
| else: | |
| lam, V = eigsh(A, k=CFG["fine_modes"], sigma=-1e-7, which="LM", | |
| tol=CFG["eigen_tolerance"], | |
| v0=np.random.default_rng(673).normal(size=n*n)) | |
| order = np.argsort(lam) | |
| lam, V = lam[order], V[:, order] | |
| lam[lam < 1e-9] = 0.0 | |
| temporary = path.with_suffix(".tmp.npz") | |
| np.savez_compressed(temporary, eigenvalues=lam, eigenvectors=V, mass=mass, | |
| source_coupling=V.T@B, receiver_coupling=R.T@V) | |
| temporary.replace(path) | |
| origin = "newly_computed" | |
| assert len(lam) == (n*n if n == CFG["coarse_grid"] else CFG["fine_modes"]) | |
| defect = np.linalg.norm(A@V-V*lam[None, :], axis=0)/np.maximum(lam, 1.0) | |
| ortho = norm(V.T@V-np.eye(V.shape[1])) | |
| record = dict(material=name, grid=n, modes=len(lam), origin=origin, | |
| path=str(path.relative_to(SOURCE)), sha256=digest(path), | |
| elapsed_seconds=clock.perf_counter()-start, | |
| maximum_scaled_eigen_residual=float(defect.max()), orthogonality_defect=ortho) | |
| checks.append(record) | |
| print(json.dumps(record), flush=True) | |
| return dict(omega=np.sqrt(lam), V=V, b=V.T@B, c=R.T@V, mass=mass, A=A, B=B, R=R) | |
| def reduced_model(name, coarse, method, m, t, checks): | |
| n = CFG["coarse_grid"] | |
| old = SOURCE / "accuracy_cost/results" / f"{name}_n{n}_{method}_m{m}.npz" | |
| own = CACHE / f"{name}_n{n}_{method}_m{m}.npz" | |
| path = old if old.exists() else own | |
| if path.exists(): | |
| with np.load(path) as z: | |
| Q = z["orthonormal_basis"].copy() | |
| Vsmall = z["reduced_eigenvectors"].copy() | |
| lam = z["reduced_eigenvalues"].copy() | |
| ystored = z["receiver_pressure"].copy() | |
| np.testing.assert_array_equal(z["time"], t) | |
| origin = "supplied" if path == old else "new_cached" | |
| else: | |
| print(f"Rebuilding {name} {method} m={m}", flush=True) | |
| raw, _, _, _ = ACCURACY.reduced_run(n, name, m, method, t) | |
| np.savez_compressed(path, **raw) | |
| Q, Vsmall, lam = raw["orthonormal_basis"], raw["reduced_eigenvectors"], raw["reduced_eigenvalues"] | |
| ystored = raw["receiver_pressure"] | |
| origin = "newly_computed" | |
| V = Q@Vsmall | |
| w = np.sqrt(lam) | |
| b, c = V.T@coarse["B"], coarse["R"].T@V | |
| H = residue(b, c) | |
| y = response(t, w, H) | |
| checks.append(dict(material=name, method=method, m=m, origin=origin, | |
| path=str(path.relative_to(SOURCE)), sha256=digest(path), | |
| stored_response_relative_difference=norm(y-ystored)/norm(ystored), | |
| basis_orthogonality_defect=norm(V.T@V-np.eye(len(w))))) | |
| return dict(V=V, omega=w, b=b, c=c, H=H, y=y, method=method, m=m) | |
| def assignment(left, right, wl, wr): | |
| overlap = left.T@right | |
| il, ir = linear_sum_assignment(-overlap**2) | |
| return dict(left=il, right=ir, mac=overlap[il, ir]**2, | |
| sign=np.sign(overlap[il, ir]), gap_left=MODAL.gap(wl)[il], | |
| gap_right=MODAL.gap(wr)[ir], omega_left=wl[il], omega_right=wr[ir]) | |
| def accepted(a, mac, gap): | |
| return ((a["mac"] >= mac) & (a["gap_left"] >= gap) & | |
| (a["gap_right"] >= gap) & (a["omega_left"] > 1e-7) & (a["omega_right"] > 1e-7)) | |
| def chain(ar, af, mac, gap): | |
| cf = {int(i): int(j) for i, j, good in zip(af["left"], af["right"], accepted(af, mac, gap)) if good} | |
| return [(int(i), int(j), cf[int(j)]) | |
| for i, j, good in zip(ar["left"], ar["right"], accepted(ar, mac, gap)) | |
| if good and int(j) in cf] | |
| def windows(t): | |
| for end in CFG["cumulative_end_times"]: | |
| yield "cumulative", 0.0, end, (t >= 0)&(t <= end) | |
| for start, end in zip(CFG["successive_edges"][:-1], CFG["successive_edges"][1:]): | |
| yield "successive", start, end, ((t >= start) if start == 0 else (t > start))&(t <= end) | |
| def groups(): | |
| yield "all", 0, 0, np.ones((4, 3), dtype=bool) | |
| for s in range(3): | |
| for r in range(4): | |
| select = np.zeros((4, 3), dtype=bool) | |
| select[r, s] = True | |
| yield "channel", s+1, r+1, select | |
| def selected_arrays(triples, model, coarse, fine): | |
| if not triples: | |
| empty = np.array([], dtype=int) | |
| ri = ci = fi = empty | |
| else: | |
| ri, ci, fi = np.array(triples, dtype=int).T | |
| return dict(ri=ri, ci=ci, fi=fi, wr=model["omega"][ri], | |
| wh=coarse["omega"][ci], wf=fine["omega"][fi], | |
| Hr=model["H"][ri], Hf=residue(fine["b"][fi], fine["c"][:, fi])) | |
| def path_arrays(t, a, path): | |
| zr, zh, zf = (np.cos(t[:, None]*a[k][None, :]) for k in ("wr", "wh", "wf")) | |
| if path == "rom": | |
| H, zc = a["Hr"], zf | |
| elif path == "fine": | |
| H, zc = a["Hf"], zr | |
| elif path == "symmetric": | |
| H, zc = (a["Hr"]+a["Hf"])/2, (zr+zf)/2 | |
| else: | |
| raise ValueError(path) | |
| am = (zr-zh)[:, :, None, None]*H[None, :, :, :] | |
| bm = (zh-zf)[:, :, None, None]*H[None, :, :, :] | |
| coupling = np.einsum("tj,jrs->trs", zc, a["Hr"]-a["Hf"]) | |
| return am, bm, coupling | |
| def threshold_paths(name, grid, t, model, coarse, fine, yref, yfine, ar, af): | |
| settings = [(m, g) for m in CFG["mac_thresholds"] for g in CFG["relative_frequency_gaps"]] | |
| selections = {(m, g):chain(ar, af, m, g) for m, g in settings} | |
| common_keys = set.intersection(*(set(v) for v in selections.values())) | |
| common = sorted(common_keys) | |
| rows, detail, pairrows = [], [], [] | |
| error = model["y"]-yref | |
| den = norm(yref) | |
| for mac, gap in settings: | |
| for scope, triples in (("own", selections[(mac, gap)]), ("common", common)): | |
| a = selected_arrays(triples, model, coarse, fine) | |
| weights = np.linalg.norm(a["Hf"], axis=(1, 2)) | |
| weights /= max(float(weights.sum()), 1e-300) | |
| dg, dr = a["wh"]-a["wf"], a["wr"]-a["wh"] | |
| wg = float(np.sum(weights*dg/a["wf"])) | |
| wr = float(np.sum(weights*dr/a["wf"])) | |
| selected_difference = response(t, a["wr"], a["Hr"])-response(t, a["wf"], a["Hf"]) | |
| remaining = error-selected_difference | |
| fine_selected = response(t, a["wf"], a["Hf"]) | |
| interaction=response(t,a["wr"],a["Hr"]-a["Hf"])-response(t,a["wf"],a["Hr"]-a["Hf"]) | |
| for path in ("rom", "fine", "symmetric"): | |
| am, bm, cp = path_arrays(t, a, path) | |
| A, B = am.sum(axis=1), bm.sum(axis=1) | |
| changed = model["y"]-A | |
| row = dict(material=name, fine_grid=grid, method=model["method"], m=model["m"], | |
| mac_threshold=mac, relative_gap=gap, selection=scope, path=path, | |
| matched_count=len(triples), common_count=len(common), | |
| weighted_grid_shift=wg, weighted_ritz_shift=wr, | |
| frequency_compensation_ratio=(-wr/wg if abs(wg)>1e-30 else 0.0), | |
| original_error=norm(error)/den, replaced_error=norm(changed-yref)/den, | |
| error_change=(norm(changed-yref)-norm(error))/den, | |
| squared_error_change=(norm(changed-yref)**2-norm(error)**2)/den**2, | |
| ritz_norm=norm(A)/den, grid_norm=norm(B)/den, | |
| coupling_norm=norm(cp)/den, remaining_norm=norm(remaining)/den, | |
| path_interaction_norm=norm(interaction)/den, | |
| ritz_grid_cosine=float(np.sum(A*B)/max(norm(A)*norm(B),1e-300)), | |
| decomposition_defect=norm(error-A-B-cp-remaining)/den, | |
| matched_fine_response_omission=norm(yfine-fine_selected)/norm(yfine), | |
| eigenmode_coverage_norm=norm(yfine-response(t,fine["omega"],residue(fine["b"],fine["c"])))/norm(yfine)) | |
| rows.append(row) | |
| for kind, start, end, use in windows(t): | |
| eref = np.sum(yref[use]**2, axis=0) | |
| old = np.sum(error[use]**2, axis=0) | |
| new = np.sum((error[use]-A[use])**2, axis=0) | |
| for group, source, receiver, select in groups(): | |
| d = float(eref[select].sum()) | |
| s0, s1 = float(old[select].sum()), float(new[select].sum()) | |
| delta = (s1-s0)/d | |
| detail.append(dict(material=name, fine_grid=grid, mac_threshold=mac, | |
| relative_gap=gap, selection=scope, path=path, matched_count=len(triples), | |
| window_kind=kind, start=start, end=end, group=group, source=source, | |
| receiver=receiver, original_error=np.sqrt(s0/d), replaced_error=np.sqrt(s1/d), | |
| error_change=(np.sqrt(s1)-np.sqrt(s0))/np.sqrt(d), | |
| squared_error_change=delta, sign=int(np.sign(delta)) if abs(delta)>CFG["change_zero_tolerance"] else 0)) | |
| if scope == "own": | |
| for j, (ri, ci, fi) in enumerate(triples): | |
| pairrows.append(dict(material=name, fine_grid=grid, mac_threshold=mac, relative_gap=gap, | |
| rom_mode=ri, coarse_mode=ci, fine_mode=fi, weight=float(weights[j]), | |
| omega_rom=float(a["wr"][j]), omega_coarse=float(a["wh"][j]), omega_fine=float(a["wf"][j]), | |
| in_common_set=(ri,ci,fi) in common_keys)) | |
| return rows, detail, pairrows | |
| def cluster_diagnostics(name, grid, coarse, restricted, fine, af): | |
| """Cluster angles only; no arbitrary scalar shifts assigned to a cluster.""" | |
| w = coarse["omega"][:CFG["fine_modes"]] | |
| threshold = CFG["cluster_gap"] | |
| assignment_map = {int(i):int(j) for i,j in zip(af["left"],af["right"])} | |
| clusters, start = [], 1 | |
| for stop in range(2, len(w)+1): | |
| if stop == len(w) or (w[stop]-w[stop-1])/max(w[stop],1e-300) >= threshold: | |
| if stop-start > 1: | |
| clusters.append(np.arange(start,stop)) | |
| start=stop | |
| rows=[] | |
| for ids in clusters: | |
| if not all(int(j) in assignment_map for j in ids): | |
| continue | |
| fi=np.array([assignment_map[int(j)] for j in ids]) | |
| Qc,_=linalg.qr(coarse["V"][:,ids],mode="economic") | |
| Qf,_=linalg.qr(restricted[:,fi],mode="economic") | |
| singular=linalg.svdvals(Qc.T@Qf) | |
| projector_distance=np.sqrt(max(0.0,2*len(ids)-2*np.sum(singular**2))) | |
| # Orthogonal change of basis must rotate the whole frequency matrix. | |
| rng=np.random.default_rng(1700+int(ids[0])) | |
| U,_=linalg.qr(rng.normal(size=(len(ids),len(ids)))) | |
| lam=fine["omega"][fi]**2 | |
| K=U.T@np.diag(lam)@U | |
| lv,Z=linalg.eigh(K) | |
| b0,c0=fine["b"][fi],fine["c"][:,fi] | |
| b1=Z.T@(U.T@b0);c1=(c0@U)@Z | |
| test_t=np.linspace(0,8,65) | |
| original=response(test_t,np.sqrt(lam),residue(b0,c0)) | |
| transformed=response(test_t,np.sqrt(np.maximum(lv,0)),residue(b1,c1)) | |
| rows.append(dict(material=name,fine_grid=grid,start_mode=int(ids[0]),end_mode=int(ids[-1]), | |
| dimension=len(ids),smallest_principal_cosine=float(singular.min()), | |
| largest_principal_angle_degrees=float(np.degrees(np.arccos(np.clip(singular.min(),0,1)))), | |
| projector_frobenius_distance=float(projector_distance), | |
| block_response_basis_rotation_relative_defect=norm(original-transformed)/max(norm(original),1e-300), | |
| individually_attributed=False)) | |
| return rows | |
| def finite_time(name, grid, t, model, coarse, fine, yref, triples): | |
| with np.load(SOURCE/"propagation/results"/f"{name}_n384.npz") as z: | |
| np.testing.assert_array_equal(t,z["time"]) | |
| alternate_reference=z["receiver_pressure"].copy() | |
| a=selected_arrays(triples,model,coarse,fine) | |
| am,bm,coupling=path_arrays(t,a,"rom") | |
| A,B=am.sum(axis=1),bm.sum(axis=1) | |
| error=model["y"]-yref | |
| q=error-A-B | |
| remainder=q-coupling | |
| dg,dr=a["wh"]-a["wf"],a["wr"]-a["wh"] | |
| base=-t[:,None]*np.sin(t[:,None]*a["wf"][None,:]) | |
| H=a["Hr"] | |
| psi=base[:,:,None,None]*H[None,:,:,:] | |
| alin=np.einsum("tjrs,j->trs",psi,dr) | |
| blin=np.einsum("tjrs,j->trs",psi,dg) | |
| rows=[];saved={"rom_modes":a["ri"],"coarse_modes":a["ci"],"fine_modes":a["fi"],"delta_grid":dg,"delta_ritz":dr} | |
| analysis_windows=list(windows(t)) | |
| analysis_windows.extend(("short_cumulative",0.0,end,(t>=0)&(t<=end)) | |
| for end in CFG["linearization_short_end_times"]) | |
| for kind,start,end,use in analysis_windows: | |
| time_gram=base[use].T@base[use] | |
| for group,source,receiver,select in groups(): | |
| den2=float(np.sum(yref[use][:,select]**2)) | |
| aa=A[use][:,select];bb=B[use][:,select];qq=q[use][:,select] | |
| ee=error[use][:,select] | |
| a_modes=am[use][:,:,select];b_modes=bm[use][:,:,select] | |
| exact=(np.sum((ee-aa)**2)-np.sum(ee**2))/den2 | |
| reference_difference=(yref-alternate_reference)[use][:,select] | |
| alternate_error=ee+reference_difference | |
| alternate_exact=(np.sum((alternate_error-aa)**2)-np.sum(alternate_error**2))/den2 | |
| reference_delta=2*float(np.sum(aa*reference_difference))/den2 | |
| reference_bound=2*norm(aa)*norm(reference_difference)/den2 | |
| ritz_square=-float(np.sum(aa**2))/den2 | |
| grid_cross=-2*float(np.sum(aa*bb))/den2 | |
| q_cross=-2*float(np.sum(aa*qq))/den2 | |
| diagonal=-float(np.sum(a_modes**2)+2*np.sum(a_modes*b_modes))/den2 | |
| offdiagonal=ritz_square+grid_cross-diagonal | |
| Hselected=H[:,select] | |
| G=time_gram*(Hselected@Hselected.T) | |
| cq=np.sum(Hselected*(base[use].T@qq),axis=1) | |
| linear=-(2*dr@G@dg+dr@G@dr+2*dr@cq)/den2 | |
| linear_noq=-(2*dr@G@dg+dr@G@dr)/den2 | |
| linear_diag=-np.sum((2*dr*dg+dr*dr)*np.diag(G))/den2 | |
| approx=(np.sum((blin[use][:,select]+qq)**2)-np.sum((alin[use][:,select]+blin[use][:,select]+qq)**2))/den2 | |
| single_mode_negative_grid=(dg<0)&(dr>0)&(dr < -2*dg) | |
| weight=np.linalg.norm(Hselected,axis=1) | |
| eigenvalues=linalg.eigvalsh((G+G.T)/2) | |
| scale=max(float(np.max(np.abs(eigenvalues))),1e-300) | |
| row=dict(material=name,fine_grid=grid,method=model["method"],m=model["m"],matched_count=len(triples), | |
| window_kind=kind,start=start,end=end,group=group,source=source,receiver=receiver, | |
| original_error=norm(ee)/np.sqrt(den2),replaced_error=norm(ee-aa)/np.sqrt(den2), | |
| exact_squared_error_change=exact,negative_ritz_square=ritz_square, | |
| negative_twice_ritz_grid=grid_cross,negative_twice_ritz_remainder=q_cross, | |
| exact_same_mode_frequency_terms=diagonal,exact_cross_mode_frequency_terms=offdiagonal, | |
| coupling_cross=-2*float(np.sum(aa*coupling[use][:,select]))/den2, | |
| unmatched_reference_cross=-2*float(np.sum(aa*remainder[use][:,select]))/den2, | |
| linear_full=scalar(linear),linear_without_q=scalar(linear_noq),linear_diagonal_without_q=scalar(linear_diag), | |
| exact_sign=int(np.sign(exact)) if abs(exact)>CFG["change_zero_tolerance"] else 0, | |
| linear_sign=int(np.sign(linear)) if abs(linear)>CFG["change_zero_tolerance"] else 0, | |
| alternate_reference_squared_change_same_denominator=float(alternate_exact), | |
| reference_change_exact_cross=reference_delta,reference_change_bound=reference_bound, | |
| reference_sign_margin=abs(exact)/max(reference_bound,1e-300), | |
| reference_change_identity_defect=abs(exact-alternate_exact-reference_delta), | |
| exact_budget_defect=abs(exact-ritz_square-grid_cross-q_cross), | |
| linear_gram_identity_defect=abs(scalar(linear)-scalar(approx)), | |
| gram_relative_minimum_eigenvalue=float(eigenvalues.min()/scale), | |
| gram_relative_symmetry_defect=norm(G-G.T)/max(norm(G),1e-300), | |
| ritz_linearization_error=norm(alin[use][:,select]-aa)/max(norm(aa),1e-300), | |
| grid_linearization_error=norm(blin[use][:,select]-bb)/max(norm(bb),1e-300), | |
| maximum_phase_offset=float(end*np.max(np.maximum(np.abs(dg),np.abs(dg+dr)),initial=0)), | |
| relative_signal_energy=float(den2/np.sum(yref[use]**2)), | |
| single_mode_condition_residue_fraction=float(weight[single_mode_negative_grid].sum()/max(weight.sum(),1e-300))) | |
| rows.append(row) | |
| if group=="all": | |
| key=f"{kind}_{start:g}_{end:g}" | |
| saved[key+"_gram_normalized"]=G/den2 | |
| saved[key+"_q_inner_normalized"]=cq/den2 | |
| np.savez_compressed(OUT/f"{name}_n{grid}_{model['method']}_m{model['m']}_gram.npz",**saved) | |
| return rows | |
| def original_comparison(name,t,model,coarse,fine,yfine,triples): | |
| a=selected_arrays(triples,model,coarse,fine) | |
| am,bm,coupling=path_arrays(t,a,"rom") | |
| A,B=am.sum(axis=1),bm.sum(axis=1) | |
| weight=np.linalg.norm(a["Hf"],axis=(1,2));weight/=max(float(weight.sum()),1e-300) | |
| values=dict(accepted_three_grid_chain=len(triples), | |
| weighted_grid_shift=float(np.sum(weight*(a["wh"]-a["wf"])/a["wf"])), | |
| weighted_ritz_shift=float(np.sum(weight*(a["wr"]-a["wh"])/a["wf"])), | |
| ritz_grid_cosine=float(np.sum(A*B)/max(norm(A)*norm(B),1e-300)), | |
| total_error_vs_128=norm(model["y"]-yfine)/norm(yfine), | |
| error_without_ritz_shift_vs_128=norm(model["y"]-A-yfine)/norm(yfine)) | |
| with (SOURCE/"modal_diagnostics/results/summary.csv").open() as stream: | |
| old=next(r for r in csv.DictReader(stream) if r["material"]==name and r["method"]==model["method"] and int(r["m"])==model["m"]) | |
| Aold=response(t,a["wr"],a["Hr"])-response(t,a["wh"],a["Hr"]) | |
| Bold=response(t,a["wh"],a["Hr"])-response(t,a["wf"],a["Hr"]) | |
| old_order_cosine=float(np.sum(Aold*Bold)/max(norm(Aold)*norm(Bold),1e-300)) | |
| return [dict(material=name,method=model["method"],m=model["m"],quantity=k, | |
| original=float(old[k]),recomputed=float(v),absolute_difference=abs(float(v)-float(old[k])), | |
| original_order_recomputed=old_order_cosine if k=="ritz_grid_cosine" else float(v), | |
| original_order_absolute_difference=abs((old_order_cosine if k=="ritz_grid_cosine" else float(v))-float(old[k])), | |
| ritz_relative_norm=norm(A)/norm(yfine), | |
| angle_near_zero_component=(k=="ritz_grid_cosine" and norm(A)/norm(yfine)<1e-6)) for k,v in values.items()] | |
| def main(): | |
| p=argparse.ArgumentParser() | |
| p.add_argument("--materials",nargs="+",default=CFG["materials"]) | |
| p.add_argument("--fine-grids",nargs="+",type=int,default=CFG["fine_grids"]) | |
| p.add_argument("--prepare-only",action="store_true") | |
| p.add_argument("--skip-controls",action="store_true") | |
| args=p.parse_args() | |
| OUT.mkdir(exist_ok=True);CACHE.mkdir(exist_ok=True) | |
| if hasattr(os,"sched_getaffinity"): | |
| available=set(os.sched_getaffinity(0));chosen=available&set(CFG["cpu_affinity"]) | |
| os.sched_setaffinity(0,chosen or set(sorted(available)[:CFG["threads"]])) | |
| start=clock.perf_counter() | |
| for name in args.materials: | |
| print("Processing "+name,flush=True) | |
| checks=[];baseline=[];sensitivity=[];channel=[];pairs=[];cluster=[];finite=[];reference=[] | |
| n=CFG["coarse_grid"] | |
| coarse=cached_spectrum(n,name,checks) | |
| with np.load(SOURCE/"propagation/results"/f"{name}_n{CFG['evaluation_reference_grid']}.npz") as z: | |
| t,yref=z["time"].copy(),z["receiver_pressure"].copy() | |
| if args.prepare_only: | |
| for grid in args.fine_grids: | |
| cached_spectrum(grid,name,checks) | |
| dump(OUT/f"{name}_preparation.json",checks) | |
| continue | |
| model=reduced_model(name,coarse,*CFG["primary_model"],t,checks) | |
| ar=assignment(model["V"],coarse["V"],model["omega"],coarse["omega"]) | |
| baseline_selected={} | |
| for grid in args.fine_grids: | |
| assert grid % n == 0,"Physical block averaging requires an integer grid ratio." | |
| fine=cached_spectrum(grid,name,checks) | |
| with np.load(SOURCE/"propagation/results"/f"{name}_n{grid}.npz") as z: | |
| np.testing.assert_array_equal(t,z["time"]) | |
| yfine=z["receiver_pressure"].copy() | |
| W,_=MODAL.restriction(fine["V"],fine["mass"],coarse["mass"],grid,n) | |
| af=assignment(coarse["V"],W,coarse["omega"],fine["omega"]) | |
| rr,dd,pp=threshold_paths(name,grid,t,model,coarse,fine,yref,yfine,ar,af) | |
| sensitivity.extend(rr);channel.extend(dd);pairs.extend(pp) | |
| cluster.extend(cluster_diagnostics(name,grid,coarse,W,fine,af)) | |
| triples=chain(ar,af,CFG["baseline_mac"],CFG["baseline_gap"]) | |
| baseline_selected[grid]=triples | |
| finite.extend(finite_time(name,grid,t,model,coarse,fine,yref,triples)) | |
| if grid==128: | |
| baseline.extend(original_comparison(name,t,model,coarse,fine,yfine,triples)) | |
| if not args.skip_controls: | |
| for method,m in CFG["control_models"]: | |
| control=reduced_model(name,coarse,method,m,t,checks) | |
| arc=assignment(control["V"],coarse["V"],control["omega"],coarse["omega"]) | |
| tc=chain(arc,af,CFG["baseline_mac"],CFG["baseline_gap"]) | |
| finite.extend(finite_time(name,grid,t,control,coarse,fine,yref,tc)) | |
| baseline.extend(original_comparison(name,t,control,coarse,fine,yfine,tc)) | |
| np.savez_compressed(OUT/f"{name}_n{grid}_assignments.npz", | |
| **{"rom_coarse_"+k:v for k,v in ar.items()},**{"coarse_fine_"+k:v for k,v in af.items()}) | |
| print(json.dumps(dict(material=name,grid=grid,baseline_count=len(triples), | |
| baseline_original_error=norm(model["y"]-yref)/norm(yref))),flush=True) | |
| if len(args.fine_grids)>1: | |
| first=args.fine_grids[0] | |
| keys0={(ri,ci) for ri,ci,_ in baseline_selected[first]} | |
| for grid in args.fine_grids[1:]: | |
| keys1={(ri,ci) for ri,ci,_ in baseline_selected[grid]} | |
| reference.append(dict(material=name,base_grid=first,comparison_grid=grid, | |
| base_count=len(keys0),comparison_count=len(keys1),intersection=len(keys0&keys1), | |
| lost=len(keys0-keys1),gained=len(keys1-keys0))) | |
| for filename,rows in (("sensitivity",sensitivity),("channel_sensitivity",channel),("pairs",pairs), | |
| ("clusters",cluster),("finite_time",finite),("baseline_check",baseline),("reference_matching",reference)): | |
| csvwrite(OUT/f"{name}_{filename}.csv",rows) | |
| dump(OUT/f"{name}_verification.json",dict(spectral_and_reduced_checks=checks, | |
| propagation_input_sha256={str(path.relative_to(SOURCE)):digest(path) for path in | |
| [SOURCE/"propagation/results"/f"{name}_n{g}.npz" for g in sorted(set(args.fine_grids+[384,CFG['evaluation_reference_grid']]))]}, | |
| maximum_baseline_difference=max((r["absolute_difference"] for r in baseline),default=0), | |
| maximum_decomposition_defect=max(r["decomposition_defect"] for r in sensitivity), | |
| maximum_exact_budget_defect=max(r["exact_budget_defect"] for r in finite), | |
| maximum_gram_identity_defect=max(r["linear_gram_identity_defect"] for r in finite), | |
| minimum_gram_relative_eigenvalue=min(r["gram_relative_minimum_eigenvalue"] for r in finite), | |
| maximum_cluster_rotation_defect=max((r["block_response_basis_rotation_relative_defect"] for r in cluster),default=0), | |
| config_sha256=digest(HERE/"config.json"),analysis_sha256=digest(Path(__file__)))) | |
| dump(OUT/"environment.json",dict(python=platform.python_version(),numpy=np.__version__,scipy=scipy.__version__, | |
| platform=platform.platform(),threads=CFG["threads"],affinity=sorted(os.sched_getaffinity(0)), | |
| arguments=vars(args),elapsed_seconds=clock.perf_counter()-start, | |
| input_source_hashes={str(path.relative_to(SOURCE)):digest(path) for path in | |
| (SOURCE/"acoustic_core.py",SOURCE/"modal_diagnostics/run.py",SOURCE/"accuracy_cost/run.py")}, | |
| config_sha256=digest(HERE/"config.json"),analysis_sha256=digest(Path(__file__)))) | |
| if __name__=="__main__": | |
| main() | |