File size: 15,318 Bytes
cfbe945
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
#!/usr/bin/env python3
"""Check the continuous reference, projections, saved responses and budgets."""
from common import CFG, HERE, OUT, acoustic, config_digest, dump
import csv
import hashlib
import json
import zipfile
import numpy as np
from numpy.polynomial.legendre import leggauss
from scipy.sparse.linalg import expm_multiply


def relative(a, b):
    return float(np.linalg.norm(a - b) / max(np.linalg.norm(b), 1e-300))


def modal_response(times, omega, coefficients, observation):
    phases = np.cos(np.outer(times, omega))
    output = np.zeros((len(times), observation.shape[0], coefficients.shape[1]))
    for j in range(len(omega)):
        output += phases[:, j, None, None] * np.outer(observation[:, j], coefficients[j])[None]
    return output


def quadrature_ports(n, initial, receiver_centres):
    points, weights = leggauss(12)
    x = ((np.arange(n)[:, None] + .5 + points[None] / 2) / n).ravel()
    xx = np.stack([acoustic.x_values(x, initial["q_squared"][ell], initial["amplitudes"][ell])
                   .reshape(n, 12, -1).transpose(0, 2, 1) @ (weights / 2)
                   for ell in range(CFG["max_y_mode"] + 1)])
    yy = acoustic.y_values(x, CFG["max_y_mode"]).reshape(n, 12, -1)
    yy = np.einsum("ijl,j->il", yy, weights / 2)
    B = np.einsum("lim,jl,lms->ijs", xx, yy, initial["coefficients"], optimize=True).reshape(n * n, 3)
    mass = acoustic.mass_vector(n)
    B *= np.sqrt(mass)[:, None]
    receivers = []
    for cx, cy in receiver_centres:
        gx = np.exp(-.5 * ((x - cx) / CFG["sigma"]) ** 2).reshape(n, 12) @ (weights / (2 * n))
        gy = np.exp(-.5 * ((x - cy) / CFG["sigma"]) ** 2).reshape(n, 12) @ (weights / (2 * n))
        receivers.append((np.outer(gx, gy) / (gx.sum() * gy.sum())).ravel() / np.sqrt(mass))
    return B, np.stack(receivers, axis=1)


def selected_full_vectors(full, indices):
    n = len(full["y_eigenvectors"])
    raw = full["full_sort_order"][indices]
    ell, longitudinal = np.divmod(raw, n)
    return np.column_stack([np.outer(full["x_eigenvectors"][l, :, m], full["y_eigenvectors"][:, l]).ravel()
                            for l, m in zip(ell, longitudinal)])


def selected_continuous_vectors(n, fine, indices):
    x = (np.arange(n) + .5) / n
    ell = fine["ell"][indices]
    xx = acoustic.x_values(x, fine["q_squared"][indices], fine["amplitudes"][indices], 1 / n)
    yy = acoustic.y_values(x, ell.max())[:, ell] * np.sinc(ell / (2 * n))[None]
    vectors = np.einsum("ik,jk->ijk", xx, yy).reshape(n * n, -1) * np.sqrt(acoustic.mass_vector(n))[:, None]
    return vectors / np.linalg.norm(vectors, axis=0)[None]


def channel_mask(row, layout_config):
    group = row["group"]
    if group == "aggregate":
        return np.ones((4, 3), dtype=bool)
    if group == "channel":
        mask = np.zeros((4, 3), dtype=bool)
        mask[int(row["receiver"]) - 1, int(row["source"]) - 1] = True
        return mask
    sources = layout_config["original_source_centres"] if int(row["source_layout"]) == 0 else CFG["source_centres"]
    receivers = layout_config["original_receiver_centres"] if int(row["receiver_layout"]) == 0 else CFG["receiver_centres"]
    mask = np.asarray([[(r[0] < .5) == (s[0] < .5) for s in sources] for r in receivers])
    return mask if group == "same_side" else ~mask


