Files
MeltMind/references/2026-11-14/s2-design/sampled-driver-5e4b406.py
T

158 lines
11 KiB
Python

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