File size: 7,727 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
#!/usr/bin/env python3
"""Recompute modal, segmentation, sampling, and polynomial reference checks."""
from __future__ import annotations

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 time

import numpy as np
from scipy.linalg import eigh

from run_propagation import CONFIG, MATERIALS, build_sparse, ports, propagate, relative
from chebyshev_reference import propagate as polynomial_propagate

ROOT = Path(__file__).resolve().parent
RESULTS = ROOT / 'results'
MODAL_CASES = [(name, n) for n in (32, 48) for name in MATERIALS] + [('rotated_stripes', 64)]


def write_json(path, value):
    path.write_text(json.dumps(value, indent=2, allow_nan=False) + '\n')


def load_case(name, n):
    path = RESULTS / f'{name}_n{n}.npz'
    with np.load(path, allow_pickle=False) as archive:
        return {key: archive[key].copy() for key in archive.files}


def modal_check(name, n):
    reference = load_case(name, n)
    started = time.perf_counter()
    x, y, _, bulk, _, coupling, _ = build_sparse(n, name)
    sources = ports(x, y, bulk, CONFIG['source_centres'], True)
    receivers = ports(x, y, bulk, CONFIG['receiver_centres'], False)
    values, vectors = eigh((coupling @ coupling.T).toarray())
    values = np.maximum(values, 0.)
    modal = np.einsum('rm,tm,ms->trs', receivers.T @ vectors,
        np.cos(reference['time'][:, None] * np.sqrt(values)[None, :]),
        vectors.T @ sources, optimize=True)
    difference = relative(reference['receiver_pressure'], modal)
    result = dict(material=name, grid=n, samples=len(reference['time']),
                  modal_relative_difference=difference, seconds=time.perf_counter() - started,
                  passed=difference < 1e-10)
    print(json.dumps({'check': 'dense_modal', **result}), flush=True)
    return result


def clock_checks():
    n, name = 64, 'rotated_stripes'
    baseline = load_case(name, n)
    if int(baseline['samples']) != 641 or float(baseline['chunk_duration']) != 1.:
        baseline = propagate(n, name, samples=641, chunk_duration=1.)
    if not np.array_equal(baseline['time'], np.linspace(0., 8., 641)):
        raise ValueError('The segmentation comparison requires 641 samples on [0, 8].')

    fine = propagate(n, name, samples=1281, chunk_duration=.5)
    np.savez_compressed(RESULTS / 'clock_check_rotated_stripes_n64.npz', **fine)
    if not np.array_equal(fine['time'][::2], baseline['time']):
        raise ValueError('Doubled-sampling output times do not contain the baseline times.')
    common = relative(fine['receiver_pressure'][::2], baseline['receiver_pressure'])
    power = np.sum(fine['receiver_pressure'] ** 2, axis=(1, 2))
    integral_fine = float(np.trapezoid(power, fine['time']))
    integral_coarse = float(np.trapezoid(power[::2], fine['time'][::2]))
    sampling = dict(grid=n, material=name, fine_samples=1281, coarse_samples=641,
        chunk_durations=[1., .5], relative_trace_difference=common,
        max_absolute_trace_difference=float(np.max(abs(fine['receiver_pressure'][::2] - baseline['receiver_pressure']))),
        energy_relative_drift=float(fine['energy_relative_drift']),
        waveform_norm_relative_change=abs(np.sqrt(integral_fine / integral_coarse) - 1),
        quantity='Trapezoidal norm of one waveform, not a cross-grid error numerator.',
        passed=common < 1e-10 and np.isfinite(integral_fine) and integral_coarse > 0)
    sampling['passed'] = bool(sampling['passed'])
    write_json(RESULTS / 'clock_check.json', sampling)
    print(json.dumps({'check': 'output_sampling', **sampling}), flush=True)

    alternate = propagate(n, name, samples=641, chunk_duration=.6625)
    np.savez_compressed(RESULTS / 'clock_check_alternate_chunk_rotated_stripes_n64.npz', **alternate)
    difference = relative(alternate['receiver_pressure'], baseline['receiver_pressure'])
    segmentation = dict(grid=n, material=name, samples=641,
        chunk_durations=[1., .6625], chunk_steps=[80, 53],
        relative_trace_difference=difference,
        max_absolute_trace_difference=float(np.max(abs(alternate['receiver_pressure'] - baseline['receiver_pressure']))),
        energy_relative_drift=float(alternate['energy_relative_drift']), passed=difference < 1e-10)
    write_json(RESULTS / 'clock_check_alternate_chunk.json', segmentation)
    print(json.dumps({'check': 'segmentation', **segmentation}), flush=True)
    return sampling, segmentation


