110 lines
8.9 KiB
Python
110 lines
8.9 KiB
Python
"""One guarded full-node field per process; unchanged E6 arithmetic + O2-rep."""
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import resource
|
|
import time
|
|
import numpy as np
|
|
if __package__:
|
|
from . import run_e6_real_kernel as e6
|
|
from . import o2_rep as rep
|
|
else:
|
|
import run_e6_real_kernel as e6
|
|
import o2_rep as rep
|
|
|
|
|
|
def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest()
|
|
def save(p,x):Path(p).write_text(json.dumps(x,indent=2,allow_nan=False)+'\n')
|
|
|
|
|
|
def run(out,index,pose):
|
|
contract=json.loads((out/'execution_contract.json').read_text());spec=contract['cases'][index];case=spec['case']
|
|
dest=out/(case+'_'+pose);dest.mkdir(exist_ok=False);start=time.monotonic()
|
|
save(dest/'started.json',dict(contract_sha256=sha(out/'execution_contract.json'),pose=pose))
|
|
for path in spec['verified_inputs']:
|
|
if sha(path)!=contract['input_sha256'][path]:raise ValueError('Changed input '+path)
|
|
meta=json.loads(Path(spec['geometry_metadata']).read_text());L=meta['L_med_raw'];R=spec['radius']
|
|
with np.load(spec['sample']) as data:
|
|
x=data['points_raw'];tet=data['tetra'];mass=data['node_volume_raw'];edges=data['edges'];gate=data['gate_location_raw'];gate_normal=data['gate_normal']
|
|
d=np.load(spec['distance']);Q=np.asarray(contract['rotation']);shift=np.asarray(contract['translation'])
|
|
if pose=='rotated':x=x@Q.T+shift;gate=gate@Q.T+shift;gate_normal=gate_normal@Q.T
|
|
loaded=time.monotonic();raw,raw_meta=e6.raw_field(x,tet,d);raw_done=time.monotonic()
|
|
sx,sm,st=e6.samples(x,tet,mass,'tetra_four_point',raw);source_done=time.monotonic()
|
|
real_tree=e6.cKDTree;progress=dict(nodes_total=len(x),nodes_done=0,neighbor_visits=0,stage='kernel')
|
|
class GuardedTree:
|
|
def __init__(self,*args,**kwargs):self.tree=real_tree(*args,**kwargs)
|
|
def query_ball_point(self,*args,**kwargs):
|
|
ids=self.tree.query_ball_point(*args,**kwargs);progress['nodes_done']+=1;progress['neighbor_visits']+=len(ids)
|
|
if time.monotonic()-start>spec['wall_seconds']:raise TimeoutError('Per-field reservation exceeded')
|
|
if progress['nodes_done']%256==0:
|
|
save(dest/'progress.json',dict(progress,elapsed_seconds=time.monotonic()-start))
|
|
return ids
|
|
e6.cKDTree=GuardedTree
|
|
try:a=e6.integrate(x,sx,sm,st,R)
|
|
finally:e6.cKDTree=real_tree
|
|
kernel_done=time.monotonic();del sx,sm,st,raw
|
|
r=rep.readout(a['tensor'],a['kernel_mass'],d>0,a['effective_samples'])
|
|
checks=rep.acceptance(r);tol=contract['acceptance_tolerances'];limit=tol['algebra_abs']
|
|
assert checks['mu_sum_error']<=limit and checks['mu_min']>=-limit and checks['ordering_violation']<=limit
|
|
assert checks['B_symmetry_error']<=limit and checks['B_min_eigenvalue']>=-limit and checks['reconstruction_max']<=limit
|
|
assert not r['valid'][d==0].any() and np.isnan(r['tau0'][d==0]).all()
|
|
assert np.all(r['mu'][~r['valid']]==0) and np.all(r['B'][~r['valid']]==0)
|
|
readout_done=time.monotonic()
|
|
edge_q=np.empty((len(edges),2,2));edge_valid=np.empty((len(edges),2),bool);edge_length=np.empty(len(edges));edge_dir=np.empty(len(edges),bool);edge_reason=np.empty(len(edges),np.uint8)
|
|
max_identity=max_bound=0.
|
|
def qcheck(q,rr,v):
|
|
nonlocal max_identity,max_bound
|
|
ok=q['channel_valid']
|
|
if not ok.any():return
|
|
u=v[ok]/q['length'][ok,None];direct=np.einsum('ni,nij,nj->n',u,rr['normalized_corrected'][ok],u)-rr['mu'][ok,2]
|
|
max_identity=max(max_identity,float(abs(q['q'][ok].sum(1)-direct).max()))
|
|
max_bound=max(max_bound,float(np.maximum(-q['q'][ok],0).max()),float(np.maximum(q['q'][ok]-rr['g'][ok],0).max()))
|
|
for begin in range(0,len(edges),4096):
|
|
stop=min(begin+4096,len(edges));ij=edges[begin:stop];v=x[ij[:,1]]-x[ij[:,0]]
|
|
for side in [0,1]:
|
|
ids=ij[:,side];rr={k:r[k][ids] for k in ['B','mu','valid','normalized_corrected','g']}
|
|
q=rep.contract_direction(rr['B'],rr['mu'],rr['valid'],v,L,'edge');qcheck(q,rr,v)
|
|
edge_q[begin:stop,side]=q['q'];edge_valid[begin:stop,side]=q['channel_valid']
|
|
edge_length[begin:stop]=q['length'];edge_dir[begin:stop]=q['direction_valid'];edge_reason[begin:stop]=q['direction_reason']
|
|
v=gate-x;gq=rep.contract_direction(r['B'],r['mu'],r['valid'],v,L,'gate');qcheck(gq,r,v)
|
|
assert max_identity<=limit and max_bound<=limit
|
|
feature_done=time.monotonic()
|
|
np.savez(dest/'nodes.npz',**a,**r,gate_q=gq['q'],gate_length=gq['length'],gate_direction_valid=gq['direction_valid'],gate_channel_valid=gq['channel_valid'],gate_direction_reason=gq['direction_reason'])
|
|
np.savez(dest/'edges.npz',edge_node_ids=edges,q=edge_q,channel_valid=edge_valid,length=edge_length,direction_valid=edge_dir,direction_reason=edge_reason)
|
|
# All anchors are retained in a compact publishable tau0/status table.
|
|
np.savez_compressed(dest/'anchor_report.npz',node_id=np.arange(len(x)),tau0=r['tau0'],tau0_reason=r['tau0_reason'],status=r['status'],clipped=r['clipped'],neff_pass=r['neff_pass'],kernel_mass=a['kernel_mass'],neff=a['effective_samples'],mu=r['mu'],g=r['g'],node_mass=mass,gate_distance=gq['length'],gate_direction_valid=gq['direction_valid'])
|
|
rng=np.random.default_rng(20261114);old=np.load(spec['prior_fields']);old_ids=old['unique_node_ids']
|
|
audit_ids=np.unique(np.r_[old_ids,rng.choice(len(x),min(512,len(x)),replace=False),np.argmin(gq['length'])])
|
|
edge_ids=np.sort(rng.choice(len(edges),min(2048,len(edges)),replace=False))
|
|
np.savez_compressed(dest/'audit_samples.npz',node_ids=audit_ids,points_pose=x[audit_ids],gate_pose=gate,gate_normal_pose=gate_normal,
|
|
**{k:value[audit_ids] for k,value in a.items()},**{k:value[audit_ids] for k,value in r.items()},
|
|
gate_q=gq['q'][audit_ids],gate_distance=gq['length'][audit_ids],gate_direction_valid=gq['direction_valid'][audit_ids],gate_channel_valid=gq['channel_valid'][audit_ids],
|
|
edge_indices=edge_ids,edge_node_ids=edges[edge_ids],edge_vectors=x[edges[edge_ids,1]]-x[edges[edge_ids,0]],edge_q=edge_q[edge_ids],edge_channel_valid=edge_valid[edge_ids],edge_direction_valid=edge_dir[edge_ids],
|
|
edge_endpoint_B=r['B'][edges[edge_ids]],edge_endpoint_mu=r['mu'][edges[edge_ids]],edge_endpoint_valid=r['valid'][edges[edge_ids]])
|
|
overlap_error=0.
|
|
for key in a:
|
|
target=old[('original_' if pose=='original' else 'rotated_')+key]
|
|
overlap_error=max(overlap_error,float(abs(a[key][old_ids]-target).max()))
|
|
np.testing.assert_allclose(a[key][old_ids],target,rtol=1e-10,atol=1e-10)
|
|
counts={name:int((r['status']==code).sum()) for code,name in rep.STATUS.items()}
|
|
fractions={name:float(mass[r['status']==code].sum()/mass.sum()) for code,name in rep.STATUS.items()}
|
|
summary=dict(case=case,pose=pose,nodes=len(x),edges=len(edges),radius=R,L_med_raw=L,gate_identity=meta['gate_identity'],gate_pose=gate.tolist(),gate_normal_pose=gate_normal.tolist(),
|
|
input_process_metadata_source=spec['geometry_metadata'],status_counts=counts,status_mass_fractions=fractions,
|
|
tau0_defined_count=int(np.isfinite(r['tau0']).sum()),tau0_reason_counts={name:int((r['tau0_reason']==code).sum()) for code,name in rep.TAU_REASON.items()},
|
|
tau0_quantiles_defined=np.quantile(r['tau0'][np.isfinite(r['tau0'])],[0,.5,.99,1]).tolist(),clipped_count=int(r['clipped'].sum()),
|
|
neff_pass_count=int(r['neff_pass'].sum()),scored_neff_fail_count=int(((d>0)&~r['neff_pass']).sum()),
|
|
gate_undefined_direction_count=int((~gq['direction_valid']).sum()),gate_undefined_node_ids=np.flatnonzero(~gq['direction_valid']).tolist(),
|
|
edge_undefined_direction_count=int((~edge_dir).sum()),gate_valid_channel_count=int(gq['channel_valid'].sum()),edge_valid_endpoint_channel_count=int(edge_valid.sum()),
|
|
algebra_checks=checks,q_identity_max=max_identity,q_bound_violation_max=max_bound,prior_anchor_overlap_count=len(old_ids),prior_anchor_max_abs_difference=overlap_error,
|
|
neighbor_visits=progress['neighbor_visits'],visit_alarm_exceeded=progress['neighbor_visits']>500000000,
|
|
timings=dict(load=loaded-start,raw_field=raw_done-loaded,source_samples=source_done-raw_done,kernel=kernel_done-source_done,readout=readout_done-kernel_done,edge_gate_features=feature_done-readout_done,write_and_overlap=time.monotonic()-feature_done),
|
|
wall_seconds=time.monotonic()-start,peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,
|
|
acceptance_status='PASS',new_distance_queries=0,training=False,O1=False,
|
|
full_output_sha256={n:sha(dest/n) for n in ['nodes.npz','edges.npz','anchor_report.npz','audit_samples.npz']})
|
|
save(dest/'result.json',summary);save(dest/'progress.json',dict(progress,stage='complete',elapsed_seconds=time.monotonic()-start));print('COMPLETE',case,pose,summary['wall_seconds'],flush=True)
|
|
|
|
|
|
if __name__=='__main__':
|
|
p=argparse.ArgumentParser();p.add_argument('output',type=Path);p.add_argument('case_index',type=int);p.add_argument('pose',choices=['original','rotated']);a=p.parse_args();run(a.output,a.case_index,a.pose)
|