Files
MeltMind/tools/verify_e6_cost.py

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()