def polynomial_check(n):
    name = 'rotated_stripes'
    reference = load_case(name, n)
    answer = polynomial_propagate(n, name)
    if not np.array_equal(answer['time'], reference['time']):
        raise ValueError('Chebyshev and sparse-exponential observation times differ.')
    record = {key: float(answer[key]) for key in ('energy_relative_drift', 'wall_seconds',
        'uniform_cosine_tail_bound', 'squared_frequency_upper_bound')}
    record.update(material=name, grid=n, polynomial_degree=int(answer['polynomial_degree']),
                  energy_check_times=answer['energy_check_times'].tolist())
    for key in ('receiver_pressure', 'pressure_snapshots'):
        record[key + '_relative_difference'] = relative(answer[key], reference[key])
    record['passed'] = max(record[key + '_relative_difference']
                           for key in ('receiver_pressure', 'pressure_snapshots')) < 2e-10
    print(json.dumps({'check': 'chebyshev', **record}), flush=True)
    return record


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--quick', action='store_true',
                        help='Check only the prescribed striped 32 x 32 modal and polynomial case.')
    args = parser.parse_args()
    RESULTS.mkdir(parents=True, exist_ok=True)
    cases = [('rotated_stripes', 32)] if args.quick else MODAL_CASES
    grids = [32] if args.quick else [32, 64, 256]
    required = {f'{name}_n{n}.npz' for name, n in cases}
    required.update(f'rotated_stripes_n{n}.npz' for n in grids)
    if not args.quick:
        required.add('rotated_stripes_n64.npz')
    missing = [name for name in sorted(required) if not (RESULTS / name).is_file()]
    if missing:
        raise FileNotFoundError('Run the propagation grid ladder first: ' + ', '.join(missing))
    modal = [modal_check(name, n) for name, n in cases]
    sampling, segmentation = (None, None) if args.quick else clock_checks()
    polynomial = [polynomial_check(n) for n in grids]
    suffix = '_quick' if args.quick else ''
    write_json(RESULTS / f'modal_comparison{suffix}.json', modal)
    polynomial_name = 'chebyshev_verification_quick.json' if args.quick else 'chebyshev_verification_n32_64_256.json'
    write_json(RESULTS / polynomial_name, polynomial)
    checks = modal + polynomial + ([sampling, segmentation] if sampling is not None else [])
    summary = dict(mode='quick' if args.quick else 'full', passed=all(row['passed'] for row in checks),
        modal_cases=len(modal), polynomial_cases=len(polynomial),
        maximum_modal_relative_difference=max(row['modal_relative_difference'] for row in modal),
        maximum_polynomial_relative_difference=max(row[key + '_relative_difference']
            for row in polynomial for key in ('receiver_pressure', 'pressure_snapshots')),
        output_sampling=sampling, segmentation=segmentation,
        input_sha256={name: hashlib.sha256((RESULTS / name).read_bytes()).hexdigest() for name in sorted(required)})
    write_json(RESULTS / f'reference_checks{suffix}.json', summary)
    if not summary['passed']:
        raise SystemExit('A propagation reference check failed.')


if __name__ == '__main__':
    main()