Bobchen1980's picture
Upload folder using huggingface_hub (part 3)
cfbe945 verified
Raw History Blame Contribute Delete
16.9 kB
#!/usr/bin/env python3
"""Compute both fixed port layouts and their exact modal interventions."""
from common import CFG, HERE, OUT, acoustic, config_digest, dump, residue, response, relative_gaps, save_arrays
import argparse
from datetime import datetime, timezone
import hashlib
import platform
import sys
import time
import numpy as np
import scipy
from scipy import linalg
from scipy.optimize import linear_sum_assignment
from threadpoolctl import threadpool_info
from accuracy_cost.run import cb_basis
def catalogue(initial=None, receiver_centres=None):
initial = acoustic.continuous_data() if initial is None else initial
receiver_centres = CFG["receiver_centres"] if receiver_centres is None else receiver_centres
active_max = float(initial["omega"].max())
halo = active_max + np.pi * np.sqrt(max(np.asarray(CFG["bulk_modulus"]) / np.asarray(CFG["density"])))
count = int(np.floor(halo / np.pi)) + 2
entries = []
for ell in range(count):
for m, omega in enumerate(acoustic.roots(ell, count + 1)):
if omega <= halo:
q2, amplitudes = acoustic.mode_parameters(omega, ell)
entries.append((omega, m, ell, q2, amplitudes))
entries.sort(key=lambda row: row[0])
omega = np.asarray([row[0] for row in entries])
mm = np.asarray([row[1] for row in entries], dtype=int)
ll = np.asarray([row[2] for row in entries], dtype=int)
q2 = np.stack([row[3] for row in entries])
amplitudes = np.stack([row[4] for row in entries])
coefficients = np.zeros((len(omega), 3))
for j, (m, ell) in enumerate(zip(mm, ll)):
if m <= CFG["max_x_mode"] and ell <= CFG["max_y_mode"]:
coefficients[j] = initial["coefficients"][ell, m]
order = CFG["quadrature_order"]
a = CFG["interface_x"]
xl, wl = acoustic.gauss_interval(order, 0., a)
xr, wr = acoustic.gauss_interval(order, a, 1.)
x, wx = np.r_[xl, xr], np.r_[wl, wr]
y, wy = acoustic.gauss_interval(order, 0., 1.)
X = acoustic.x_values(x, q2, amplitudes)
Y = acoustic.y_values(y, ll.max())[:, ll]
receivers = np.empty((4, len(omega)))
for r, (cx, cy) in enumerate(receiver_centres):
gx = np.exp(-.5 * ((x - cx) / CFG["sigma"]) ** 2)
gy = np.exp(-.5 * ((y - cy) / CFG["sigma"]) ** 2)
receivers[r] = (X.T @ (wx * gx)) * (Y.T @ (wy * gy)) / (
acoustic.gaussian_integrals([0., 1.], cx)[0] * acoustic.gaussian_integrals([0., 1.], cy)[0])
return {"omega": omega, "m": mm, "ell": ll, "q_squared": q2, "amplitudes": amplitudes,
"coefficients": coefficients, "receiver_modes": receivers, "active_max": active_max, "halo_max": halo}
def original_continuous_data(layout_config):
acoustic.CFG["source_centres"] = layout_config["original_source_centres"]
acoustic.CFG["receiver_centres"] = layout_config["original_receiver_centres"]
acoustic.continuous_data.cache_clear()
try:
data = {key: value.copy() for key, value in acoustic.continuous_data().items()}
finally:
acoustic.CFG["source_centres"] = CFG["source_centres"]
acoustic.CFG["receiver_centres"] = CFG["receiver_centres"]
acoustic.continuous_data.cache_clear()
return data
def original_ports(n, mass, initial, layout_config):
xx, yy = acoustic.averaged_modes(n)
B = acoustic.synthesize(xx, yy, initial["omega"], initial["coefficients"], [0.])[0] * np.sqrt(mass)[:, None]
edges = np.linspace(0., 1., n + 1)
windows = []
for cx, cy in layout_config["original_receiver_centres"]:
gx = acoustic.gaussian_integrals(edges, cx)
gy = acoustic.gaussian_integrals(edges, cy)
windows.append(np.outer(gx / gx.sum(), gy / gy.sum()).ravel() / np.sqrt(mass))
return B, np.stack(windows, axis=-1)
def factorial_responses(times, omega, sources, receivers):
return np.stack([np.stack([response(times, omega, residue(source, receiver))
for receiver in receivers]) for source in sources])
def factorial_terms(model, fine_catalogues, times, reference, sources, receivers):
ri, fi = model["matched_reduced_indices"], model["matched_continuous_indices"]
sr, sf = model["sign_reduced_full"], model["sign_continuous_full"]
wr, wh, wf = (model[key] for key in ("matched_reduced_omega", "matched_full_omega", "matched_continuous_omega"))
terms = {key: np.empty_like(reference) for key in (
"receiver_pressure", "ritz_frequency", "grid_frequency", "source_coupling", "receiver_coupling", "unmatched")}
h_reduced = np.empty((2, 2, len(ri), 4, 3))
h_continuous = np.empty_like(h_reduced)
for source_layout in range(2):
for receiver_layout in range(2):
br, cr = sources[source_layout][ri] * sr[:, None], receivers[receiver_layout][:, ri] * sr[None]
bf = fine_catalogues[source_layout]["coefficients"][fi] * sf[:, None]
cf = fine_catalogues[receiver_layout]["receiver_modes"][:, fi] * sf[None]
Hr, Hf = residue(br, cr), residue(bf, cf)
h_reduced[source_layout, receiver_layout], h_continuous[source_layout, receiver_layout] = Hr, Hf
yr = response(times, model["omega"], residue(sources[source_layout], receivers[receiver_layout]))
ritz = response(times, wr, Hr) - response(times, wh, Hr)
grid = response(times, wh, Hr) - response(times, wf, Hr)
source = response(times, wf, residue(br - bf, (cr + cf) / 2))
receiver = response(times, wf, residue((br + bf) / 2, cr - cf))
values = (yr, ritz, grid, source, receiver, yr - reference[source_layout, receiver_layout] - ritz - grid - source - receiver)
for key, value in zip(terms, values):
terms[key][source_layout, receiver_layout] = value
return {"factorial_" + key: value for key, value in terms.items()} | {
"factorial_source_coefficients": np.stack(sources), "factorial_receiver_modes": np.stack(receivers),
"factorial_reduced_residues": h_reduced, "factorial_continuous_residues": h_continuous}
def project_separated(full, vectors):
n = len(full["y_eigenvectors"])
by_y = np.einsum("ijk,jl->lik", vectors.reshape(n, n, -1), full["y_eigenvectors"], optimize=True)
return np.matmul(full["x_eigenvectors"].transpose(0, 2, 1), by_y).reshape(n * n, -1)
def continuous_overlap(full, fine):
n = len(full["y_eigenvectors"])
centres = (np.arange(n) + .5) / n
ll = fine["ell"]
xavg = acoustic.x_values(centres, fine["q_squared"], fine["amplitudes"], 1 / n)
yavg = acoustic.y_values(centres, ll.max())[:, ll] * np.sinc(ll / (2 * n))[None]
xweighted = xavg * np.sqrt(full["mass"].reshape(n, n)[:, 0])[:, None]
norms = np.sqrt(np.sum(xweighted ** 2, axis=0) * np.sum(yavg ** 2, axis=0))
ox = np.matmul(full["x_eigenvectors"].transpose(0, 2, 1), xweighted[None])
oy = full["y_eigenvectors"].T @ yavg
overlap = (ox * oy[:, None, :]).reshape(n * n, -1) / norms[None]
return overlap, norms
def match_overlap(overlap, left_omega, right_omega):
left, right = linear_sum_assignment(-(overlap ** 2))
mac = overlap[left, right] ** 2
accepted = ((mac >= CFG["mac_threshold"])
& (relative_gaps(left_omega)[left] >= CFG["relative_frequency_gap"])
& (relative_gaps(right_omega)[right] >= CFG["relative_frequency_gap"])
& (left_omega[left] > 1e-7) & (right_omega[right] > 1e-7))
return left, right, mac, np.sign(overlap[left, right]), accepted
def modal_terms(full, reduced, fine, continuum_pairs, times, reference):
order = np.argsort(full["omega"].ravel())
coarse_omega = full["omega"].ravel()[order]
overlap = project_separated(full, reduced["eigenvectors"])[order].T
ri0, ci0, mac0, signs0, accepted = match_overlap(overlap, reduced["omega"], coarse_omega)
chain = [(int(i), int(j), continuum_pairs[int(j)][0], float(mac), continuum_pairs[int(j)][1],
float(sign), continuum_pairs[int(j)][2])
for i, j, mac, sign, ok in zip(ri0, ci0, mac0, signs0, accepted)
if ok and int(j) in continuum_pairs]
ri = np.asarray([row[0] for row in chain], dtype=int)
ci = np.asarray([row[1] for row in chain], dtype=int)
fi = np.asarray([row[2] for row in chain], dtype=int)
sr = np.asarray([row[5] for row in chain])
sf = np.asarray([row[6] for row in chain])
br = reduced["coefficients"][ri] * sr[:, None]
cr = reduced["observation"][:, ri] * sr[None]
bf = fine["coefficients"][fi] * sf[:, None]
cf = fine["receiver_modes"][:, fi] * sf[None]
Hr, Hf = residue(br, cr), residue(bf, cf)
wr, wh, wf = reduced["omega"][ri], coarse_omega[ci], fine["omega"][fi]
ritz = response(times, wr, Hr) - response(times, wh, Hr)
grid = response(times, wh, Hr) - response(times, wf, Hr)
source = response(times, wf, residue(br - bf, (cr + cf) / 2))
receiver = response(times, wf, residue((br + bf) / 2, cr - cf))
yr = reduced["receiver_pressure"]
unmatched = yr - reference - ritz - grid - source - receiver
return {"matched_reduced_indices": ri, "matched_full_indices": ci, "matched_continuous_indices": fi,
"mac_reduced_full": np.asarray([row[3] for row in chain]),
"mac_full_continuous": np.asarray([row[4] for row in chain]),
"sign_reduced_full": sr, "sign_continuous_full": sf,
"matched_reduced_omega": wr, "matched_full_omega": wh, "matched_continuous_omega": wf,
"matched_reduced_residues": Hr, "matched_continuous_residues": Hf,
"ritz_frequency": ritz, "grid_frequency": grid, "source_coupling": source,
"receiver_coupling": receiver, "unmatched": unmatched,
"no_ritz_frequency_response": yr - ritz,
"continuous_frequency_response": yr - ritz - grid,
"matched_continuous_response": response(times, wf, Hf)}
def pressure_terms(n, full, reduced, times):
data = {"continuous_norm_squared": [], "full_norm_squared": [], "projection_floor_squared": [],
"full_continuous_error_squared": []}
for m in reduced:
data[f"m{m}_continuous_error_squared"] = []
data[f"m{m}_same_grid_error_squared"] = []
minimum = np.inf
for start in range(0, len(times), 16):
tt = times[start:start + 16]
exact = acoustic.exact_mass_weighted_pressure(n, tt)
discrete = acoustic.separable_pressure(full, tt)
continuous = acoustic.exact_pressure_norm_squared(tt)
subcell = continuous - np.sum(exact ** 2, axis=1)
minimum = min(minimum, float(subcell.min()))
if minimum < -1e-9:
raise RuntimeError("Negative subcell projection norm")
subcell = np.maximum(subcell, 0.)
data["continuous_norm_squared"].append(continuous)
data["full_norm_squared"].append(np.sum(discrete ** 2, axis=1))
data["projection_floor_squared"].append(subcell)
data["full_continuous_error_squared"].append(np.sum((discrete - exact) ** 2, axis=1) + subcell)
for m, model in reduced.items():
modal = np.cos(tt[:, None] * model["omega"][None])[:, :, None] * model["coefficients"][None]
field = (model["eigenvectors"] @ modal.transpose(1, 0, 2).reshape(len(model["omega"]), -1))
field = field.reshape(n * n, len(tt), 3).transpose(1, 0, 2)
data[f"m{m}_continuous_error_squared"].append(np.sum((field - exact) ** 2, axis=1) + subcell)
data[f"m{m}_same_grid_error_squared"].append(np.sum((field - discrete) ** 2, axis=1))
data = {key: np.concatenate(value) for key, value in data.items()}
data["minimum_subcell_squared_norm"] = np.asarray(minimum)
return data
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--grids", type=int, nargs="+", choices=CFG["grids"], default=CFG["grids"])
args = parser.parse_args()
import json
layout_config = json.loads((HERE / "layout_config.json").read_text())
OUT.mkdir(exist_ok=True)
dump(OUT / "environment.json", {"started_at_utc": datetime.now(timezone.utc).isoformat(),
"config_sha256": config_digest(), "python": sys.version, "platform": platform.platform(),
"numpy": np.__version__, "scipy": scipy.__version__, "threadpools": threadpool_info(),
"layout_config_sha256": hashlib.sha256((HERE / "layout_config.json").read_bytes()).hexdigest(),
"code_sha256": {path.name: hashlib.sha256(path.read_bytes()).hexdigest() for path in HERE.glob("*.py")}})
times = np.linspace(0., CFG["time_end"], CFG["samples"])
original_initial = original_continuous_data(layout_config)
reference = acoustic.exact_receiver(times)
fine = catalogue()
original_fine = catalogue(original_initial, layout_config["original_receiver_centres"])
fine_catalogues = [original_fine, fine]
factorial_reference = factorial_responses(times, fine["omega"],
[entry["coefficients"] for entry in fine_catalogues], [entry["receiver_modes"] for entry in fine_catalogues])
save_arrays(OUT / "continuous_reference.npz", time=times, receiver_pressure=reference, **acoustic.continuous_data())
save_arrays(OUT / "continuous_catalogue.npz", **fine)
save_arrays(OUT / "factorial_reference.npz", time=times, receiver_pressure=factorial_reference,
original_coefficients=original_initial["coefficients"], original_receiver_modes=original_initial["receiver_modes"],
original_catalogue_coefficients=original_fine["coefficients"], original_catalogue_receiver_modes=original_fine["receiver_modes"])
for n in args.grids:
started = time.perf_counter()
print(f"Grid {n}: separated full spectrum and complete modal matching", flush=True)
full = acoustic.separable_setup(n)
mass, A, _, B, R, _, _ = acoustic.assembly(n)
original_B, original_R = original_ports(n, mass, original_initial, layout_config)
full["B"], full["R"] = B, R
full_receiver = acoustic.separable_receiver(full, times)
factorial_B = [original_B, B]
factorial_R = [original_R, R]
full_sources = [project_separated(full, item) for item in factorial_B]
full_receivers = [project_separated(full, item).T for item in factorial_R]
factorial_full = factorial_responses(times, full["omega"].ravel(), full_sources, full_receivers)
order = np.argsort(full["omega"].ravel())
omega_h = full["omega"].ravel()[order]
overlap, norms = continuous_overlap(full, fine)
ii, jj, mac, signs, accepted = match_overlap(overlap[order], omega_h, fine["omega"])
accepted &= (fine["omega"][jj] <= fine["active_max"] + 1e-9) & (norms[jj] > 1e-8)
cf = {int(i): (int(j), float(mm), float(sign)) for i, j, mm, sign, ok in zip(ii, jj, mac, signs, accepted) if ok}
save_arrays(OUT / f"n{n}_full.npz", time=times, receiver_pressure=full_receiver,
full_sort_order=order, continuum_full_indices=np.asarray(list(cf), dtype=int),
continuum_indices=np.asarray([row[0] for row in cf.values()], dtype=int),
continuum_mac=np.asarray([row[1] for row in cf.values()]),
original_B=original_B, original_R=original_R, factorial_receiver_pressure=factorial_full, **full)
del overlap
models = {}
for m in CFG["modes_per_patch"]:
print(f"Grid {n}: Craig--Bampton m={m}", flush=True)
Q = cb_basis(n, mass, A, m)
Ar = Q.T @ (A @ Q)
lam, V = linalg.eigh((Ar + Ar.T) / 2, check_finite=False, driver="evd")
if lam.min() < -1e-9 * max(lam.max(), 1.):
raise RuntimeError("Indefinite reduced stiffness")
lam[lam < 1e-9] = 0.
W = Q @ V
coefficients, observation = W.T @ B, R.T @ W
omega = np.sqrt(lam)
model = {"omega": omega, "eigenvectors": W, "coefficients": coefficients, "observation": observation,
"receiver_pressure": response(times, omega, residue(coefficients, observation))}
model.update(modal_terms(full, model, fine, cf, times, reference))
model.update(factorial_terms(model, fine_catalogues, times, factorial_reference,
[W.T @ item for item in factorial_B], [item.T @ W for item in factorial_R]))
save_arrays(OUT / f"n{n}_cb_m{m}.npz", time=times, **model)
models[m] = model
print(f"Grid {n}, m={m}: {len(model['matched_reduced_indices'])} accepted triples", flush=True)
print(f"Grid {n}: continuous pressure-field errors", flush=True)
save_arrays(OUT / f"n{n}_pressure_errors.npz", time=times, **pressure_terms(n, full, models, times))
print(f"Grid {n} complete in {time.perf_counter() - started:.1f} s (execution log only)", flush=True)
if __name__ == "__main__":
main()