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