File size: 8,290 Bytes
c902ee7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 | #!/usr/bin/env python3
"""Accuracy of full and reduced solutions against the interface modal solution."""
import os
for key in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS"):
os.environ[key] = "2"
import argparse
import hashlib
import json
from pathlib import Path
import sys
import numpy as np
from scipy import linalg
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE.parent))
from accuracy_cost.run import cb_basis, rational_basis
from interface_case.kernel import (CFG, analytic_data, assembly, exact_receiver, exact_pressure_norm_squared,
exact_mass_weighted_pressure, separable_setup, separable_receiver, separable_pressure)
OUT = HERE / "results"
def relative(a, b):
return float(np.linalg.norm(a - b) / np.linalg.norm(b))
def receiver_errors(yy, ref, times):
answer = {}
for end in (2., 8.):
ii = times <= end + 1e-12
answer[f"T{int(end)}"] = {"relative_error": relative(yy[ii], ref[ii]),
"per_source": [relative(yy[ii, :, ss], ref[ii, :, ss]) for ss in range(3)]}
return answer
def field_errors(evaluate, reference, times, cache=None, continuous=False):
numerators = np.zeros((2, 3))
denominators = np.zeros((2, 3))
for start in range(0, len(times), 16):
stop = min(start + 16, len(times))
tt = times[start:stop]
uu = evaluate(tt)
vv = cache[start:stop] if cache is not None else reference(tt)
norm2 = exact_pressure_norm_squared(tt) if continuous else None
# Orthogonality of cell averaging gives the exact unresolved subcell term.
subcell = norm2 - np.sum(vv ** 2, axis=1) if continuous else None
if continuous:
assert np.min(subcell) >= -1e-11
subcell = np.maximum(subcell, 0.)
for j, end in enumerate((2., 8.)):
ii = tt <= end + 1e-12
numerators[j] += np.sum((uu[ii] - vv[ii]) ** 2, axis=(0, 1))
if continuous:
numerators[j] += np.sum(subcell[ii], axis=0)
denominators[j] += np.sum(norm2[ii], axis=0)
else:
denominators[j] += np.sum(vv[ii] ** 2, axis=(0, 1))
return {f"T{int(end)}": {"relative_error": float(np.sqrt(numerators[j].sum() / denominators[j].sum())),
"per_source": np.sqrt(numerators[j] / denominators[j]).tolist()}
for j, end in enumerate((2., 8.))}
def dump(path, answer):
path.write_text(json.dumps(answer, indent=2, allow_nan=False) + "\n")
def save_arrays(path, **arrays):
temporary = path.with_suffix(".partial.npz")
np.savez_compressed(temporary, **arrays)
temporary.replace(path)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--grids", type=int, nargs="+", default=CFG["grids"])
args = parser.parse_args()
if hasattr(os, "sched_getaffinity"):
available = set(os.sched_getaffinity(0))
os.sched_setaffinity(0, available & set(CFG["cpu_affinity"]) or available)
OUT.mkdir(exist_ok=True)
digest = hashlib.sha256((HERE / "config.json").read_bytes()).hexdigest()
for prior in OUT.glob("aligned_impedance_step_*.json"):
if json.loads(prior.read_text())["config_sha256"] != digest:
raise RuntimeError("Existing result configuration differs")
times = np.linspace(0., CFG["time_end"], CFG["samples"])
analytic_data()
yy_exact = exact_receiver(times)
save_arrays(OUT / "analytic_reference.npz", time=times,
receiver_pressure=yy_exact, **analytic_data())
for n in args.grids:
full = separable_setup(n)
yy_full = separable_receiver(full, times)
full_stem = f"aligned_impedance_step_n{n}_full"
# At n<=128 the two pressure histories occupy at most 504 MB combined.
exact_cache = exact_mass_weighted_pressure(n, times) if n <= 128 else None
full_cache = separable_pressure(full, times) if n <= 128 else None
record = {"grid": n, "method": "full_separable", "dimension": n * n,
"config_sha256": digest, "receiver_total_error": receiver_errors(yy_full, yy_exact, times),
"pressure_total_error": field_errors(lambda tt: separable_pressure(full, tt),
lambda tt: exact_mass_weighted_pressure(n, tt), times, exact_cache, continuous=True)}
save_arrays(OUT / f"{full_stem}.npz", time=times, receiver_pressure=yy_full, **full)
dump(OUT / f"{full_stem}.json", record)
print(full_stem, "receiver", record["receiver_total_error"]["T8"]["relative_error"],
"pressure", record["pressure_total_error"]["T8"]["relative_error"], flush=True)
if n not in CFG["reduced_grids"]:
continue
mass, A, J, B, R, rho, bulk = assembly(n)
for m in CFG["modes_per_patch"]:
for method in ("craig_bampton", "rational_krylov"):
stem = f"aligned_impedance_step_n{n}_{method}_m{m}"
if (OUT / f"{stem}.json").exists():
continue
r = n + 2 * m
if (OUT / f"{stem}.npz").exists():
with np.load(OUT / f"{stem}.npz") as raw:
Q = raw["orthonormal_basis"]
V = raw["reduced_eigenvectors"]
lam = raw["reduced_eigenvalues"]
coeff = raw["initial_modal_coefficients"]
details = {}
else:
if method == "craig_bampton":
Q = cb_basis(n, mass, A, m)
details = {}
else:
Q, details = rational_basis(mass, A, B, r)
Ar = Q.T @ (A @ Q)
lam, V = linalg.eigh((Ar + Ar.T) / 2, check_finite=False, driver="evd")
assert lam[0] >= -1e-9 * max(1., lam[-1])
lam[lam < 1e-10] = 0.
coeff = V.T @ (Q.T @ B)
W = Q @ V
observation = R.T @ W
phase = np.cos(times[:, None] * np.sqrt(lam)[None, :])
yy = np.einsum("ir,tr,rs->tis", observation, phase, coeff, optimize=True)
def reduced_pressure(tt):
modal = np.cos(tt[:, None] * np.sqrt(lam)[None, :])[:, :, None] * coeff[None, :, :]
return np.einsum("ir,trs->tis", W, modal, optimize=True)
local_error = yy - yy_full
grid_error = yy_full - yy_exact
cross_norm = np.linalg.norm(local_error) * np.linalg.norm(grid_error)
record = {"grid": n, "method": method, "dimension": r, "modes_per_patch": m,
"config_sha256": digest, "receiver_total_error": receiver_errors(yy, yy_exact, times),
"receiver_same_grid_error": receiver_errors(yy, yy_full, times),
"pressure_total_error": field_errors(reduced_pressure, None, times, exact_cache, continuous=True),
"pressure_same_grid_error": field_errors(reduced_pressure, None, times, full_cache),
"receiver_error_vector_cosine": float(np.sum(local_error * grid_error) / cross_norm) if cross_norm else 0.,
"structure": {"orthonormality_frobenius": float(np.linalg.norm(Q.T @ Q - np.eye(r))),
"initial_pressure_projection_error": relative(Q @ (Q.T @ B), B),
"constant_mode_projection_error": float(np.linalg.norm(np.sqrt(mass) - Q @ (Q.T @ np.sqrt(mass))) / np.linalg.norm(np.sqrt(mass))),
**details}}
if not (OUT / f"{stem}.npz").exists():
save_arrays(OUT / f"{stem}.npz", time=times, receiver_pressure=yy,
orthonormal_basis=Q, reduced_eigenvectors=V, reduced_eigenvalues=lam,
initial_modal_coefficients=coeff, mass=mass)
dump(OUT / f"{stem}.json", record)
print(stem, "receiver_total", record["receiver_total_error"]["T8"]["relative_error"],
"receiver_same", record["receiver_same_grid_error"]["T8"]["relative_error"], flush=True)
del exact_cache, full_cache, mass, A, J, B, R, rho, bulk
if __name__ == "__main__":
main()
|