File size: 9,734 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
#!/usr/bin/env python3
"""Observation and time-window dependence of fixed modal interventions."""
import os
for name in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS"):
    os.environ[name] = "1"
import csv
import hashlib
import json
from pathlib import Path
import numpy as np

HERE = Path(__file__).resolve().parent
SOURCE = HERE.parent
OUT = HERE / "results"
CFG = json.loads((HERE / "config.json").read_text())
KEYS = {"remove_ritz": "no_ritz_frequency_response", "fine_frequency": "fine_frequency_response"}


def digest(path):
    h = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            h.update(block)
    return h.hexdigest()


def write_csv(name, rows):
    with (OUT / name).open("w", newline="") as stream:
        writer = csv.DictWriter(stream, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)


def windows():
    for end in CFG["cumulative_end_times"]:
        yield "cumulative", 0.0, end
    edges = CFG["successive_edges"]
    for start, end in zip(edges[:-1], edges[1:]):
        yield "disjoint", start, end


def main():
    OUT.mkdir(exist_ok=True)
    channel_rows, group_rows, inputs = [], [], {}
    max_identity = 0.0
    max_ritz_identity = 0.0
    tol = CFG["squared_relative_change_zero_tolerance"]
    for material in CFG["materials"]:
        references = {}
        for grid in CFG["reference_grids"]:
            path = SOURCE / "propagation" / "results" / f"{material}_n{grid}.npz"
            with np.load(path) as data:
                references[grid] = (data["time"], data["receiver_pressure"])
            inputs[str(path.relative_to(SOURCE))] = digest(path)
        for method, modes in CFG["models"]:
            path = SOURCE / "modal_diagnostics" / "results" / f"{material}_{method}_m{modes}_decomposition.npz"
            with np.load(path) as data:
                time = data["time"]
                original = data["rom_response"]
                changed = {name: data[key] for name, key in KEYS.items()}
                ritz = data["ritz_frequency"]
            inputs[str(path.relative_to(SOURCE))] = digest(path)
            max_ritz_identity = max(max_ritz_identity,
                float(np.linalg.norm(changed["remove_ritz"] - original + ritz)
                      / np.linalg.norm(original)))
            for grid, (reference_time, reference) in references.items():
                np.testing.assert_array_equal(reference_time, time)
                for kind, start, end in windows():
                    use = (time <= end) & ((time >= start) if start == 0 else (time > start))
                    yref, y = reference[use], original[use]
                    energy = np.sum(yref * yref, axis=0)
                    assert np.all(energy > 0)
                    total_energy = float(energy.sum())
                    error = y - yref
                    sse = np.sum(error * error, axis=0)
                    common = dict(material=material, method=method, modes_per_patch=modes,
                                  reference_grid=grid, window_kind=kind, start=start, end=end,
                                  samples=int(use.sum()))
                    intervention = {}
                    for name, trajectory in changed.items():
                        delta = trajectory[use] - y
                        new_sse = np.sum((trajectory[use] - yref) ** 2, axis=0)
                        square = np.sum(delta * delta, axis=0)
                        cross = 2 * np.sum(error * delta, axis=0)
                        increment = new_sse - sse
                        residual = np.abs(increment - square - cross) / total_energy
                        max_identity = max(max_identity, float(residual.max()))
                        intervention[name] = (new_sse, square, cross, increment)
                    for source in range(3):
                        for receiver in range(4):
                            k = (receiver, source)
                            row = dict(common, source=source + 1, receiver=receiver + 1,
                                reference_energy=float(energy[k]),
                                reference_energy_share=float(energy[k] / total_energy),
                                original_relative_error=float(np.sqrt(sse[k] / energy[k])),
                                original_squared_error_contribution=float(sse[k] / total_energy))
                            for name, (new_sse, square, cross, increment) in intervention.items():
                                row.update({
                                    f"{name}_relative_error": float(np.sqrt(new_sse[k] / energy[k])),
                                    f"{name}_error_change": float((np.sqrt(new_sse[k]) - np.sqrt(sse[k])) / np.sqrt(energy[k])),
                                    f"{name}_squared_error_change_contribution": float(increment[k] / total_energy),
                                    f"{name}_intervention_square_contribution": float(square[k] / total_energy),
                                    f"{name}_intervention_cross_contribution": float(cross[k] / total_energy),
                                    f"{name}_change_sign": int(np.sign(increment[k])) if abs(increment[k]) > tol * energy[k] else 0,
                                })
                            channel_rows.append(row)
                    groups = [("all", 0, np.ones((4, 3), dtype=bool))]
                    for source in range(3):
                        select = np.zeros((4, 3), dtype=bool); select[:, source] = True
                        groups.append(("source", source + 1, select))
                    for receiver in range(4):
                        select = np.zeros((4, 3), dtype=bool); select[receiver, :] = True
                        groups.append(("receiver", receiver + 1, select))
                    for group, index, select in groups:
                        den = float(energy[select].sum())
                        old = float(sse[select].sum())
                        row = dict(common, group=group, index=index,
                            reference_energy_share=den / total_energy,
                            original_relative_error=float(np.sqrt(old / den)))
                        for name, (new_sse, square, cross, increment) in intervention.items():
                            ratio = increment / energy
                            positive, negative = ratio > tol, ratio < -tol
                            row.update({
                                f"{name}_relative_error": float(np.sqrt(new_sse[select].sum() / den)),
                                f"{name}_error_change": float((np.sqrt(new_sse[select].sum()) - np.sqrt(old)) / np.sqrt(den)),
                                f"{name}_squared_error_change_contribution": float(increment[select].sum() / total_energy),
                                f"{name}_increased_error_channels": int((positive & select).sum()),
                                f"{name}_decreased_error_channels": int((negative & select).sum()),
                                f"{name}_neutral_channels": int((~(positive | negative) & select).sum()),
                                f"{name}_increased_error_energy_share": float(energy[positive & select].sum() / den),
                                f"{name}_decreased_error_energy_share": float(energy[negative & select].sum() / den),
                            })
                        group_rows.append(row)
    write_csv("channel_errors.csv", channel_rows)
    write_csv("group_errors.csv", group_rows)
    primary = [r for r in channel_rows if r["reference_grid"] == 512]
    alternative = {(r["material"], r["method"], r["modes_per_patch"], r["window_kind"], r["start"], r["end"], r["source"], r["receiver"]): r
                   for r in channel_rows if r["reference_grid"] == 384}
    sensitivity = []
    for row in primary:
        key = tuple(row[k] for k in ("material", "method", "modes_per_patch", "window_kind", "start", "end", "source", "receiver"))
        other = alternative[key]
        record = {k: row[k] for k in ("material", "method", "modes_per_patch", "window_kind", "start", "end", "source", "receiver")}
        for name in KEYS:
            record[f"{name}_change_difference"] = row[f"{name}_error_change"] - other[f"{name}_error_change"]
            record[f"{name}_sign_changed"] = row[f"{name}_change_sign"] != other[f"{name}_change_sign"]
        sensitivity.append(record)
    write_csv("reference_sensitivity.csv", sensitivity)
    focal = [r for r in group_rows if r["group"] == "all" and r["reference_grid"] == 512
             and r["method"] == "craig_bampton" and r["modes_per_patch"] == 32]
    focal_sensitivity = [r for r in sensitivity if r["method"] == "craig_bampton" and r["modes_per_patch"] == 32]
    summary = dict(channel_rows=len(channel_rows), group_rows=len(group_rows),
        max_normalized_squared_error_identity_residual=max_identity,
        max_relative_remove_ritz_trajectory_identity=max_ritz_identity,
        focal_reference_sign_changes={name: sum(r[f"{name}_sign_changed"] for r in focal_sensitivity) for name in KEYS},
        focal_max_absolute_reference_change_difference={name: max(abs(r[f"{name}_change_difference"]) for r in focal_sensitivity) for name in KEYS},
        focal_aggregate_results=focal,
        input_sha256=inputs, config_sha256=digest(HERE / "config.json"),
        analysis_code_sha256=digest(Path(__file__)))
    (OUT / "summary.json").write_text(json.dumps(summary, indent=2) + "\n")
    print(json.dumps({k: v for k, v in summary.items() if k not in ("focal_aggregate_results", "input_sha256")}, indent=2))


if __name__ == "__main__":
    main()