Download unequal_speed_interface/verify.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 7.98 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/unequal_speed_interface/verify.py
- Command line
-
hf download hf://soundai2016/ADComp/unequal_speed_interface/verify.py
-
curl -L -o verify.py https://huggingface.co/soundai2016/ADComp/resolve/main/unequal_speed_interface/verify.py
7.98 kB
| #!/usr/bin/env python3 | |
| """Independent accuracy and structural checks for the unequal-speed case.""" | |
| import os | |
| for key in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS", "NUMEXPR_NUM_THREADS"): | |
| os.environ[key] = "2" | |
| import json | |
| from pathlib import Path | |
| import sys | |
| import numpy as np | |
| from scipy import linalg | |
| from scipy.sparse.linalg import expm_multiply | |
| HERE = Path(__file__).resolve().parent | |
| sys.path.insert(0, str(HERE.parent)) | |
| from unequal_speed_interface.kernel import ( | |
| CFG, continuous_data, exact_receiver, roots, cosine_q, q_sine, characteristic, | |
| assembly, separable_setup, separable_pressure, separable_receiver, | |
| full_eigenvectors, x_tridiagonal, exact_mass_weighted_pressure, | |
| exact_pressure_norm_squared, gauss_interval, x_values, y_values, | |
| ) | |
| def relative(a, b): | |
| return float(np.linalg.norm(a-b)/np.linalg.norm(b)) | |
| def main(): | |
| (HERE/"results").mkdir(exist_ok=True) | |
| tt = np.linspace(0., CFG["time_end"], CFG["samples"]) | |
| data = continuous_data(192) | |
| fine = continuous_data(384) | |
| finer_roots = continuous_data(192, .01) | |
| rho = np.asarray(CFG["density"]) | |
| kk = np.asarray(CFG["bulk_modulus"]) | |
| q2 = data["q_squared"] | |
| amp = data["amplitudes"] | |
| cc = cosine_q(q2, [.5, .5]) | |
| ss = q_sine(q2, [.5, .5])/rho | |
| pressure_jump = amp[..., 0]*cc[..., 0]-amp[..., 1]*cc[..., 1] | |
| flux_jump = amp[..., 0]*ss[..., 0]+amp[..., 1]*ss[..., 1] | |
| flux_scale = np.maximum(np.linalg.norm(amp*ss, axis=-1), 1.) | |
| pressure_scale = np.maximum(np.linalg.norm(amp*cc, axis=-1), 1.) | |
| values = { | |
| "sound_speeds": np.sqrt(kk/rho).tolist(), "impedances": np.sqrt(kk*rho).tolist(), | |
| "pressure_jump_scaled_max": float(np.max(np.abs(pressure_jump)/pressure_scale)), | |
| "normal_flux_jump_scaled_max": float(np.max(np.abs(flux_jump)/flux_scale)), | |
| "x_beta_gram_max_error": float(np.max(np.abs(data["x_gram"]-np.eye(21)[None]))), | |
| "y_gram_max_error": float(np.max(np.abs(data["y_gram"]-np.eye(17)))), | |
| "initial_acoustic_energy": (.5*np.sum(data["coefficients"]**2, axis=(0, 1))).tolist(), | |
| "zero_mode_coefficients": data["coefficients"][0, 0].tolist(), | |
| "source_quadrature_relative_change_192_384": relative(data["coefficients"], fine["coefficients"]), | |
| "receiver_quadrature_relative_change_192_384": relative(exact_receiver(tt, 192), exact_receiver(tt, 384)), | |
| "root_scan_relative_change_002_001": relative(data["omega"], finer_roots["omega"]), | |
| "receiver_root_scan_relative_change_002_001": relative(exact_receiver(tt), exact_receiver(tt, 192, .01)), | |
| "number_of_finite_initial_modes": int(data["omega"].size-1), | |
| "evanescent_segments_in_initial_modes": int(np.sum(q2 < 0)), | |
| "time_propagation": "Exact modal cosine propagation; no time-stepping error.", | |
| } | |
| # The equal-speed spectrum supplies an independent regression target. | |
| equal_errors = [] | |
| for ell in (0, 1, 4, 8, 16): | |
| computed = roots(ell, 21, (1., 8.), (1., 8.)) | |
| exact = np.pi*np.sqrt(np.arange(21)**2+ell**2) | |
| equal_errors.append(float(np.max(np.abs(computed-exact)/np.maximum(exact, 1.)))) | |
| values["equal_speed_spectrum_relative_max_error"] = max(equal_errors) | |
| # Check the continuous root ordering against converging independent 1-D | |
| # FV eigenvalues. These FV spectra never define the continuous solution. | |
| root_checks = [] | |
| for ell in (0, 4, 8, 16): | |
| omega = data["omega"][ell] | |
| for n in (512, 1024, 2048): | |
| d, e, speed2 = x_tridiagonal(n) | |
| lam = linalg.eigh_tridiagonal(d+speed2*(ell*np.pi)**2, e, | |
| eigvals_only=True, select="i", select_range=(0, 20)) | |
| if ell == 0: | |
| lam[0] = 0. | |
| estimate = np.sqrt(np.maximum(lam, 0.)) | |
| root_checks.append({"ell": ell, "cells": n, | |
| "frequency_relative_max_error": float(np.max(np.abs(estimate-omega)/np.maximum(omega, 1.)))}) | |
| values["independent_1d_root_checks"] = root_checks | |
| values["independent_1d_finest_root_relative_max_error"] = max(r["frequency_relative_max_error"] for r in root_checks if r["cells"] == 2048) | |
| n = 16 | |
| mass, A, J, B, R, _, _ = assembly(n) | |
| full = separable_setup(n) | |
| omega, vectors, _ = full_eigenvectors(full) | |
| values["separated_eigensystem_relative_residual"] = relative(A@vectors, vectors*omega[None]**2) | |
| values["separated_eigensystem_orthogonality_error"] = float(np.max(np.abs(vectors.T@vectors-np.eye(n*n)))) | |
| initial = np.zeros((J.shape[0], 3)) | |
| initial[:n*n] = B | |
| short_times = np.linspace(0., 8., 33) | |
| state = expm_multiply(J, initial, start=0., stop=8., num=33, traceA=0.) | |
| values["separated_vs_sparse_pressure_relative_error"] = relative(separable_pressure(full, short_times), state[:, :n*n]) | |
| yy = np.einsum("ir,tis->trs", R, state[:, :n*n], optimize=True) | |
| values["separated_vs_sparse_receiver_relative_error"] = relative(separable_receiver(full, short_times), yy) | |
| values["energy_drift"] = float(np.max(np.abs(np.sum(state**2, axis=1)/np.sum(initial**2, axis=0)-1))) | |
| values["generator_skew_defect"] = float(np.max(np.abs((J+J.T).data), initial=0.)) | |
| # Direct in-cell quadrature verifies the continuous reconstruction identity. | |
| nq = 10 | |
| nodes, weights = np.polynomial.legendre.leggauss(nq) | |
| x = ((np.arange(n)[:, None]+.5)/n+nodes[None]/(2*n)).ravel() | |
| weight = np.tile(weights/(2*n), n) | |
| beta = np.where(x < .5, 1/kk[0], 1/kk[1]) | |
| y = y_values(x, 16) | |
| time = .37 | |
| exact = np.zeros((len(x), len(x))) | |
| for ell in range(17): | |
| xx = x_values(x, q2[ell], amp[ell]) | |
| value = xx @ (data["coefficients"][ell, :, 0]*np.cos(data["omega"][ell]*time)) | |
| exact += value[:, None]*y[:, ell][None] | |
| numerical = separable_pressure(full, [time])[0, :, 0] | |
| p0 = numerical/np.sqrt(mass) | |
| reconstructed = np.repeat(np.repeat(p0.reshape(n, n), nq, axis=0), nq, axis=1) | |
| direct = float(np.einsum("ij,i,j->", (reconstructed-exact)**2, weight*beta, weight)) | |
| projected = exact_mass_weighted_pressure(n, [time])[0, :, 0] | |
| identity = float(np.sum((numerical-projected)**2)+exact_pressure_norm_squared([time])[0, 0]-np.sum(projected**2)) | |
| values["continuous_field_identity_relative_error"] = abs(identity-direct)/direct | |
| values["norm_definition"] = "Continuous beta-weighted pressure norm, including orthogonal unresolved subcell contribution." | |
| numerical_keys = [k for k in values if k.endswith(("max_error", "scaled_max", "relative_error", "relative_residual", "orthogonality_error"))] | |
| # The independent FV-to-continuum convergence has O(h^2), not roundoff, error. | |
| precise_keys = [k for k in numerical_keys if not k.startswith("independent_1d")] | |
| precision_checks = precise_keys+[ | |
| "source_quadrature_relative_change_192_384", "receiver_quadrature_relative_change_192_384", | |
| "root_scan_relative_change_002_001", "receiver_root_scan_relative_change_002_001", "energy_drift"] | |
| values["passed"] = (all(values[k] < 2e-9 for k in precision_checks) | |
| and values["independent_1d_finest_root_relative_max_error"] < 2e-4 | |
| and max(abs(v-1.) for v in values["initial_acoustic_energy"]) < 1e-11 | |
| and max(abs(v) for v in values["zero_mode_coefficients"]) < 1e-13) | |
| (HERE/"results"/"verification.json").write_text(json.dumps(values, indent=2, allow_nan=False)+"\n") | |
| print(json.dumps(values, indent=2), flush=True) | |
| if not values["passed"]: | |
| raise RuntimeError("Unequal-speed verification failed") | |
| if __name__ == "__main__": | |
| import argparse | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--results", action="store_true", | |
| help="Verify saved trajectories, modal budgets, window statistics, and output hashes") | |
| arguments = parser.parse_args() | |
| if arguments.results: | |
| from unequal_speed_interface.verify_outputs import main as verify_outputs_main | |
| verify_outputs_main() | |
| else: | |
| main() | |