98 lines
5.9 KiB
Python
98 lines
5.9 KiB
Python
"""One immutable geometry-only exact-event measurement. Never reads labels."""
|
|
import argparse
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import time
|
|
import traceback
|
|
import numpy as np
|
|
from s2_recovery_supervisor import save
|
|
from s3b_runtime import contract, checked, read, sha, restrict_prediction_io
|
|
from s3b_graph import SOLVER, edge_geometry, distal_regions, fill_events
|
|
|
|
|
|
def run(root, index):
|
|
c = contract(root); spec = c['ten_parts'][index]
|
|
dest = root/'parts'/f'part-{index:02d}'/'output'; dest.mkdir(exist_ok=False)
|
|
save(dest/'started.json', dict(pid=os.getpid(), case=spec['case'], index=index, unix=time.time(),
|
|
solver=SOLVER, authorizing_ruling=c['authorizing_ruling'], labels_read=False))
|
|
allowed = list(spec['inputs'])
|
|
restrict_prediction_io(allowed, dest)
|
|
start = time.monotonic(); cpu = time.process_time(); latest = None
|
|
cost = {}; geometry = None
|
|
def progress(stage, **kw):
|
|
save(dest/'progress.json', dict(stage=stage, case=spec['case'], pid=os.getpid(), unix=time.time(),
|
|
worker_CPU_s=time.process_time()-cpu, wall_s=time.monotonic()-start, **kw))
|
|
try:
|
|
progress('VERIFY_GEOMETRY_ALLOWLIST')
|
|
for p, h in spec['inputs'].items(): checked(p, h)
|
|
source = Path(spec['preparation_root'])
|
|
metadata = read(source/'result.json')
|
|
if metadata['base_columns'][5] != 'geodesic_over_Rg':
|
|
raise ValueError('Not the original unrestricted geodesic column')
|
|
with np.load(source/'geometry.npz', allow_pickle=False) as z:
|
|
x=z['points_raw']; tetra=z['tetra']; faces=z['boundary_triangles']
|
|
edges=z['edges']; mass=z['node_volume_raw']; raw=z['raw_node_ids']; gate=z['gate_location_raw']
|
|
dw = np.load(source/'boundary_distance_raw.npy', allow_pickle=False)
|
|
base = np.load(source/'base.npy', allow_pickle=False)
|
|
distance = base[:, 5]*metadata['scales']['Rg']; del base
|
|
if np.any(np.diff(raw) <= 0): raise ValueError('Original IDs must be increasing')
|
|
seed = int(np.argmin(np.linalg.norm(x-gate, axis=1)))
|
|
if seed != metadata['base_gate_node']: raise ValueError('Gate source identity differs')
|
|
branch_start = time.process_time()
|
|
regions = distal_regions(distance, mass, edges, raw)
|
|
save(dest/'regions.json', dict(case=spec['case'], definition='strict-geodesic-distal-v0.3',
|
|
total_volume=float(mass.sum()), geometry_inputs=spec['inputs'], **regions))
|
|
cost['regions_CPU_s'] = time.process_time()-branch_start
|
|
def midpoint_progress(done, total):
|
|
progress('EXACT_MIDPOINTS', completed=done, total=total)
|
|
progress('GEOMETRY_EDGE_CAPACITY')
|
|
geometry = edge_geometry(x, tetra, faces, dw, edges, mass, midpoint_progress)
|
|
cost.update({k:geometry[k] for k in ['geometry_CPU_s','midpoint_CPU_s']})
|
|
np.savez_compressed(dest/'conductance.npz', edges=edges, edge_volume=geometry['edge_volume'],
|
|
midpoint_distance=geometry['midpoint'], g=geometry['conductance'],
|
|
exact_query_edge_ids=geometry['exact_query_edge_ids'], boundary_edges=geometry['boundary_edges'])
|
|
save(dest/'geometry-freeze.json', dict(case=spec['case'], nodes=len(x), total_volume=float(mass.sum()),
|
|
exact_midpoint_queries=len(geometry['exact_query_edge_ids']), seed=seed, raw_seed=int(raw[seed]),
|
|
boundary_edges=int(geometry['boundary_edges'].sum()), positive_edges=int((geometry['conductance']>0).sum()),
|
|
regions_sha256=sha(dest/'regions.json'), conductance_sha256=sha(dest/'conductance.npz'), costs=cost))
|
|
progress('EXACT_EVENTS', nodes=len(x), events=0, wetted_nodes=1)
|
|
last_progress = -1.
|
|
event_start = time.process_time()
|
|
with (dest/'events.jsonl').open('x', buffering=1) as stream:
|
|
def event(row):
|
|
stream.write(json.dumps(row, allow_nan=False)+'\n')
|
|
def state(row, remaining, arrival):
|
|
nonlocal latest, last_progress
|
|
latest = (row, remaining, arrival)
|
|
now = time.monotonic()
|
|
if row['events'] <= 2 or now-last_progress >= 1:
|
|
progress('EXACT_EVENTS', event_state=row)
|
|
last_progress = now
|
|
arrival, remaining, result = fill_events(edges, geometry['conductance'], mass, seed, event, state)
|
|
cost['events_CPU_s'] = time.process_time()-event_start
|
|
np.savez_compressed(dest/'event-field.npz', raw_ids=raw, arrival=arrival, remaining=remaining, mass=mass)
|
|
save(dest/'result.json', dict(case=spec['case'], index=index, nodes=len(x),
|
|
exact_midpoint_queries=len(geometry['exact_query_edge_ids']), **result, costs=cost,
|
|
labels_read=False, GPU=False, new_fits=0, event_batching=False, solver=SOLVER,
|
|
worker_CPU_s=time.process_time()-cpu, wall_s=time.monotonic()-start,
|
|
output_sha256={p.name:sha(p) for p in dest.iterdir() if p.is_file() and p.name!='progress.json'}))
|
|
progress(result['status'], event_state=result)
|
|
return 0
|
|
except Exception as exc:
|
|
if latest is not None:
|
|
state, remaining, arrival = latest
|
|
np.savez_compressed(dest/'last-trusted-state.npz', remaining=remaining, arrival=arrival)
|
|
else: state = None
|
|
save(dest/'failure.json', dict(status='NUMERICAL_OR_INPUT_FAILURE', case=spec['case'],
|
|
type=type(exc).__name__, message=str(exc), traceback=traceback.format_exc(),
|
|
last_trusted_state=state, remaining_volume=state['remaining_volume'] if state else None,
|
|
remaining_state='KNOWN_LAST_STATE' if state else 'UNKNOWN', costs=cost,
|
|
worker_CPU_s=time.process_time()-cpu, wall_s=time.monotonic()-start, retry=False))
|
|
raise
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser=argparse.ArgumentParser();parser.add_argument('root', type=Path);parser.add_argument('index', type=int)
|
|
args=parser.parse_args();raise SystemExit(run(args.root,args.index))
|