File size: 10,490 Bytes
68db0a3 | 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 | #!/usr/bin/env python3
"""Complete cost envelopes for the fixed SV/CB family on a uniform grid sweep."""
import os
for key in ('OPENBLAS_NUM_THREADS','OMP_NUM_THREADS','MKL_NUM_THREADS'):
os.environ[key]='1'
import csv
import hashlib
import json
from pathlib import Path
import numpy as np
HERE=Path(__file__).resolve().parent
ROOT=HERE.parent
def dump(path,value):
path.write_text(json.dumps(value,indent=2,allow_nan=False)+'\n')
def relative(a,b):
return float(np.linalg.norm(a-b)/np.linalg.norm(b))
def write_csv(path,rows):
keys=list(dict.fromkeys(k for row in rows for k in row))
with path.open('w',newline='') as stream:
writer=csv.DictWriter(stream,fieldnames=keys)
writer.writeheader()
writer.writerows({k:json.dumps(v) if isinstance(v,(list,dict)) else v for k,v in row.items()} for row in rows)
def encode(row):
if row is None:return None
keys=('grid','method','modes_per_patch','requested_cfl','dimension','total_receiver_error',
'alternative_reference_total_receiver_error','total_seconds','minimum_total_seconds','maximum_total_seconds')
return {key:row[key] for key in keys}
def identify(row):
return None if row is None else (row['grid'],row['method'],row['modes_per_patch'],row['requested_cfl'])
def select(rows,epsilon):
selected={}
for ref,key in [('primary','total_receiver_error'),('alternative','alternative_reference_total_receiver_error')]:
for group in ('full','reduced'):
available=[row for row in rows if row[key]<=epsilon and row['method'].startswith('full_')==(group=='full')]
selected[ref+'_'+group]=min(available,key=lambda r:r['total_seconds']) if available else None
result={'tolerance':epsilon,**{key:encode(value) for key,value in selected.items()}}
full,reduced=selected['primary_full'],selected['primary_reduced']
result['median_full_over_reduced']=None if full is None or reduced is None else full['total_seconds']/reduced['total_seconds']
result['fastest_full_over_slowest_reduced']=None if full is None or reduced is None else full['minimum_total_seconds']/reduced['maximum_total_seconds']
result['slowest_full_over_fastest_reduced']=None if full is None or reduced is None else full['maximum_total_seconds']/reduced['minimum_total_seconds']
alternate_full,alternate_reduced=selected['alternative_full'],selected['alternative_reduced']
result['alternative_median_full_over_reduced']=None if alternate_full is None or alternate_reduced is None else alternate_full['total_seconds']/alternate_reduced['total_seconds']
result['alternative_fastest_full_over_slowest_reduced']=None if alternate_full is None or alternate_reduced is None else alternate_full['minimum_total_seconds']/alternate_reduced['maximum_total_seconds']
result['selection_unchanged_by_reference']=all(identify(selected['primary_'+group])==identify(selected['alternative_'+group]) for group in ('full','reduced'))
result['candidates_changing_threshold_classification']=sum((r['total_receiver_error']<=epsilon)!=(r['alternative_reference_total_receiver_error']<=epsilon) for r in rows)
return result
def envelope(rows,lower,upper):
breaks=sorted({lower,upper}|{r[key] for r in rows for key in ('total_receiver_error','alternative_reference_total_receiver_error') if lower<r[key]<upper})
points=[select(rows,epsilon) for epsilon in breaks]
intervals=[{'lower_tolerance':left['tolerance'],'upper_tolerance':right['tolerance'],
'lower_closed':True,'upper_closed':False,**{k:v for k,v in left.items() if k!='tolerance'}}
for left,right in zip(points[:-1],points[1:])]
ratios=[p['median_full_over_reduced'] for p in points if p['median_full_over_reduced'] is not None]
conservative=[p['fastest_full_over_slowest_reduced'] for p in points if p['fastest_full_over_slowest_reduced'] is not None]
alternate_ratios=[p['alternative_median_full_over_reduced'] for p in points if p['alternative_median_full_over_reduced'] is not None]
merged=[]
for interval in intervals:
pair=(identify(interval['primary_full']),identify(interval['primary_reduced']))
if merged and pair==merged[-1]['candidate_pair']:
merged[-1]['upper_tolerance']=interval['upper_tolerance']
merged[-1]['selection_unchanged_throughout_interval'] &= interval['selection_unchanged_by_reference']
else:
merged.append({**interval,'candidate_pair':pair,
'selection_unchanged_throughout_interval':interval['selection_unchanged_by_reference']})
return {'breakpoints':breaks,'points':points,'intervals':intervals,'endpoint':points[-1],
'merged_primary_selection_intervals':merged,
'median_reduction_advantage_intervals':[p for p in merged if p['median_full_over_reduced'] is not None and p['median_full_over_reduced']>1],
'separated_timing_range_advantage_intervals':[p for p in merged if p['fastest_full_over_slowest_reduced'] is not None and p['fastest_full_over_slowest_reduced']>1],
'maximum_median_full_over_reduced':max(ratios,default=None),
'maximum_fastest_full_over_slowest_reduced':max(conservative,default=None),
'maximum_alternative_median_full_over_reduced':max(alternate_ratios,default=None),
'minimum_median_full_over_reduced':min(ratios,default=None)}
def main():
cfg=json.loads((HERE/'config.json').read_text())
expected=len(cfg['materials'])*len(cfg['grids'])*(len(cfg['explicit_cfl_values'])+1)
paths=sorted((HERE/'results'/'candidates').glob('*_timing.json'))
if len(paths)!=expected:
raise RuntimeError(f'Complete batch required: expected {expected}, found {len(paths)}')
references={}
ref_hashes={}
for material in cfg['materials']:
references[material]={}
for grid in (cfg['reference_grid'],cfg['alternative_reference_grid']):
path=ROOT/'propagation'/'results'/f'{material}_n{grid}.npz'
with np.load(path) as data:
references[material][grid]=data['receiver_pressure'].copy()
np.testing.assert_array_equal(data['time'],np.linspace(0,cfg['time_end'],cfg['samples']))
ref_hashes[str(path.relative_to(ROOT))]=hashlib.sha256(path.read_bytes()).hexdigest()
rows=[]
for path in paths:
record=json.loads(path.read_text())
material=record['material']
with np.load(path.with_name(path.name.replace('_timing.json','.npz'))) as data:
y=data['receiver_pressure'].copy()
np.testing.assert_array_equal(data['time'],np.linspace(0,cfg['time_end'],cfg['samples']))
reference=references[material][cfg['reference_grid']]
alternative=references[material][cfg['alternative_reference_grid']]
rows.append({key:record[key] for key in ('material','grid','method','modes_per_patch','requested_cfl','dimension')})
rows[-1].update(total_receiver_error=relative(y,reference),
alternative_reference_total_receiver_error=relative(y,alternative),
reference_grid_difference=relative(alternative,reference),
per_source_total_receiver_error=[relative(y[:,:,s],reference[:,:,s]) for s in range(3)],
total_seconds=record['median']['total_seconds'],minimum_total_seconds=record['median']['minimum_total_seconds'],
maximum_total_seconds=record['median']['maximum_total_seconds'],
time_repetitions=[sum(stages.values()) for stages in record['repetitions']])
seen={(r['material'],r['grid'],r['method'],r['requested_cfl']) for r in rows}
prescribed={(material,n,method,cfl) for material in cfg['materials'] for n in cfg['grids']
for method,cfl in [('full_stormer_verlet',c) for c in cfg['explicit_cfl_values']]+[('craig_bampton',None)]}
assert seen==prescribed and len(rows)==len(seen)
write_csv(HERE/'results'/'receiver_errors.csv',rows)
lower,upper=min(cfg['receiver_tolerances']),max(cfg['receiver_tolerances'])
envelopes={}
sparse_envelopes={}
selections=[]
flat_intervals=[]
for material in cfg['materials']:
candidates=[r for r in rows if r['material']==material]
envelopes[material]=envelope(candidates,lower,upper)
sparse_envelopes[material]=envelope([r for r in candidates if r['grid'] in (64,96,128)],lower,upper)
for epsilon in cfg['receiver_tolerances']:
selections.append({'material':material,**select(candidates,epsilon)})
for interval in envelopes[material]['intervals']:
flat={'material':material,**{k:v for k,v in interval.items() if not isinstance(v,dict) and k not in ('primary_full','primary_reduced','alternative_full','alternative_reduced')}}
for group in ('primary_full','primary_reduced','alternative_full','alternative_reduced'):
if interval[group] is not None:
flat.update({group+'_'+k:v for k,v in interval[group].items()})
flat_intervals.append(flat)
write_csv(HERE/'results'/'tolerance_cost_intervals.csv',flat_intervals)
dump(HERE/'results'/'tolerance_cost_envelope.json',{'range':[lower,upper],
'materials':envelopes,'sparse_grid_subset_same_batch':sparse_envelopes,
'scope':'Every candidate error from both references supplies a breakpoint. Intervals are left closed and right open; the 10% endpoint is retained. Both solver families are compared only when both have a passing candidate.'})
summary={'complete':True,'settings':len(rows),'repetitions':cfg['repetitions'],
'reference_grid':cfg['reference_grid'],'alternative_reference_grid':cfg['alternative_reference_grid'],
'reference_sha256':ref_hashes,'receiver_tolerances':cfg['receiver_tolerances'],'selections':selections,
'envelope_extrema':{material:{k:v for k,v in envelopes[material].items() if k.startswith(('maximum','minimum'))} for material in cfg['materials']},
'sparse_subset_envelope_extrema':{material:{k:v for k,v in sparse_envelopes[material].items() if k.startswith(('maximum','minimum'))} for material in cfg['materials']},
'candidate_family':'Fixed Craig-Bampton m128, Stormer-Verlet CFL0.25/0.125, n=64:8:128.',
'cost':'Setup-inclusive three-source receiver production. Each median uses three complete stage sums.'}
dump(HERE/'results'/'summary.json',summary)
print(json.dumps(summary,indent=2))
if __name__=='__main__':main()
|