"""B15 single fixed fit after B14 terminal; independent7200CPU-second ledger.""" import argparse,fcntl,json,os,resource,sys,time,traceback from pathlib import Path import numpy as np import xgboost as xgb import joblib from phase2_b1213_gate import config,read,score as base_score from phase2_b1213_features import input_geometry,cached,flow_mesh,source_geometry,InputViolation from phase2_b15_math import sample,geometry_mask,supervision,positive_speed from phase2_fixed_io import BASE,freeze,verify from phase2_h1_worker_v2 import checked,sha,save from gre24_features_v2 import COLUMNS,solve_eikonal,strict_volume_cdf from gre24_models import xgb_model from s2_custody_common import prediction_inputs from r4bc_guard import supervise from s2_recovery_monitoring import disk_usage def prep(root,c,index): row=c['parts'][index];dest=root/'parts'/f'{index:04d}';start=time.process_time() x,t0,raw,old=input_geometry(row);mesh,decoded=source_geometry(c['archive'],row['case']);t=mesh['tets'];cells=mesh['raw_cells'] if not np.array_equal(mesh['raw_nodes'],raw) or not np.array_equal(mesh['points'],x):raise InputViolation('Original geometry/node identity') key=lambda a:np.lexsort(tuple(a[:,i] for i in [3,2,1,0])) a=np.sort(t0,axis=1);b=np.sort(t,axis=1) if not np.array_equal(a[key(a)],b[key(b)]):raise InputViolation('Original tetra membership') g=flow_mesh(x,t);center=np.sum(x*g['mass'][:,None],axis=0)/g['mass'].sum();rg=float(np.sqrt(np.sum(g['mass']*np.sum((x-center)**2,axis=1))/g['mass'].sum())) E,valid,condition=geometry_mask(x,t,rg);features=cached(row,'features');X=features[:,4:19][t].mean(1).astype(np.float32) if X.shape!=(len(t),15) or not np.isfinite(X).all():raise ValueError('Geometry feature shape/precision') sources=np.searchsorted(raw,old['features']['gate_raw_ids']) if np.any(sources>=len(raw)) or not np.array_equal(raw[sources],old['features']['gate_raw_ids']):raise ValueError('Original gate identity') selected=sample(row['case'],cells);pi=min(1.,4096/len(t));p=dest/'geometry.npz' np.savez_compressed(p,points=x,tets=t,raw_cells=cells,raw_ids=raw,volume=g['volume'],mass=g['mass'],E=E,X=X,geometry_valid=valid,condition=condition,sources=sources,selected=selected,center=center,Rg=rg) save(dest/'result.json',dict(status='GEOMETRY_COMPLETE',case=row['case'],index=index,tetrahedra=len(t),sampled=len(selected),sampling_pi=pi,geometry_valid=int(valid.sum()),geometry_invalid_volume=float(g['volume'][~valid].sum()),geometry_sha256=sha(p),sampled_raw_tet_ids=cells[selected].tolist(),columns=list(COLUMNS[4:]),sample_fixed_before_labels=True,labels_read=False,decoded_geometry_arrays=decoded,cpu_seconds=time.process_time()-start)) def entries(root):return {e['case']:e for e in read(root/'features-manifest.json')['entries']} def load(root,e): d=root/'parts'/f"{e['index']:04d}";r=read(checked(d/'result.json',e['result_sha256']));z=np.load(checked(d/'geometry.npz',r['geometry_sha256']),allow_pickle=False);return z,r def train(root,c): verify(root,'features');dest=root/'phases/train';by=entries(root);Xs=[];Ys=[];Ws=[];reports=[] for row in c['rows']['learning']: with load(root,by[row['case']])[0] as z: ix=z['selected'];tet=z['tets'][ix];E=z['E'][ix];validgeom=z['geometry_valid'][ix];volume=z['volume'][ix] save(dest/'target-access.json',dict(case=row['case'],role='learning',sample_fixed_sha256=by[row['case']]['result_sha256'],target_sha256=row['v5_cache']['output_sha256']['target.npy'])) u=cached(row,'target');y,valid,reasons,gradient=supervision(E,tet,u,z['sources'],validgeom) pi=min(1.,4096/len(z['tets']));w=volume/pi np.savez_compressed(dest/(row['case']+'-supervision.npz'),sampled_raw_cells=z['raw_cells'][ix],geometry_mask=validgeom,supervision_mask=valid,y=y,gradient=gradient,volume=volume,weights_before_normalization=w,**reasons) reports.append(dict(case=row['case'],sampled=len(ix),valid=int(valid.sum()),sampled_volume=float(volume.sum()),valid_sampled_volume=float(volume[valid].sum()),pi=pi,reasons={k:dict(count=int(v.sum()),sampled_volume=float(volume[v].sum())) for k,v in reasons.items()},record_resolution_delta=0,precision_interpretation='numerical ties only; no recording resolution metadata')) Xs.append(z['X'][ix][valid]);Ys.append(y[valid]);Ws.append(w[valid]) save(dest/'progress.json',dict(stage='LEARNING_SUPERVISION',parts=len(reports),valid_samples=sum(r['valid'] for r in reports))) X=np.concatenate(Xs);Y=np.concatenate(Ys);W=np.concatenate(Ws);W/=W.mean();model=xgb_model(0,1);model.fit(X,Y,sample_weight=W);model.save_model(dest/'model.ubj') save(dest/'xgboost-config.json',json.loads(model.get_booster().save_config()));save(dest/'result.json',dict(status='FIT_COMPLETE',checkpoint_sha256=sha(dest/'model.ubj'),parts=len(reports),samples=len(Y),columns=list(COLUMNS[4:]),sample_reports=reports,target='negative log P1 normalized gradient norm',validation_labels_read=False)) def predict(root,c): verify(root,'model');dest=root/'phases/predict';by=entries(root);model=xgb.XGBRegressor();model.load_model(root/'phases/train/model.ubj');baseline=joblib.load(checked(c['baseline']['model_path'],c['baseline']['model_sha256']));manifest=[] for row in c['rows']['validation']: begin=time.process_time() with load(root,by[row['case']])[0] as z: if not np.all(z['geometry_valid']):raise ValueError('Validation contains invalid geometry; no tet deletion') a=positive_speed(model.predict(z['X']));g=flow_mesh((z['points']-z['center'])/float(z['Rg']),z['tets']) begin_solver=time.process_time();phi=solve_eikonal(g,z['sources'],a);solver_cpu=time.process_time()-begin_solver;U=strict_volume_cdf(phi,z['mass']);pred_all=c['clock_c']*U np.savez_compressed(dest/(row['case']+'-field.npz'),raw_ids=z['raw_ids'],raw_cells=z['raw_cells'],speed=a,phi=phi,U=U,pred_normalized=pred_all) q=prediction_inputs(row);ix=np.searchsorted(z['raw_ids'],q['raw_ids']) if np.any(ix>=len(z['raw_ids'])) or not np.array_equal(z['raw_ids'][ix],q['raw_ids']):raise ValueError('Query identity') f=cached(row,'features');A=np.asarray(baseline.predict(f[ix].astype(np.float32)),np.float64);p=dest/(row['case']+'.npz') np.savez_compressed(p,pred=pred_all[ix],A=A,raw_ids=q['raw_ids'],counts=q['counts'],coordinates_over_Rg=q['coordinates_over_Rg']) manifest.append(dict(case=row['case'],component_id=row['component_id'],path=str(p),sha256=sha(p),full_field_sha256=sha(dest/(row['case']+'-field.npz')),geometry_valid=True,solver_cpu_seconds=solver_cpu,cpu_seconds=time.process_time()-begin,clock_learning_only=c['clock_c'])) save(dest/'progress.json',dict(parts=len(manifest),last=manifest[-1],validation_targets_read=False)) save(dest/'manifest.json',dict(entries=manifest,validation_labels_read=False,all_validation_complete=True)) def score(root,c): base_score(root,c) from s2_custody_statistics import kendall_pairs from r4bc_common import paired_difference by={r['case']:r for r in c['rows']['validation']};rows=[];groups={} for e in read(root/'phases/predict/manifest.json')['entries']: row=by[e['case']];raw=cached(row,'raw_ids');target=cached(row,'target') with np.load(checked(e['path'],e['sha256']),allow_pickle=False) as z: ix=np.searchsorted(raw,z['raw_ids']);record=dict(case=row['case'],component=row['component_id']) for arm,key in [('new','pred'),('A','A')]:record[arm]=kendall_pairs(target[ix],z[key],int(row['case'].split('_')[0])) rows.append(record);groups.setdefault(row['component_id'],[]).append(record) values={arm:{g:float(np.mean([r[arm]['value'] for r in rs])) for g,rs in groups.items() if all(r[arm]['value'] is not None for r in rs)} for arm in ['new','A']} save(root/'phases/score/kendall-diagnostic.json',dict(rows=rows,new_minus_A=paired_difference(values['new'],values['A']),descriptive_only=True,gate_unchanged=True)) def run(root): c=config(root);os.sched_setaffinity(0,[28]);lock=(root/'run.lock').open('a');fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB) if (root/'started.json').exists():raise FileExistsError('Single B15 launch') b14=BASE/'artifacts/phase2-b14-gate-2026-11-17/complete.json' if not b14.exists():raise RuntimeError('B14 not terminal') start=time.process_time();u0=resource.getrusage(resource.RUSAGE_CHILDREN);charged=0.;records=[];out=[] def total(): u=resource.getrusage(resource.RUSAGE_CHILDREN);return 60+max(charged,u.ru_utime+u.ru_stime-u0.ru_utime-u0.ru_stime)+time.process_time()-start def call(mode,dest,cap,wall,index=None): nonlocal charged cap=min(cap,7200-total()-120);disk=c['disk_bytes']-disk_usage(root) if cap<=0 or disk<=0:raise RuntimeError('RESOURCE_RESERVE_EXHAUSTED') cmd=[sys.executable,'tools/phase2_b15_gate.py',mode,str(root)]+([] if index is None else [str(index)]) g=supervise(cmd,dest,dict(cpu_seconds=cap,wall_seconds=wall,rss_bytes=c['rss_bytes'],disk_bytes=disk));charged+=g['cpu_seconds'];records.append(dict(mode=mode,index=index,guard=g));save(root/'phase-ledger.json',dict(records=records,cumulative_cpu_seconds=total())) if g['status']!='PASS' or total()>7200 or disk_usage(root)>c['disk_bytes']:raise RuntimeError('ENGINEERING_OR_RESOURCE_STOP') save(root/'started.json',dict(pid=os.getpid(),unix=time.time(),contract_sha256=sha(root/'contract.json'),B14_terminal_sha256=sha(b14))) try: for index,row in enumerate(c['parts']): if total()>c['geometry_cpu_cap']-60:raise RuntimeError('PARK_GEOMETRY_RESOURCE') dest=root/'parts'/f'{index:04d}';dest.mkdir(parents=True,exist_ok=False);call('prep',dest,30,60,index);out.append(dict(case=row['case'],index=index,result_sha256=sha(dest/'result.json'))) save(root/'live-progress.json',dict(stage='GEOMETRY',parts=len(out),cumulative_cpu_seconds=total())) if len(out)==10: projection=1.25*(total()-60)*sum(r['nodes'] for r in c['parts'])/sum(r['nodes'] for r in c['parts'][:10]);save(root/'first-ten-cost-check.json',dict(projected_cpu_seconds=projection,cap=c['geometry_cpu_cap'],passed=projection<=c['geometry_cpu_cap'])) if projection>c['geometry_cpu_cap']:raise RuntimeError('PARK_GEOMETRY_COST_PROJECTION') save(root/'features-manifest.json',dict(entries=out,all431_terminal=True,labels_read=False)) freeze(root,'features',[root/'contract.json',root/'features-manifest.json',*[BASE/p for p in c['code_sha256']]]) for mode,cap in [('train',1500),('predict',3600),('score',180)]: if mode=='predict':freeze(root,'model',[root/'contract.json',root/'phases/train/model.ubj',root/'phases/train/result.json',*[BASE/p for p in c['code_sha256']]]) if mode=='score':freeze(root,'predictions',[root/'contract.json',root/'phases/predict/manifest.json',*[BASE/p for p in c['code_sha256']]]) dest=root/'phases'/mode;dest.mkdir(parents=True,exist_ok=False);save(root/'live-progress.json',dict(stage=mode,cumulative_cpu_seconds=total()));call(mode,dest,cap,cap+60) save(root/'complete.json',dict(status='COMPLETE',scientific_gate=read(root/'phases/score/result.json')['decision'],records=records,cumulative_cpu_seconds=total(),models_fit=1,retry=False)) except BaseException as exc: save(root/'complete.json',dict(status='STOPPED',reason=type(exc).__name__+': '+str(exc),records=records,cumulative_cpu_seconds=total(),completed_geometry=len(out),retry=False));raise if __name__=='__main__': p=argparse.ArgumentParser();p.add_argument('mode',choices=['run','prep','train','predict','score']);p.add_argument('root',type=Path);p.add_argument('index',nargs='?',type=int);a=p.parse_args() if a.mode=='run':run(a.root) elif a.mode=='prep':prep(a.root,config(a.root),a.index) else:dict(train=train,predict=predict,score=score)[a.mode](a.root,config(a.root))