Download source_receiver_validation/run.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 16.9 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/source_receiver_validation/run.py
- Command line
-
hf download hf://soundai2016/ADComp/source_receiver_validation/run.py
-
curl -L -o run.py https://huggingface.co/soundai2016/ADComp/resolve/main/source_receiver_validation/run.py
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() | |