Files
MeltMind/tools/run_naive_ordering_part.py
T

109 lines
6.8 KiB
Python

"""One authorized full-node custody decode and D_w^2 graph approximation."""
import argparse
import json
import os
from pathlib import Path
import time
import traceback
from zipfile import ZipFile
from xml.etree import ElementTree as ET
import numpy as np
from audit_samples import decode_array
from freeze_g1_components import sha
from s2_custody_common import checked, read_json
from s2_recovery_supervisor import save
from naive_ordering_common import contract, rows
from naive_ordering_math import cdf_interval, squared_wall_distance, volume_clock_curve
def decode_full(archive, case):
stack=[];count=None;header=None
with ZipFile(archive) as z,z.open(case+'_sim.vtu') as stream:
for event,e in ET.iterparse(stream,events=('start','end')):
if event=='start':
stack.append(e.tag)
if e.tag=='VTKFile':
if e.get('byte_order')!='LittleEndian' or e.get('compressor')!='vtkZLibDataCompressor':
raise ValueError('Unsupported source encoding')
header=e.get('header_type','UInt32')
elif e.tag=='Piece':
if count is not None:raise ValueError('Multiple pieces')
count=int(e.get('NumberOfPoints'))
else:
if e.tag=='DataArray':
if stack[-2]=='PointData' and e.get('Name')=='Fill_time':
values=decode_array(e,header)
if values.shape!=(count,):raise ValueError('Full-node label length')
return values.copy()
e.clear()
stack.pop()
raise ValueError('No Fill_time array')
def run(root, index):
c=contract(root);row=rows(c)[index];prep=row['preparation'];source=Path(prep['preparation_root'])
dest=root/'parts'/f'part-{index:03d}'/'output'
dest.mkdir(exist_ok=False)
start=time.monotonic();cpu=time.process_time()
save(dest/'started.json',dict(pid=os.getpid(),case=row['case'],index=index,unix=time.time(),
contract_sha256=sha(root/'contract.json'),custody_authorization=c['latest_ruling']))
try:
for name in ['geometry.npz','r2.npz','queries.npz']:checked(source/name,prep['output_sha256'][name])
metadata=read_json(checked(source/'result.json',prep['result_sha256']))
if metadata['r2']['columns'][8]!='Dw':raise ValueError('Expected original wall-distance column')
with np.load(source/'geometry.npz',allow_pickle=False) as z:
x=z['points_raw'];edges=z['edges'];mass=z['node_volume_raw'];raw=z['raw_node_ids'];gate=z['gate_location_raw']
with np.load(source/'r2.npz',allow_pickle=False) as z:
dw=z['features'][:,8];df1=z['Df'];vf=z['Vf']
with np.load(source/'queries.npz',allow_pickle=False) as z:
mask=z['eligible_s2'];ids=z['anchor_ids'][mask];query_raw=z['raw_node_ids'][mask];counts=z['multiplicity'][mask]
if not np.array_equal(raw[ids],query_raw):raise ValueError('Query/raw-ID mismatch')
st=Path(c['archive']).stat();a=c['archive_stat']
if (st.st_size,st.st_mtime_ns,st.st_ino)!=(a['bytes'],a['mtime_ns'],a['inode']):raise ValueError('Archive identity changed')
# Exactly once per immutable attempt; save raw bytes even if validation later fails.
full=decode_full(c['archive'],row['case'])
np.savez_compressed(dest/'full-node-labels.npz',seconds=full,retained_tet_raw_ids=raw)
save(dest/'decode-receipt.json',dict(case=row['case'],decoded_arrays=['Fill_time'],decode_count=1,
full_VTU_nodes=len(full),retained_tet_nodes=len(raw),label_sha256=sha(dest/'full-node-labels.npz'),
original_S2_query_decode_preserved=True,custody_authorization=c['latest_ruling']))
if not np.isfinite(full).all() or np.any(full<0) or full.max()<=0:raise ValueError('Invalid full-node Fill_time; preserve raw cache, no retry')
if raw.ndim!=1 or np.any(np.diff(raw)<=0) or raw[0]<0 or raw[-1]>=len(full):raise ValueError('Full-node/tet indexing')
old={v['case']:v for v in read_json(checked(c['label_index'],c['label_index_sha256']))}[row['case']]
with np.load(checked(old['path'],old['sha256']),allow_pickle=False) as z:
if not np.array_equal(z['raw_ids'],query_raw) or not np.array_equal(z['counts'],counts) or not np.array_equal(z['seconds'],full[query_raw]):
raise ValueError('Full decode differs from immutable S2 query cache')
left1,right1=cdf_interval(df1,mass)
difference=float(np.max(np.abs(left1-vf)))
if difference>1e-12:raise ValueError('Existing B0 is not the expected full-volume strict D_w Dijkstra CDF')
save(dest/'progress.json',dict(stage='Dw_squared_graph',cpu_seconds=time.process_time()-cpu))
df2,gate_node,zero_edges=squared_wall_distance(x,edges,dw,gate)
left2,right2=cdf_interval(df2,mass)
leftT,rightT=cdf_interval(full[raw],mass)
np.savez_compressed(dest/'full-domain-maps.npz',raw_ids=raw,truth_left=leftT,truth_right=rightT,
df1_left=left1,df1_right=right1,df2_left=left2,df2_right=right2)
end=float(full.max());tet_end=float(full[raw].max());query_end=float(full[query_raw].max())
positive=float(mass[dw>0].sum()/mass.sum());K=int(counts.sum());alpha=positive*K/metadata['draw_slots']
curve=volume_clock_curve(full[raw],mass,end,prep['t_set'])
save(dest/'volume-clock-curve.json',curve)
save(dest/'result.json',dict(status='COMPLETE',case=row['case'],index=index,component_id=row['component_id'],
t_set=prep['t_set'],full_VTU_T_end=end,full_tet_T_end=tet_end,query_T_max=query_end,
raw_nodes=len(full),tet_nodes=len(raw),zero_mass_excluded_VTU_nodes=len(full)-len(raw),
full_vs_tet_end_difference=end-tet_end,eligible_slots=K,draw_slots=metadata['draw_slots'],
positive_mass_fraction=positive,estimated_alpha=alpha,alpha_is_estimate=True,
DKW_halfwidth_if_fixed_score_independent_PPS=float(np.sqrt(np.log(40)/(2*K))),
baseline_Dw_Vf_max_abs_difference=difference,Dw_solve_reused=True,Dw2_solver='tet-edge Dijkstra approximation',
zero_midpoint_edges_excluded=zero_edges,gate_node=gate_node,
cpu_seconds=time.process_time()-cpu,wall_seconds=time.monotonic()-start,
output_sha256={p.name:sha(p) for p in dest.glob('*') if p.is_file() and p.name not in ['progress.json']},
no_training=True,no_GPU=True,decode_count=1))
return 0
except Exception as exc:
save(dest/'failure.json',dict(type=type(exc).__name__,message=str(exc),traceback=traceback.format_exc(),
cpu_seconds=time.process_time()-cpu,wall_seconds=time.monotonic()-start,retry=False))
raise
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('root',type=Path);p.add_argument('index',type=int);a=p.parse_args()
raise SystemExit(run(a.root,a.index))