def main():
    layout_config = json.loads((HERE / "layout_config.json").read_text())
    environment = json.loads((OUT / "environment.json").read_text())
    checks = {"configuration_matches": config_digest() == environment["config_sha256"],
              "layout_configuration_matches": hashlib.sha256((HERE / "layout_config.json").read_bytes()).hexdigest() == environment["layout_config_sha256"]}
    archives = sorted(OUT.glob("*.npz"))
    for path in archives:
        with zipfile.ZipFile(path) as archive:
            if archive.testzip() is not None:
                raise IOError(f"Corrupt NPZ: {path.name}")
    reference = np.load(OUT / "continuous_reference.npz")
    factorial = np.load(OUT / "factorial_reference.npz")
    fine = np.load(OUT / "continuous_catalogue.npz")
    t = reference["time"]
    yf = factorial["receiver_pressure"]
    quadrature = acoustic.exact_receiver(t, order=384)
    refined_roots = acoustic.exact_receiver(t, scan_step=.01)
    checks["new_reference_quadrature_relative_difference"] = relative(quadrature, reference["receiver_pressure"])
    checks["new_reference_root_scan_relative_difference"] = relative(refined_roots, reference["receiver_pressure"])
    checks["continuous_initial_energy_max_error"] = float(np.max(abs(.5 * np.sum(reference["coefficients"] ** 2, axis=(0, 1)) - 1)))
    checks["primary_factorial_reference_difference"] = relative(yf[1, 1], reference["receiver_pressure"])
    checks["original_reference_regression_difference"] = relative(yf[0, 0], np.load(HERE.parent / "unequal_speed_interface/results/continuous_reference.npz")["receiver_pressure"])
    source_coefficients = [factorial["original_catalogue_coefficients"], fine["coefficients"]]
    receiver_modes = [factorial["original_catalogue_receiver_modes"], fine["receiver_modes"]]
    checks["factorial_reference_modal_replay_difference"] = max(relative(modal_response(t, fine["omega"], source_coefficients[a], receiver_modes[b]), yf[a, b]) for a in range(2) for b in range(2))
    initial = {key: reference[key] for key in ("omega", "q_squared", "amplitudes", "coefficients")}
    original_initial = initial | {"coefficients": factorial["original_coefficients"]}
    max_values = {key: 0. for key in ("cell_average_initialization_difference", "receiver_cell_quadrature_difference",
        "original_full_response_regression_difference", "original_reduced_response_regression_difference", "original_reduced_frequency_regression_difference",
        "reduced_orthonormality", "projected_eigenproblem_relative_residual", "full_modal_eigenproblem_relative_residual",
        "reduced_full_mac_absolute_difference", "full_continuous_mac_absolute_difference",
        "receiver_modal_replay_difference", "direct_frequency_terms_difference", "independent_budget_absolute_difference",
        "diagonal_budget_absolute_difference", "tabulated_receiver_error_difference", "pressure_error_replay_difference")}
    budget_rows = list(csv.DictReader((OUT / "finite_time_budgets.csv").open()))
    accuracy_rows = list(csv.DictReader((OUT / "accuracy.csv").open()))
    replayed_rows = 0
    for n in CFG["grids"]:
        full = np.load(OUT / f"n{n}_full.npz")
        field = np.load(OUT / f"n{n}_pressure_errors.npz")
        _, A, _, _, _, _, _ = acoustic.assembly(n)
        for data, receiver_positions, bname, rname in ((initial, CFG["receiver_centres"], "B", "R"),
            (original_initial, layout_config["original_receiver_centres"], "original_B", "original_R")):
            B, R = quadrature_ports(n, data, receiver_positions)
            max_values["cell_average_initialization_difference"] = max(max_values["cell_average_initialization_difference"], relative(B, full[bname]))
            max_values["receiver_cell_quadrature_difference"] = max(max_values["receiver_cell_quadrature_difference"], relative(R, full[rname]))
        old = np.load(HERE.parent / f"unequal_speed_interface/results/n{n}_full_receiver.npz")
        max_values["original_full_response_regression_difference"] = max(max_values["original_full_response_regression_difference"], relative(full["factorial_receiver_pressure"][0, 0], old["receiver_pressure"]))
        for m in CFG["modes_per_patch"]:
            model = np.load(OUT / f"n{n}_cb_m{m}.npz")
            W, omega = model["eigenvectors"], model["omega"]
            old = np.load(HERE.parent / f"unequal_speed_interface/results/n{n}_craig_bampton_m{m}.npz")
            max_values["original_reduced_response_regression_difference"] = max(max_values["original_reduced_response_regression_difference"], relative(model["factorial_receiver_pressure"][0, 0], old["receiver_pressure"]))
            max_values["original_reduced_frequency_regression_difference"] = max(max_values["original_reduced_frequency_regression_difference"], relative(omega, old["omega"]))
            max_values["reduced_orthonormality"] = max(max_values["reduced_orthonormality"], float(np.linalg.norm(W.T @ W - np.eye(len(omega)))))
            projected = W.T @ (A @ W)
            max_values["projected_eigenproblem_relative_residual"] = max(max_values["projected_eigenproblem_relative_residual"], relative(projected, np.diag(omega ** 2)))
            hi, fi, ri = (model[key] for key in ("matched_full_indices", "matched_continuous_indices", "matched_reduced_indices"))
            Vh, Vf = selected_full_vectors(full, hi), selected_continuous_vectors(n, fine, fi)
            wh = model["matched_full_omega"]
            max_values["full_modal_eigenproblem_relative_residual"] = max(max_values["full_modal_eigenproblem_relative_residual"], relative(A @ Vh, Vh * wh[None] ** 2))
            max_values["reduced_full_mac_absolute_difference"] = max(max_values["reduced_full_mac_absolute_difference"], float(np.max(abs(np.sum(W[:, ri] * Vh, axis=0) ** 2 - model["mac_reduced_full"]))))
            max_values["full_continuous_mac_absolute_difference"] = max(max_values["full_continuous_mac_absolute_difference"], float(np.max(abs(np.sum(Vh * Vf, axis=0) ** 2 - model["mac_full_continuous"]))))
            for a in range(2):
                for b in range(2):
                    br, cr = model["factorial_source_coefficients"][a], model["factorial_receiver_modes"][b]
                    yr = model["factorial_receiver_pressure"][a, b]
                    direct = modal_response(t, omega, br, cr)
                    max_values["receiver_modal_replay_difference"] = max(max_values["receiver_modal_replay_difference"], relative(direct, yr))
                    Hr = model["factorial_reduced_residues"][a, b]
                    wr, wf = model["matched_reduced_omega"], model["matched_continuous_omega"]
                    Aj = (np.cos(np.outer(t, wr)) - np.cos(np.outer(t, wh)))[:, :, None, None] * Hr[None]
                    Bj = (np.cos(np.outer(t, wh)) - np.cos(np.outer(t, wf)))[:, :, None, None] * Hr[None]
                    aa, bb = Aj.sum(axis=1), Bj.sum(axis=1)
                    qq = yr - yf[a, b] - aa - bb
                    max_values["direct_frequency_terms_difference"] = max(max_values["direct_frequency_terms_difference"],
                        float(np.linalg.norm(aa - model["factorial_ritz_frequency"][a, b]) / np.linalg.norm(yf[a, b])),
                        float(np.linalg.norm(bb - model["factorial_grid_frequency"][a, b]) / np.linalg.norm(yf[a, b])))
                    selected = [row for row in budget_rows if int(row["grid"]) == n and int(row["modes_per_patch"]) == m
                        and int(row["source_layout"]) == a and int(row["receiver_layout"]) == b]
                    for row in selected:
                        active = t <= float(row["time_end"]) + 1e-12
                        channels = channel_mask(row, layout_config)
                        ref = yf[a, b][active][:, channels]
                        e = (yr - yf[a, b])[active][:, channels]
                        ra, gb, remainder = (item[active][:, channels] for item in (aa, bb, qq))
                        den = np.sum(ref ** 2)
                        budget = (-np.sum(ra ** 2) - 2 * np.sum(ra * gb) - 2 * np.sum(ra * remainder)) / den
                        diagonal = (-np.sum(Aj[active][:, :, channels] ** 2) - 2 * np.sum(Aj[active][:, :, channels] * Bj[active][:, :, channels])) / den
                        max_values["independent_budget_absolute_difference"] = max(max_values["independent_budget_absolute_difference"], abs(float(budget) - float(row["delta_squared_error"])))
                        max_values["diagonal_budget_absolute_difference"] = max(max_values["diagonal_budget_absolute_difference"], abs(float(diagonal) - float(row["same_mode_term"])))
                        original_error = float(np.sqrt(np.sum(e ** 2) / den))
                        replaced_error = float(np.sqrt(np.sum((e - ra) ** 2) / den))
                        max_values["tabulated_receiver_error_difference"] = max(max_values["tabulated_receiver_error_difference"],
                            abs(original_error - float(row["total_receiver_error"])), abs(replaced_error - float(row["coarse_replacement_error"])))
                        replayed_rows += 1
            selected_times = [0, 40, 160, 640]
            tt = t[selected_times]
            exact = acoustic.exact_mass_weighted_pressure(n, tt)
            full_field = acoustic.separable_pressure(full, tt)
            modal = np.cos(tt[:, None] * omega[None])[:, :, None] * model["coefficients"][None]
            pressure = np.stack([W @ modal[j] for j in range(len(tt))])
            subcell = acoustic.exact_pressure_norm_squared(tt) - np.sum(exact ** 2, axis=1)
            values = np.sum((pressure - exact) ** 2, axis=1) + subcell
            values_h = np.sum((pressure - full_field) ** 2, axis=1)
            max_values["pressure_error_replay_difference"] = max(max_values["pressure_error_replay_difference"],
                float(np.max(abs(values - field[f"m{m}_continuous_error_squared"][selected_times]))),
                float(np.max(abs(values_h - field[f"m{m}_same_grid_error_squared"][selected_times]))))
    n = 16
    mass, _, J, B, R, _, _ = acoustic.assembly(n)
    state0 = np.zeros((J.shape[0], 3))
    state0[:n * n] = B
    state = expm_multiply(J, state0, start=0., stop=.5, num=3, traceA=0.)
    separated = acoustic.separable_setup(n)
    expected = acoustic.separable_pressure(separated, [0., .25, .5])
    checks["independent_sparse_propagation_pressure_difference"] = relative(state[:, :n * n], expected)
    checks["independent_sparse_propagation_receiver_difference"] = relative(np.einsum("ir,tis->trs", R, state[:, :n * n]), acoustic.separable_receiver(separated, [0., .25, .5]))
    checks["independent_sparse_energy_drift"] = float(np.max(abs(np.sum(state ** 2, axis=1) / np.sum(state0 ** 2, axis=0) - 1)))
    checks.update(max_values)
    numeric = {key: value for key, value in checks.items() if not isinstance(value, bool)}
    tolerances = {key: 5e-10 for key in numeric}
    tolerances["independent_budget_absolute_difference"] = 1e-11
    tolerances["diagonal_budget_absolute_difference"] = 1e-11
    tolerances["tabulated_receiver_error_difference"] = 1e-11
    passed = all(value for value in checks.values() if isinstance(value, bool)) and all(value < tolerances[key] for key, value in numeric.items()) and replayed_rows == len(budget_rows) == 1080
    record = {"passed": passed, "npz_archives_crc_checked": len(archives), "budget_rows_replayed": replayed_rows,
              "accuracy_rows_checked": len(accuracy_rows), "checks": checks, "tolerances": tolerances,
              "configuration_sha256": config_digest()}
    dump(OUT / "verification.json", record)
    print(f"Verified {len(archives)} NPZ archives and {replayed_rows} exact budgets: {'passed' if passed else 'failed'}.")
    print(f"Maximum independent budget difference: {max_values['independent_budget_absolute_difference']:.3e}; report: results/verification.json")
    if not passed:
        raise RuntimeError("Second-layout verification failed")


if __name__ == "__main__":
    main()