55 lines
3.9 KiB
Python
55 lines
3.9 KiB
Python
"""Recompute cost arithmetic from saved counts/timings, without kernels."""
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import numpy as np
|
|
|
|
|
|
def read(p):return json.loads(Path(p).read_text())
|
|
def close(a,b):np.testing.assert_allclose(a,b,rtol=1e-11,atol=1e-12)
|
|
|
|
|
|
def main():
|
|
p=argparse.ArgumentParser();p.add_argument('output',type=Path);p.add_argument('--check-local-inputs',action='store_true');a=p.parse_args();out=a.output
|
|
c=read(out/'execution_contract.json');cal=read(out/'calibration_contract.json');plan=read(out/'calibration_plan.json')
|
|
assert plan['contract_sha256']==hashlib.sha256((out/'calibration_contract.json').read_bytes()).hexdigest()
|
|
checked=0
|
|
if a.check_local_inputs:
|
|
for path,h in (c['input_sha256']|cal['input_sha256']).items():
|
|
assert hashlib.sha256(Path(path).read_bytes()).hexdigest()==h,path
|
|
checked+=1
|
|
rows=[];total=0;overlap=0
|
|
for spec in c['cases']:
|
|
case=spec['case'];r=read(out/(case+'.json'));t=read(out/(case+'.calibration.json'));saved=np.load(out/(case+'_counts.npz'))
|
|
counts=saved['neighbor_counts'];positive=saved['positive_distance_mask'];mass=saved['node_lumped_mass']
|
|
old=np.load(Path(c['prior_directory'])/(case+'_tetra_four_point_anchors.npz'))
|
|
np.testing.assert_array_equal(counts[old['unique_node_ids']],old['neighbor_counts'])
|
|
for name,mask in [('all_nodes',np.ones(len(counts),bool)),('positive_distance_nodes',positive),('boundary_nodes',~positive)]:
|
|
g=r['groups'][name];assert int(mask.sum())==g['nodes'] and int(counts[mask].sum())==g['neighbor_sum']
|
|
close(np.quantile(counts[mask],[0,.5,.9,.99,1]),list(g['quantiles'].values()))
|
|
close(mass[mask].sum()/mass.sum(),g['lumped_mass_fraction'])
|
|
cp=next(x for x in plan['cases'] if x['case']==case);assert t['query_count']==len(cp['queries'])<=64
|
|
ids=np.array([q['node'] for q in t['queries']]);assert len(np.unique(ids))==len(ids)
|
|
assert list(ids)==[q['node'] for q in cp['queries']]
|
|
np.testing.assert_array_equal(counts[ids],[q['neighbors'] for q in t['queries']])
|
|
assert max(counts[ids])==max(counts)
|
|
total+=int(counts[ids].sum());assert int(counts[ids].sum())==t['neighbor_visits']==cp['neighbor_visits']
|
|
close(sum(q['seconds'] for q in t['queries']),t['measured_query_loop_seconds'])
|
|
close(t['amortized_seconds_per_neighbor'],t['measured_query_loop_seconds']/t['neighbor_visits'])
|
|
fixed=sum(t['fixed_setup'].values())
|
|
for name,groups in [('all_nodes',['boundary','interior']),('positive_distance_nodes',['interior']),('boundary_nodes',['boundary'])]:
|
|
strata=[s for s in t['strata'] if s['group'] in groups];assert sum(s['nodes'] for s in strata)==r['groups'][name]['nodes']
|
|
assert sum(s['neighbor_visits'] for s in strata)==r['groups'][name]['neighbor_sum']
|
|
close(sum(s['nodes']*np.mean(s['sample_query_seconds']) for s in strata),t['estimates'][name]['integration_seconds'])
|
|
close(t['estimates'][name]['total_seconds_with_fixed_setup'],fixed+t['estimates'][name]['integration_seconds'])
|
|
assert t['old_field_overlap_checked']>0;overlap+=t['old_field_overlap_checked']
|
|
rows.append(dict(case=case,all_node_count=r['nodes'],old_anchor_count_checked=len(old['unique_node_ids']),calibration_queries=len(ids),calibration_visits=t['neighbor_visits']))
|
|
assert total==plan['total_neighbor_visits']<=cal['total_visit_cap']
|
|
result=dict(status='PASS',checked_local_input_hashes=checked,parts=rows,total_calibration_visits=total,
|
|
prior_field_overlap_checks_recorded=overlap,scope='Recomputed stored count, strata, timing and budget arithmetic; profile runner separately checked overlap outputs against frozen E6. No kernel rerun or O2-rep implementation.')
|
|
(out/'verification.json').write_text(json.dumps(result,indent=2)+'\n');print(json.dumps(result,indent=2))
|
|
|
|
|
|
if __name__=='__main__':main()
|