Bobchen1980's picture
Upload folder using huggingface_hub (part 3)
cfbe945 verified
Raw History Blame Contribute Delete
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()