"""Frozen E6/O2 routines on a fixed subset of anchors; no S1 scoring.""" import argparse import hashlib import json from pathlib import Path import resource import time import numpy as np import run_e6_real_kernel as e6 import o2_rep as rep def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest() def read(p):return json.loads(Path(p).read_text()) def save(p,v):Path(p).write_text(json.dumps(v,indent=2,allow_nan=False)+'\n') def bit_comparison(name, actual, expected): a=np.asarray(actual);b=np.asarray(expected) same=a.shape==b.shape and a.dtype==b.dtype and a.tobytes()==b.tobytes() row=dict(array=name,shape=list(a.shape),dtype=str(a.dtype),bitwise_equal=same) if not same and a.shape==b.shape and a.dtype==b.dtype: av=np.ascontiguousarray(a).reshape(-1).view(np.dtype((np.void,a.dtype.itemsize))) bv=np.ascontiguousarray(b).reshape(-1).view(np.dtype((np.void,b.dtype.itemsize))) bad=np.flatnonzero(av!=bv);row['different_elements']=len(bad) row['first_flat_indices']=bad[:20].tolist() if np.issubdtype(a.dtype,np.number): finite=np.isfinite(a)&np.isfinite(b) row['max_abs_finite_difference']=float(np.max(np.abs(a[finite]-b[finite]),initial=0)) return row def run(out,phase,index): c=read(out/'execution_contract.json');s=c[phase][index];case=s['case'];pose=s['pose'] dest=out/phase/s['job'];dest.mkdir(exist_ok=False);start=time.monotonic() save(dest/'started.json',dict(contract_sha256=sha(out/'execution_contract.json'),case=case,pose=pose,phase=phase)) for p,h in c['code_sha256'].items():assert sha(p)==h,p for p,h in s['input_sha256'].items():assert sha(p)==h,p if phase=='panel': gate=read(out/'equivalence_gate.json');assert gate['status']=='PASS' for job,h in gate['result_sha256'].items():assert sha(out/'equivalence'/job/'result.json')==h with np.load(s['geometry'],allow_pickle=False) as z: x=z['points_raw'];tet=z['tetra'];mass=z['node_volume_raw'];edges=z['edges'];gate=z['gate_location_raw'] raw_ids=z['raw_node_ids'] if 'raw_node_ids' in z else np.arange(len(x)) d=np.load(s['distance'],allow_pickle=False) with np.load(s['anchor_file'],allow_pickle=False) as z: ids=z['unique_ids'];multiplicity=z['multiplicity'] assert np.all(np.diff(ids)>0) and len(multiplicity)==len(ids) # Original full-part scales, before eligibility; carry L_med to rotated pose. lengths=np.linalg.norm(x[edges[:,1]]-x[edges[:,0]],axis=1) positive=lengths[np.isfinite(lengths)&(lengths>0)] L=float(np.median(positive)) if len(positive) else None if 'L_med_raw' in s:assert L==s['L_med_raw'] center=np.sum(mass[:,None]*x,axis=0)/mass.sum() Rg=float(np.sqrt(np.sum(mass*np.sum((x-center)**2,axis=1))/mass.sum())) if not np.isfinite(Rg) or Rg<=0:raise ValueError('Invalid full-part R_g') if pose=='rotated': Q=np.asarray(c['rotation']);shift=np.asarray(c['translation']);x=x@Q.T+shift;gate=gate@Q.T+shift load_done=time.monotonic() progress=dict(stage='raw_field',anchors_done=0,anchors_total=len(ids),neighbor_visits=0) save(dest/'progress.json',progress) 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);sources_done=time.monotonic() source_count=len(sx);real_tree=e6.cKDTree;progress['stage']='kernel' class ProgressTree: def __init__(self,*args,**kwargs):self.tree=real_tree(*args,**kwargs) def query_ball_point(self,*args,**kwargs): result=self.tree.query_ball_point(*args,**kwargs) progress['anchors_done']+=1;progress['neighbor_visits']+=len(result) if progress['anchors_done']%32==0: save(dest/'progress.json',dict(progress,elapsed_seconds=time.monotonic()-start)) return result e6.cKDTree=ProgressTree try:a=e6.integrate(x[ids],sx,sm,st,s['radius']) finally:e6.cKDTree=real_tree del sx,sm,st,raw kernel_done=time.monotonic() if phase=='panel':assert progress['neighbor_visits']==s['exact_unique_visits'] r=rep.readout(a['tensor'],a['kernel_mass'],d[ids]>0,a['effective_samples']) checks=rep.acceptance(r);limit=c['frozen_algebra_tolerance'] if checks['valid_count']: 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 gq=rep.contract_direction(r['B'],r['mu'],r['valid'],gate-x[ids],L,'gate') readout_done=time.monotonic() lookup=np.full(len(x),-1,np.int64);lookup[ids]=np.arange(len(ids)) edge_idx,side=np.nonzero(lookup[edges]>=0);anchor_local=lookup[edges[edge_idx,side]] m=len(edge_idx);q=np.empty((m,2));channel_valid=np.empty(m,bool);direction_valid=np.empty(m,bool) edge_length=np.empty(m);edge_reason=np.empty(m,np.uint8) for begin in range(0,m,4096): stop=min(begin+4096,m);e=edges[edge_idx[begin:stop]];j=anchor_local[begin:stop] vectors=x[e[:,1]]-x[e[:,0]] eq=rep.contract_direction(r['B'][j],r['mu'][j],r['valid'][j],vectors,L,'edge') q[begin:stop]=eq['q'];channel_valid[begin:stop]=eq['channel_valid'] direction_valid[begin:stop]=eq['direction_valid'];edge_length[begin:stop]=eq['length'];edge_reason[begin:stop]=eq['direction_reason'] # Summarize all finite valid true edge ends, retaining every invalid endpoint record. finite_q=np.isfinite(q).all(1);accepted=channel_valid&finite_q degree=np.bincount(anchor_local,minlength=len(ids));valid_degree=np.bincount(anchor_local[accepted],minlength=len(ids)) total=np.zeros((len(ids),2));maximum=np.full((len(ids),2),-np.inf) np.add.at(total,anchor_local[accepted],q[accepted]);np.maximum.at(maximum,anchor_local[accepted],q[accepted]) mean=np.full_like(total,np.nan);has=valid_degree>0;mean[has]=total[has]/valid_degree[has,None];maximum[~has]=np.nan summaries=np.column_stack([mean[:,0],maximum[:,0],mean[:,1],maximum[:,1]]) full_degree=np.bincount(edges.ravel(),minlength=len(x))[ids] complete=(degree==full_degree)&has&np.isfinite(summaries).all(1) feature_finite=np.isfinite(r['g']).all(1)&np.isfinite(gq['q']).all(1)&np.isfinite(gq['length'])&np.isfinite(d[ids]) eligible=(d[ids]>0)&r['valid']&r['neff_pass']&gq['direction_valid']&gq['channel_valid']&complete&feature_finite near=(d[ids]>0)&(d[ids]/s['t_part']<=.25) node_outputs=dict(**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']) edge_outputs=dict(edge_indices=edge_idx,endpoint_side=side,anchor_local=anchor_local, anchor_ids=ids[anchor_local],edge_node_ids=edges[edge_idx],q=q,channel_valid=channel_valid, length=edge_length,direction_valid=direction_valid,direction_reason=edge_reason) feature_done=time.monotonic() np.savez_compressed(dest/'nodes.npz',anchor_ids=ids,raw_node_ids=raw_ids[ids],multiplicity=multiplicity, distance=d[ids],node_mass=mass[ids],**node_outputs,edge_summary=summaries,edge_count=degree, valid_edge_count=valid_degree,edge_block_complete=complete,eligible=eligible,near_wall=near) np.savez_compressed(dest/'edges.npz',**edge_outputs) mismatch=[];comparisons=[] if phase=='equivalence': baseline=Path(s['baseline']);br=read(baseline/'result.json') for name,h in br['full_output_sha256'].items():assert sha(baseline/name)==h,(baseline,name) with np.load(baseline/'nodes.npz',allow_pickle=False) as z: for key,value in node_outputs.items():comparisons.append(bit_comparison('node.'+key,value,z[key][ids])) with np.load(baseline/'edges.npz',allow_pickle=False) as z: for key in ['q','channel_valid']: comparisons.append(bit_comparison('edge.'+key,edge_outputs[key],z[key][edge_idx,side])) for key in ['length','direction_valid','direction_reason','edge_node_ids']: comparisons.append(bit_comparison('edge.'+key,edge_outputs[key],z[key][edge_idx])) mismatch=[row for row in comparisons if not row['bitwise_equal']] save(dest/'equivalence.json',dict(status='FAIL' if mismatch else 'PASS',comparison='dtype/shape/C-order bytes exactly; includes NaN bit patterns',arrays=comparisons,mismatches=mismatch,baseline_result_sha256=sha(baseline/'result.json'))) summary=dict(case=case,pose=pose,phase=phase,status='EQUIVALENCE_MISMATCH' if mismatch else 'COMPLETE', anchors=len(ids),draw_slots=int(multiplicity.sum()),full_nodes=len(x),full_tets=len(tet),full_sources=source_count, radius=s['radius'],t_part=s['t_part'],R_g_raw=Rg,L_med_raw=L,raw_field=raw_meta, status_counts={name:int((r['status']==code).sum()) for code,name in rep.STATUS.items()}, status_draw_counts={name:int(multiplicity[r['status']==code].sum()) for code,name in rep.STATUS.items()}, tau0_reason_counts={name:int((r['tau0_reason']==code).sum()) for code,name in rep.TAU_REASON.items()}, gate_direction_reason_counts={name:int((gq['direction_reason']==code).sum()) for code,name in rep.DIRECTION_REASON.items()}, edge_direction_reason_counts={name:int((edge_reason==code).sum()) for code,name in rep.DIRECTION_REASON.items()}, clipped_count=int(r['clipped'].sum()),neff_pass_count=int(r['neff_pass'].sum()), gate_channel_valid_count=int(gq['channel_valid'].sum()),edge_endpoint_count=m, edge_channel_valid_count=int(channel_valid.sum()),edge_nonfinite_q_count=int((~finite_q).sum()), edge_block_complete_count=int(complete.sum()),n_ref=int(eligible.sum()),eligible_draw_count=int(multiplicity[eligible].sum()), eligible_near_wall_draw_count=int(multiplicity[eligible&near].sum()), neighbor_visits=progress['neighbor_visits'],visit_alarm_exceeded=progress['neighbor_visits']>500000000, algebra_checks=checks,equivalence_arrays_compared=len(comparisons),equivalence_mismatches=mismatch, timings=dict(load_and_scales=load_done-start,raw_field=raw_done-load_done,sources=sources_done-raw_done, kernel=kernel_done-sources_done,readout=readout_done-kernel_done,edge_features=feature_done-readout_done, write_and_equivalence=time.monotonic()-feature_done), wall_seconds=time.monotonic()-start,peak_rss_bytes=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss*1024, draw_file_sha256=sha(s['anchor_file']),new_distance_queries=0,S1_scoring=False,training=False, output_sha256={n:sha(dest/n) for n in ['nodes.npz','edges.npz']}) save(dest/'result.json',summary);save(dest/'progress.json',dict(progress,stage='complete' if not mismatch else 'mismatch',elapsed_seconds=time.monotonic()-start)) print(json.dumps(summary,indent=2),flush=True) if mismatch:raise SystemExit(2) if __name__=='__main__': p=argparse.ArgumentParser();p.add_argument('output',type=Path);p.add_argument('phase',choices=['equivalence','panel']);p.add_argument('index',type=int);a=p.parse_args();run(a.output,a.phase,a.index)