File size: 15,737 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 212 213 214 | #!/usr/bin/env python3
"""Tabulate prescribed channels and source/receiver position contrasts."""
from common import CFG, HERE, OUT, config_digest, csv_write, dump, response
import json
import numpy as np
def groups(source_layout, receiver_layout, layout_config):
sources = layout_config["original_source_centres"] if source_layout == 0 else CFG["source_centres"]
receivers = layout_config["original_receiver_centres"] if receiver_layout == 0 else CFG["receiver_centres"]
same = np.asarray([[(r[0] < .5) == (s[0] < .5) for s in sources] for r in receivers])
answer = [("aggregate", 0, 0, np.ones((4, 3), dtype=bool)),
("same_side", 0, 0, same), ("opposite_sides", 0, 0, ~same)]
for s in range(3):
for r in range(4):
mask = np.zeros((4, 3), dtype=bool)
mask[r, s] = True
answer.append(("channel", s + 1, r + 1, mask))
return answer
def summarize():
layout_config = json.loads((HERE / "layout_config.json").read_text())
reference = np.load(OUT / "factorial_reference.npz")
times = reference["time"]
reference = reference["receiver_pressure"]
accuracy, budgets, pairs = [], [], []
for n in CFG["grids"]:
full = np.load(OUT / f"n{n}_full.npz")
field = np.load(OUT / f"n{n}_pressure_errors.npz")
for a in range(2):
for b in range(2):
yr, yf = full["factorial_receiver_pressure"][a, b], reference[a, b]
for end in CFG["window_ends"]:
active = times <= end + 1e-12
for group, s, r, channels in groups(a, b, layout_config):
ref = yf[active][:, channels]
err = yr[active][:, channels] - ref
accuracy.append({"grid": n, "method": "full", "modes_per_patch": 0, "dimension": n * n,
"source_layout": a, "receiver_layout": b, "time_end": end,
"group": group, "source": s, "receiver": r,
"total_receiver_error": float(np.linalg.norm(err) / np.linalg.norm(ref)),
"same_grid_receiver_error": 0., "reference_squared_norm": float(np.sum(ref ** 2)),
"continuous_pressure_error": float(np.sqrt(field["full_continuous_error_squared"][active].sum() /
field["continuous_norm_squared"][active].sum())) if a == 1 and group == "aggregate" else ""})
for m in CFG["modes_per_patch"]:
model = np.load(OUT / f"n{n}_cb_m{m}.npz")
wr, wh, wf = (model[key] for key in ("matched_reduced_omega", "matched_full_omega", "matched_continuous_omega"))
for j, (ri, hi, fi) in enumerate(zip(model["matched_reduced_indices"], model["matched_full_indices"], model["matched_continuous_indices"])):
pairs.append({"grid": n, "modes_per_patch": m, "dimension": len(model["omega"]),
"reduced_index": int(ri), "full_index": int(hi), "continuous_index": int(fi),
"mac_reduced_full": float(model["mac_reduced_full"][j]),
"mac_full_continuous": float(model["mac_full_continuous"][j]),
"omega_reduced": float(wr[j]), "omega_full": float(wh[j]), "omega_continuous": float(wf[j]),
"relative_ritz_shift": float((wr[j] - wh[j]) / wf[j]),
"relative_grid_shift": float((wh[j] - wf[j]) / wf[j])})
ritz_phase = np.cos(times[:, None] * wr[None]) - np.cos(times[:, None] * wh[None])
grid_phase = np.cos(times[:, None] * wh[None]) - np.cos(times[:, None] * wf[None])
for a in range(2):
for b in range(2):
yf, yh = reference[a, b], full["factorial_receiver_pressure"][a, b]
yr = model["factorial_receiver_pressure"][a, b]
A, B = model["factorial_ritz_frequency"][a, b], model["factorial_grid_frequency"][a, b]
source, receiver, unmatched = (model["factorial_" + key][a, b] for key in ("source_coupling", "receiver_coupling", "unmatched"))
q = source + receiver + unmatched
Hr = model["factorial_reduced_residues"][a, b]
Hf = model["factorial_continuous_residues"][a, b]
omitted = yf - response(times, wf, Hf)
for end in CFG["window_ends"]:
active = times <= end + 1e-12
single_mode = np.sum(-ritz_phase[active] ** 2 - 2 * ritz_phase[active] * grid_phase[active], axis=0)
for group, s, r, channels in groups(a, b, layout_config):
ref = yf[active][:, channels]
er = (yr - yf)[active][:, channels]
er0 = (yr - A - yf)[active][:, channels]
er_cont = (yr - A - B - yf)[active][:, channels]
aa, bb, qq = (item[active][:, channels] for item in (A, B, q))
den = float(np.sum(ref ** 2))
exact = float((np.sum(er0 ** 2) - np.sum(er ** 2)) / den)
diagonal = float(single_mode @ np.sum(Hr[:, channels] ** 2, axis=1) / den)
frequency = float((-np.sum(aa ** 2) - 2 * np.sum(aa * bb)) / den)
cross_mode = frequency - diagonal
remainder_cross = float(-2 * np.sum(aa * qq) / den)
total = float(np.linalg.norm(er) / np.sqrt(den))
replaced = float(np.linalg.norm(er0) / np.sqrt(den))
key = {"grid": n, "method": "craig_bampton", "modes_per_patch": m, "dimension": len(model["omega"]),
"source_layout": a, "receiver_layout": b, "time_end": end,
"group": group, "source": s, "receiver": r}
same_grid = float(np.linalg.norm((yr - yh)[active][:, channels]) / np.linalg.norm(yh[active][:, channels]))
accuracy.append(key | {"total_receiver_error": total, "same_grid_receiver_error": same_grid,
"reference_squared_norm": den,
"continuous_pressure_error": float(np.sqrt(field[f"m{m}_continuous_error_squared"][active].sum() /
field["continuous_norm_squared"][active].sum())) if a == 1 and group == "aggregate" else ""})
weights = np.linalg.norm(Hf[:, channels], axis=1)
weights /= max(weights.sum(), 1e-300)
budgets.append(key | {"accepted_triples": len(wr), "total_receiver_error": total,
"same_grid_receiver_error": same_grid, "coarse_replacement_error": replaced,
"continuous_replacement_error": float(np.linalg.norm(er_cont) / np.sqrt(den)),
"change_percentage_points": 100 * (replaced - total), "delta_squared_error": exact,
"same_mode_term": diagonal, "cross_mode_term": cross_mode, "remainder_cross_term": remainder_cross,
"source_cross_term": float(-2 * np.sum(aa * source[active][:, channels]) / den),
"receiver_cross_term": float(-2 * np.sum(aa * receiver[active][:, channels]) / den),
"unmatched_cross_term": float(-2 * np.sum(aa * unmatched[active][:, channels]) / den),
"budget_absolute_defect": abs(exact - diagonal - cross_mode - remainder_cross),
"ritz_relative_norm": float(np.linalg.norm(aa) / np.sqrt(den)),
"grid_relative_norm": float(np.linalg.norm(bb) / np.sqrt(den)),
"remainder_relative_norm": float(np.linalg.norm(qq) / np.sqrt(den)),
"matched_reference_omission": float(np.linalg.norm(omitted[active][:, channels]) / np.sqrt(den)),
"weighted_relative_grid_shift": float(weights @ ((wh - wf) / wf)),
"weighted_relative_ritz_shift": float(weights @ ((wr - wh) / wf)),
"reference_squared_norm": den})
csv_write(OUT / "accuracy.csv", accuracy)
csv_write(OUT / "finite_time_budgets.csv", budgets)
csv_write(OUT / "modal_pairs.csv", pairs)
primary = [row for row in budgets if row["source_layout"] == row["receiver_layout"] == 1]
csv_write(OUT / "second_layout_budgets.csv", primary)
cases = []
for n in CFG["grids"]:
for m in CFG["modes_per_patch"]:
for end in CFG["window_ends"]:
selected = [row for row in primary if row["grid"] == n and row["modes_per_patch"] == m and row["time_end"] == end]
agg = next(row for row in selected if row["group"] == "aggregate")
channels = [row for row in selected if row["group"] == "channel"]
sides = {row["group"]: row["change_percentage_points"] for row in selected if row["group"] in ("same_side", "opposite_sides")}
cases.append({"grid": n, "modes_per_patch": m, "time_end": end,
"total_receiver_error": agg["total_receiver_error"], "coarse_replacement_error": agg["coarse_replacement_error"],
"change_percentage_points": agg["change_percentage_points"], "accepted_triples": agg["accepted_triples"],
"beneficial_ritz_channels": sum(row["change_percentage_points"] > 1e-10 for row in channels),
"harmful_ritz_channels": sum(row["change_percentage_points"] < -1e-10 for row in channels),
"same_side_change_percentage_points": sides["same_side"],
"opposite_sides_change_percentage_points": sides["opposite_sides"]})
summary = {"config_sha256": config_digest(), "accuracy_rows": len(accuracy), "budget_rows": len(budgets),
"matched_mode_rows": len(pairs), "maximum_budget_absolute_defect": max(row["budget_absolute_defect"] for row in budgets),
"second_layout_cases": cases,
"factorial_T8_aggregate": [row for row in budgets if row["group"] == "aggregate" and row["time_end"] == 8.]}
contrasts, example = position_contrasts(budgets)
csv_write(OUT / "position_contrasts.csv", contrasts)
summary["position_contrast_rows"] = len(contrasts)
summary["channel_position_sign_reversals"] = sum(row["sign_reversal"] for row in contrasts if row["group"] == "channel")
summary["aggregate_position_sign_reversals"] = [row for row in contrasts if row["group"] == "aggregate" and row["sign_reversal"]]
summary["illustrative_position_reversal"] = example
summary["figure_position_examples"] = figure_examples(budgets)
dump(OUT / "summary.json", summary)
return accuracy, budgets, summary
def position_contrasts(budgets):
cases = [("source", (0, 0), (1, 0)), ("source", (0, 1), (1, 1)),
("receiver", (0, 0), (0, 1)), ("receiver", (1, 0), (1, 1))]
index = {(row["grid"], row["modes_per_patch"], row["time_end"], row["source_layout"], row["receiver_layout"],
row["group"], row["source"], row["receiver"]): row for row in budgets}
rows = []
for n in CFG["grids"]:
for m in CFG["modes_per_patch"]:
for end in CFG["window_ends"]:
for changed, before, after in cases:
before_aggregate = index[(n, m, end, *before, "aggregate", 0, 0)]
after_aggregate = index[(n, m, end, *after, "aggregate", 0, 0)]
norm = np.sqrt(before_aggregate["reference_squared_norm"] * after_aggregate["reference_squared_norm"])
for group, s, r in [("aggregate", 0, 0)] + [("channel", s, r) for s in range(1, 4) for r in range(1, 5)]:
first, second = index[(n, m, end, *before, group, s, r)], index[(n, m, end, *after, group, s, r)]
d0, d1 = first["delta_squared_error"], second["delta_squared_error"]
reversal = d0 * d1 < 0 and min(abs(d0), abs(d1)) > 1e-12
strength = min(abs(d0 * first["reference_squared_norm"]), abs(d1 * second["reference_squared_norm"])) / norm
rows.append({"grid": n, "modes_per_patch": m, "time_end": end, "changed_positions": changed,
"before_source_layout": before[0], "before_receiver_layout": before[1],
"after_source_layout": after[0], "after_receiver_layout": after[1],
"group": group, "source": s, "receiver": r, "sign_reversal": int(reversal),
"before_change_percentage_points": first["change_percentage_points"],
"after_change_percentage_points": second["change_percentage_points"],
"before_delta_squared_error": d0, "after_delta_squared_error": d1,
"before_reference_energy_fraction": first["reference_squared_norm"] / before_aggregate["reference_squared_norm"],
"after_reference_energy_fraction": second["reference_squared_norm"] / after_aggregate["reference_squared_norm"],
"display_strength": float(strength)})
candidates = [row for row in rows if row["group"] == "channel" and row["sign_reversal"]]
example = max(candidates, key=lambda row: row["display_strength"]) if candidates else None
if example is not None:
example = example.copy()
base = (example["grid"], example["modes_per_patch"], example["time_end"])
example["before_budget"] = index[(*base, example["before_source_layout"], example["before_receiver_layout"],
"channel", example["source"], example["receiver"])]
example["after_budget"] = index[(*base, example["after_source_layout"], example["after_receiver_layout"],
"channel", example["source"], example["receiver"])]
return rows, example
def figure_examples(budgets):
contrasts, _ = position_contrasts(budgets)
selected = []
for changed in ("source", "receiver"):
candidates = [row for row in contrasts if row["group"] == "channel" and row["sign_reversal"]
and row["changed_positions"] == changed]
chosen = max(candidates, key=lambda row: row["display_strength"])
first = next(row for row in budgets if row["group"] == "channel" and row["grid"] == chosen["grid"]
and row["modes_per_patch"] == chosen["modes_per_patch"] and row["time_end"] == chosen["time_end"]
and row["source"] == chosen["source"] and row["receiver"] == chosen["receiver"]
and row["source_layout"] == chosen["before_source_layout"] and row["receiver_layout"] == chosen["before_receiver_layout"])
second = next(row for row in budgets if row["group"] == "channel" and row["grid"] == chosen["grid"]
and row["modes_per_patch"] == chosen["modes_per_patch"] and row["time_end"] == chosen["time_end"]
and row["source"] == chosen["source"] and row["receiver"] == chosen["receiver"]
and row["source_layout"] == chosen["after_source_layout"] and row["receiver_layout"] == chosen["after_receiver_layout"])
selected.append(chosen | {"before_budget": first, "after_budget": second})
return selected
def main():
_, _, summary = summarize()
print(json.dumps(summary, indent=2))
if __name__ == "__main__":
main()
|