"""Bounded E6: physical-radius kernel on cached real geometry, no graph smoothing. Anchor estimates describe the positive-distance LUMPED discrete measure, not continuous full-cavity volume. Boundary lumped mass is explicitly unscored. """ import argparse import hashlib import json from pathlib import Path import resource import time import numpy as np from scipy.spatial import cKDTree if __package__: from .run_volume_quadrature_trial import tetra_rule from .projector_remesh_probe import grouped else: from run_volume_quadrature_trial import tetra_rule from projector_remesh_probe import grouped def sha(path): return hashlib.sha256(Path(path).read_bytes()).hexdigest() def save(path, value): Path(path).write_text(json.dumps(value, indent=2, allow_nan=False)+'\n') def quantiles(a): return dict(zip(['min','p50','p99','max'], map(float,np.quantile(a,[0,.5,.99,1])))) def anchor_plan(d, mass, seed, n): order=np.argsort(d,kind='stable') median=float(d[order[np.searchsorted(np.cumsum(mass[order]),mass.sum()/2)]]) if median<=0: raise ValueError('Nonpositive thickness proxy; do not silently choose R') positive=np.flatnonzero(d>0) draws=np.random.default_rng(seed).choice(positive,size=n,replace=True,p=mass[positive]/mass[positive].sum()) unique,inverse=np.unique(draws,return_inverse=True) return unique,inverse,dict(weighted_median_distance=median,thickness_proxy=4*median,radius=10*median, positive_distance_mass_fraction=float(mass[positive].sum()/mass.sum()), boundary_unscored_mass_fraction=float(mass[d==0].sum()/mass.sum()), draws=n,unique_anchors=len(unique),seed=seed) def raw_field(x,tet,d): """Same pre-smoothing tensor definition as node_tensor(steps=0), batched.""" total=np.zeros((len(x),3,3));supported_mass=np.zeros(len(x));bad=0 for begin in range(0,len(tet),8192): ids=tet[begin:begin+8192];p=x[ids];edge=p[:,1:]-p[:,:1] v=abs(np.linalg.det(edge))/6 if np.any(v<=0): raise ValueError('Degenerate tetrahedron') g=np.linalg.solve(edge,(d[ids[:,1:]]-d[ids[:,:1]])[...,None])[...,0] norm=np.linalg.norm(g,axis=1);ok=norm>1e-8;bad+=int((~ok).sum()) normal=g/np.where(ok,norm,1)[:,None] outer=normal[:,:,None]*normal[:,None,:] w=v*ok/4 for j in range(4): np.add.at(total,ids[:,j],outer*w[:,None,None]);np.add.at(supported_mass,ids[:,j],w) total/=np.where(supported_mass>0,supported_mass,1)[:,None,None] return total,dict(zero_gradient_tets=bad,unsupported_nodes=int((supported_mass==0).sum()),smoothing_steps=0) def samples(x,tet,mass,rule,raw=None): if rule=='lumped_vertex': return x,mass,raw if rule!='tetra_four_point': raise ValueError(rule) sx=np.empty((4*len(tet),3));sm=np.empty(4*len(tet)) st=None if raw is None else np.empty((4*len(tet),3,3)) bary=tetra_rule() for begin in range(0,len(tet),8192): ids=tet[begin:begin+8192];p=x[ids];sl=slice(4*begin,4*(begin+len(ids))) sx[sl]=np.einsum('qj,tjk->tqk',bary,p).reshape(-1,3) sm[sl]=np.repeat(abs(np.linalg.det(p[:,1:]-p[:,:1]))/24,4) if st is not None: st[sl]=np.einsum('qj,tjkl->tqkl',bary,raw[ids]).reshape(-1,3,3) if not np.isclose(sm.sum(),mass.sum(),rtol=1e-10): raise ValueError('Mass mismatch') return sx,sm,st def integrate(query,sx,sm,st,radius): tree=cKDTree(sx);n=len(query);tensor=np.zeros((n,3,3));km=np.zeros(n);neff=np.zeros(n);cov=np.zeros((n,3)) for i,q in enumerate(query): ids=np.asarray(tree.query_ball_point(q,radius),dtype=int) delta=sx[ids]-q;w=sm[ids]*np.maximum(1-np.sum(delta*delta,axis=1)/radius**2,0)**2 good=w>0;ids=ids[good];delta=delta[good];w=w[good] if not len(w): continue km[i]=w.sum();wn=w/km[i];neff[i]=1/(wn@wn) tensor[i]=np.einsum('i,ijk->jk',wn,st[ids]) mean=wn@delta;cc=(delta*wn[:,None]).T@delta-np.outer(mean,mean) val=np.linalg.eigvalsh(cc)[::-1] cov[i]=val/max(val[0],1e-30) return dict(tensor=tensor,kernel_mass=km,effective_samples=neff, ball_mass_ratio=km/(32*np.pi*radius**3/105),position_covariance_eigenvalue_ratios=cov) def proportion(mask): """Wilson interval for independent with-replacement probability draws.""" n=len(mask);p=float(np.mean(mask));z=1.959963984540054 center=(p+z*z/(2*n))/(1+z*z/n) delta=z*np.sqrt(p*(1-p)/n+z*z/(4*n*n))/(1+z*z/n) return dict(estimate=p,mc_wilson95=[max(0.,center-delta),min(1.,center+delta)]) def summary(a,inverse,fraction): f=grouped(a['tensor'],.1);code=f['code'][inverse] value=f['values'];gap=(value[:,:-1]-value[:,1:])/np.maximum(value[:,:1],1e-12) defined=(~f['unsupported'])[inverse];neff=(a['effective_samples']>=64)[inverse] mode={str(k):proportion(code==k) for k in [-1,0,1,2,3]} for item in mode.values(): item['full_lumped_mass_contribution']=fraction*item['estimate'] near=((gap>=.05)&(gap<=.15))[inverse]&defined[:,None] return dict(measure='Conditional positive-distance lumped-node volume; MC estimate, NOT continuous full-cavity volume', modes=mode,near_cut={k:proportion(v) for k,v in [('gap12',near[:,0]),('gap23',near[:,1]),('either',near.any(1))]}, neff_gate_pass=proportion(neff),neff_failed=proportion(~neff), neff_pass_mode_contributions={str(k):proportion(neff&(code==k)) for k in [-1,0,1,2,3]}, neff_pass_directionally_grouped=proportion(neff&np.isin(code,[1,2,3])), spectrally_defined=proportion(defined),effective_samples=quantiles(a['effective_samples'][inverse]), ball_mass_ratio=quantiles(a['ball_mass_ratio'][inverse]), covariance_ratios=[quantiles(a['position_covariance_eigenvalue_ratios'][inverse,j]) for j in range(3)], physical_support_quality_pass=None,continuous_volume_accuracy_certified=False, interval_scope='Sampling uncertainty only; excludes geometry, quadrature, distance and discretization errors.') def pose_comparison(a,b,query,gate,R,shift,inverse): f=grouped(a['tensor'],.1);g=grouped(b['tensor'],.1);same=f['code']==g['code'] ok=same&np.isin(f['code'],[1,2,3]);v=gate-query vp=(gate@R.T+shift)-(query@R.T+shift) av=np.einsum('ngij,nj->ngi',f['projector'],v);bv=np.einsum('ngij,nj->ngi',g['projector'],vp) return dict(independent_recomputed_mesh_gradients_and_kernel=True,cached_scalar_distance_reused_under_rigid_motion=True, model_prediction_check=False,tensor_covariance_max=float(abs(b['tensor']-R@a['tensor']@R.T).max()), mode_flip=proportion((~same)[inverse]),neff_gate_flip=proportion(((a['effective_samples']>=64)!=(b['effective_samples']>=64))[inverse]), compatible_directional_anchor_count=int(ok.sum()), grouped_projector_covariance_max=float(np.linalg.norm((g['projector']-R@f['projector']@R.T)[ok],axis=(2,3)).max(initial=0)), projected_gate_vector_covariance_max_raw=float(np.linalg.norm((bv-av@R.T)[ok],axis=2).max(initial=0)), gate_distance_error_max_raw=float(abs(np.linalg.norm(vp,axis=1)-np.linalg.norm(v,axis=1)).max()), kernel_mass_relative_change_max=float((abs(b['kernel_mass']-a['kernel_mass'])/np.maximum(a['kernel_mass'],1e-30)).max())) def main(): p=argparse.ArgumentParser();p.add_argument('phase',choices=['preflight','run']);p.add_argument('output',type=Path);args=p.parse_args();out=args.output contract=json.loads((out/'execution_contract.json').read_text()) for path,h in contract['input_sha256'].items(): if sha(path)!=h: raise ValueError('Changed source '+path) with (out/(args.phase+'.started.json')).open('x') as f: json.dump({'contract_sha256':sha(out/'execution_contract.json')},f) started=time.monotonic();rows=[] if args.phase=='run': pre=json.loads((out/'preflight.json').read_text()) if pre['contract_sha256']!=sha(out/'execution_contract.json'): raise ValueError('Preflight contract changed') R,_=np.linalg.qr(np.random.default_rng(421).normal(size=(3,3)));R*=np.linalg.det(R);shift=np.array([3.1,-7.,2.]) for spec in contract['cases']: tick=time.monotonic();case=spec['case'];print(args.phase,case,flush=True) data=np.load(spec['sample']);x=data['points_raw'];tet=data['tetra'];mass=data['node_volume_raw'];d=np.load(spec['distance']);gate=data['gate_location_raw'] unique,inverse,plan=anchor_plan(d,mass,spec['seed'],contract['draws']);radius=plan['radius'];query=x[unique] if args.phase=='run': raw,raw_meta=raw_field(x,tet,d);xr=x@R.T+shift;rawr,rawr_meta=raw_field(xr,tet,d) with np.load(spec['tensor_cache']) as cached: baseline=grouped(cached['tensor'][unique],.1) bv=baseline['values'];bg=(bv[:,:-1]-bv[:,1:])/np.maximum(bv[:,:1],1e-12) bn=((bg>=.05)&(bg<=.15))[inverse]&(~baseline['unsupported'])[inverse,None] matched_baseline=dict(field='cached_3hop_at_IDENTICAL_anchors_and_measure', modes={str(k):proportion(baseline['code'][inverse]==k) for k in [-1,0,1,2,3]}, near_cut_either=proportion(bn.any(1))) for rule in spec['rules']: name=case+'_'+rule if args.phase=='preflight': sx,sm,_=samples(x,tet,mass,rule);tree=cKDTree(sx) counts=tree.query_ball_point(query,radius,return_length=True) p99_budget=float(np.quantile(counts[inverse],.99)*len(inverse));actual=int(counts.sum()) guard=p99_budget<=contract['evaluation_budget'] and 2*actual<=contract['evaluation_budget'] row=dict(name=name,case=case,rule=rule,plan=plan,source_samples=len(sx),neighbors=quantiles(counts[inverse]), p99_times_draws=p99_budget,unique_neighbor_sum=actual,main_plus_pose_evaluation_upper_bound=2*actual,guard_pass=bool(guard)) np.savez_compressed(out/(name+'_anchors.npz'),unique_node_ids=unique,draw_to_unique=inverse,neighbor_counts=counts) del tree,sx,sm else: previous=next(r for r in pre['cases'] if r['name']==name) if not previous['guard_pass']: rows.append(dict(name=name,status='NOT_RUN_COST_GUARD'));continue anchors=np.load(out/(name+'_anchors.npz')) if not np.array_equal(anchors['unique_node_ids'],unique) or not np.array_equal(anchors['draw_to_unique'],inverse): raise ValueError('Anchors changed') sx,sm,st=samples(x,tet,mass,rule,raw);a=integrate(query,sx,sm,st,radius);del sx,sm,st sx,sm,st=samples(xr,tet,mass,rule,rawr);b=integrate(query@R.T+shift,sx,sm,st,radius);del sx,sm,st np.savez_compressed(out/(name+'_fields.npz'),unique_node_ids=unique,draw_to_unique=inverse, **{'original_'+k:v for k,v in a.items()},**{'rotated_'+k:v for k,v in b.items()}) row=dict(name=name,status='COMPUTED',case=case,rule=rule,plan=plan,raw_field=raw_meta,rotated_raw_field=rawr_meta, statistics=summary(a,inverse,plan['positive_distance_mass_fraction']), matched_old_baseline=matched_baseline, pose=pose_comparison(a,b,query,gate,R,shift,inverse),new_kernel_estimates=2) row['case_elapsed_seconds_so_far']=time.monotonic()-tick save(out/(name+'_'+args.phase+'.json'),row);rows.append(row);print('DONE',name,flush=True) del data,x,tet,mass,d,gate result=dict(phase=args.phase,contract_sha256=sha(out/'execution_contract.json'),cases=rows,wall_seconds=time.monotonic()-started, peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,training=False,O1=False,O2A=False,O2B=False,O2S=False, scope='E6 bounded estimator diagnostics; no predictive or physical-support acceptance claim') save(out/(args.phase+'.json'),result) if __name__=='__main__': main()