156 lines
12 KiB
Python
156 lines
12 KiB
Python
"""Grouped spectral projectors on genuinely different tetra mesh constructions.
|
|
|
|
No unique axes inside grouped eigenspaces. Scalars remain diagnostic outputs.
|
|
The existing 3-hop estimator is intentionally held fixed so its errors are measured.
|
|
"""
|
|
import argparse
|
|
import itertools
|
|
import json
|
|
from pathlib import Path
|
|
import time
|
|
import numpy as np
|
|
from scipy.spatial import Delaunay,cKDTree
|
|
if __package__:
|
|
from .route_feasibility import graph_from_edges,node_tensor
|
|
else:
|
|
from route_feasibility import graph_from_edges,node_tensor
|
|
|
|
|
|
def grouped(tensor,tau=.1):
|
|
value,basis=np.linalg.eigh(tensor);value=value[:,::-1];basis=basis[:,:,::-1]
|
|
trace=value.sum(1);scale=np.maximum(value[:,0],1e-12);gaps=(value[:,:-1]-value[:,1:])/scale[:,None]
|
|
# pattern: split bits between ordered eigenvalues; grouping is sign-free.
|
|
code=(gaps[:,0]>tau).astype(np.int8)+2*(gaps[:,1]>tau).astype(np.int8)
|
|
unsupported=trace<=1e-10;code[unsupported]=-1
|
|
pattern={0:[(0,3)],1:[(0,1),(1,3)],2:[(0,2),(2,3)],3:[(0,1),(1,2),(2,3)]}
|
|
projector=np.zeros((len(tensor),3,3,3));mean=np.zeros((len(tensor),3));ratio=np.zeros_like(mean);rank=np.zeros_like(mean,dtype=np.int8)
|
|
for c,groups in pattern.items():
|
|
ids=np.flatnonzero(code==c)
|
|
for j,(a,b) in enumerate(groups):
|
|
q=basis[ids,:,a:b];projector[ids,j]=q@q.transpose(0,2,1);mean[ids,j]=value[ids,a:b].mean(1);ratio[ids,j]=value[ids,a:b].sum(1)/trace[ids];rank[ids,j]=b-a
|
|
return dict(values=value,ratios=value/np.where(trace>1e-10,trace,1)[:,None],projector=projector,group_mean=mean,group_ratio=ratio,rank=rank,code=code,unsupported=unsupported)
|
|
|
|
|
|
def voxel_mesh(axes,variant,is_t=False):
|
|
shape=tuple(len(a) for a in axes);base=np.stack(np.meshgrid(*axes,indexing='ij'),axis=-1).reshape(-1,3);points=list(base);tets=[]
|
|
for cell in itertools.product(*(range(n-1) for n in shape)):
|
|
low=np.array([axes[i][cell[i]] for i in range(3)]);high=np.array([axes[i][cell[i]+1] for i in range(3)]);center=(low+high)/2
|
|
if is_t and not (center[1]<.5 or abs(center[0])<.5):continue
|
|
ids={bits:int(np.ravel_multi_index(tuple(np.array(cell)+bits),shape)) for bits in itertools.product([0,1],repeat=3)}
|
|
if variant=='six_tets':
|
|
for perm in itertools.permutations(range(3)):
|
|
b=np.zeros(3,dtype=int);corners=[ids[tuple(b)]]
|
|
for axis in perm:b=b.copy();b[axis]+=1;corners.append(ids[tuple(b)])
|
|
tets.append(corners)
|
|
elif variant=='cell_center_twelve':
|
|
center_id=len(points);points.append(center)
|
|
for fixed in range(3):
|
|
other=[i for i in range(3) if i!=fixed]
|
|
for side in [0,1]:
|
|
face=[]
|
|
for u,v in [(0,0),(1,0),(1,1),(0,1)]:
|
|
b=[0,0,0];b[fixed]=side;b[other[0]]=u;b[other[1]]=v;face.append(ids[tuple(b)])
|
|
tets.extend([[center_id,face[0],face[1],face[2]],[center_id,face[0],face[2],face[3]]])
|
|
else:raise ValueError(variant)
|
|
points=np.array(points);tets=np.array(tets);used=np.unique(tets);return points[used],np.searchsorted(used,tets),0
|
|
|
|
|
|
def cylinder_mesh(n,variant):
|
|
facets=4*n;theta=np.arange(facets)*2*np.pi/facets;points=[]
|
|
for z in np.linspace(0,4,n+1):
|
|
points.append([0,0,z])
|
|
for r in [.05,.1,.15,.2]:points.extend(np.c_[r*np.cos(theta),r*np.sin(theta),np.full(facets,z)])
|
|
if variant=='staggered_interior':
|
|
for z in (np.arange(n)+.5)*4/n:
|
|
for r in [.025,.075,.125,.175]:points.extend(np.c_[r*np.cos(theta+np.pi/facets),r*np.sin(theta+np.pi/facets),np.full(facets,z)])
|
|
x=np.array(points);tet=Delaunay(x).simplices
|
|
q=x[tet];vol=np.abs(np.linalg.det(q[:,1:]-q[:,:1]))/6
|
|
# Qhull can return exactly coplanar cells in this structured point cloud.
|
|
valid=vol>1e-14;removed=int((~valid).sum());tet=tet[valid];used=np.unique(tet)
|
|
return x[used],np.searchsorted(used,tet),removed
|
|
|
|
|
|
def geometry(name,n,variant):
|
|
if name=='circular_rod':return cylinder_mesh(n,variant)
|
|
if name=='T_union':
|
|
axes=[np.unique(np.concatenate([np.linspace(a,b,n+1) for a,b in zip(bounds,bounds[1:])])) for bounds in [[-2,-.5,.5,2],[-.5,.5,2],[-.5,.5]]]
|
|
return voxel_mesh(axes,variant,True)
|
|
size={'plate':[10.,6.,.2],'square_rod':[.2,.2,8.]}[name]
|
|
return voxel_mesh([np.linspace(0,l,n+1) for l in size],variant)
|
|
|
|
|
|
def exact_distance(points,name):
|
|
if name=='circular_rod':return np.maximum(np.minimum(.2-np.linalg.norm(points[:,:2],axis=1),np.minimum(points[:,2],4-points[:,2])),0)
|
|
if name=='T_union':
|
|
if __package__:from .validate_distance_extensions import t_union
|
|
else:from validate_distance_extensions import t_union
|
|
_,rect=t_union(1)
|
|
return np.array([np.linalg.norm(x-np.clip(x,rect[:,0],rect[:,1]),axis=1).min() for x in points])
|
|
length=np.array({'plate':[10.,6.,.2],'square_rod':[.2,.2,8.]}[name])
|
|
return np.maximum(np.minimum(points,length-points).min(1),0)
|
|
|
|
|
|
def compute(points,tet,distance):
|
|
q=points[tet];v=np.abs(np.linalg.det(q[:,1:]-q[:,:1]))/6
|
|
if np.any(v<=0):raise ValueError('Degenerate retained tetrahedron')
|
|
mass=np.bincount(tet.ravel(),weights=np.repeat(v/4,4),minlength=len(points))
|
|
edgeids=np.array(list(itertools.combinations(range(4),2)));edges=np.unique(np.sort(tet[:,edgeids].reshape(-1,2),axis=1),axis=0)
|
|
g=graph_from_edges(len(points),edges,np.linalg.norm(points[edges[:,0]]-points[edges[:,1]],axis=1))
|
|
tensor,_,_=node_tensor(points,tet,mass,distance,g)
|
|
return tensor,mass,float(v.sum())
|
|
|
|
|
|
def coverage(f,mass):
|
|
return dict(unsupported_volume=float(mass[f['code']==-1].sum()/mass.sum()),isotropic_group_volume=float(mass[f['code']==0].sum()/mass.sum()),normal_plus_plane_volume=float(mass[f['code']==1].sum()/mass.sum()),plane_plus_axis_volume=float(mass[f['code']==2].sum()/mass.sum()),three_singletons_volume=float(mass[f['code']==3].sum()/mass.sum()),failure_definition='unsupported OR isotropic group has no identifiable directional projector; three singletons is NOT proof of physical identifiability')
|
|
|
|
|
|
def main():
|
|
p=argparse.ArgumentParser();p.add_argument('output',type=Path);a=p.parse_args();a.output.mkdir(parents=True,exist_ok=True)
|
|
target=a.output/'remesh_projectors.json'
|
|
if target.exists():raise FileExistsError(target)
|
|
contract=dict(primary_gap_threshold=.1,sensitivity_thresholds=[.05,.25],estimator='Existing exact-distance-at-vertices -> tetra gradients -> volume-normalized structure tensor -> 3-hop volume-weighted smoothing. Held unchanged.',emit='Grouped projectors and rank/validity flags only; eigenvalues and ratios are diagnostic, not approved network inputs.',scope='Analytic plate, square rod, circular rod and T union; common spatial vertices. Two genuinely different interior tetra constructions, same boundary geometry within each pair. No new v5 mesh or training.')
|
|
(a.output/'projector_contract.json').write_text(json.dumps(contract,indent=2)+'\n')
|
|
start=time.monotonic();rows=[]
|
|
for name,levels in [('plate',[4,8,12]),('square_rod',[4,8,12]),('circular_rod',[4,8,12]),('T_union',[2,4,6])]:
|
|
for n in levels:
|
|
variants=['radial_delaunay','staggered_interior'] if name=='circular_rod' else ['six_tets','cell_center_twelve']
|
|
meshes=[]
|
|
for variant in variants:
|
|
x,tet,removed=geometry(name,n,variant);tensor,mass,volume=compute(x,tet,exact_distance(x,name));meshes.append((x,tet,tensor,mass,volume,removed))
|
|
x1,tet1,t1,m1,v1,removed1=meshes[0];x2,tet2,t2,m2,v2,removed2=meshes[1]
|
|
error,index=cKDTree(x2).query(x1);shared=error<1e-10
|
|
if not shared.all():raise ValueError('Missing common query vertices')
|
|
if not np.isclose(v1,v2,rtol=1e-10,atol=1e-12):raise ValueError('Different volume domains')
|
|
row=dict(shape=name,resolution=n,variants=variants,nodes=[len(x1),len(x2)],tets=[len(tet1),len(tet2)],volumes=[v1,v2],removed_degenerate_tets=[removed1,removed2],common_queries=len(x1),raw_tensor_max_abs_error=float(abs(t1-t2[index]).max()),thresholds={})
|
|
for tau in [.1,.05,.25]:
|
|
f1=grouped(t1,tau);f2=grouped(t2,tau);same=(f1['code']==f2['code'][index])&(f1['code']>=0)
|
|
projector_errors=np.linalg.norm(f1['projector'][same]-f2['projector'][index[same]],axis=(2,3)).max(1) if same.any() else np.array([])
|
|
scalars=abs(f1['group_mean'][same]-f2['group_mean'][index[same]])
|
|
ratios=abs(f1['group_ratio'][same]-f2['group_ratio'][index[same]])
|
|
worst=np.flatnonzero(same)[np.argsort(projector_errors)[-5:]] if same.any() else np.array([],int)
|
|
row['thresholds'][str(tau)]=dict(coverage_A=coverage(f1,m1),coverage_B=coverage(f2,m2),pattern_mismatch_query_fraction=float((f1['code']!=f2['code'][index]).mean()),same_supported_pattern_queries=int(same.sum()),projector_frobenius_max=float(projector_errors.max()) if same.any() else None,projector_frobenius_p95=float(np.quantile(projector_errors,.95)) if same.any() else None,group_eigenvalue_mean_max_abs_error=float(scalars.max()) if same.any() else None,group_normalized_mass_max_abs_error=float(ratios.max()) if same.any() else None,all_queries_sorted_eigenvalue_max_abs_error=float(abs(f1['values']-f2['values'][index]).max()),all_queries_sorted_normalized_eigenvalue_max_abs_error=float(abs(f1['ratios']-f2['ratios'][index]).max()),worst_same_pattern_positions=x1[worst].tolist(),unsupported_or_isotropic_positions_A=x1[np.flatnonzero(f1['code']<=0)[:8]].tolist(),comparison_scope='Group-specific errors conditional on same grouping; mismatch fraction is separately mandatory. Coverage is per-mesh volume; pair errors are common-node statistics, not volume-integrated errors.')
|
|
by_pattern={}
|
|
for code,label in [(1,'normal_plus_plane'),(2,'plane_plus_axis'),(3,'three_singletons')]:
|
|
selected=same&(f1['code']==code)
|
|
if selected.any():
|
|
pe=np.linalg.norm(f1['projector'][selected]-f2['projector'][index[selected]],axis=(2,3)).max(1)
|
|
by_pattern[label]=dict(queries=int(selected.sum()),projector_frobenius_max=float(pe.max()),projector_frobenius_p95=float(np.quantile(pe,.95)),group_mean_max_error=float(abs(f1['group_mean'][selected]-f2['group_mean'][index[selected]]).max()),group_ratio_max_error=float(abs(f1['group_ratio'][selected]-f2['group_ratio'][index[selected]]).max()))
|
|
else:by_pattern[label]=dict(queries=0)
|
|
row['thresholds'][str(tau)]['by_pattern']=by_pattern
|
|
center={'plate':[5.,3.,.1],'square_rod':[.1,.1,4.],'circular_rod':[0.,0.,2.],'T_union':[0.,.5,0.]}[name]
|
|
i=int(np.argmin(np.linalg.norm(x1-np.array(center),axis=1)));j=int(index[i]);vA,bA=np.linalg.eigh(t1[i]);vB,bB=np.linalg.eigh(t2[j])
|
|
center_record=dict(query=x1[i].tolist(),tensor_A=t1[i].tolist(),tensor_B=t2[j].tolist(),eigenvalues_A=vA.tolist(),eigenvalues_B=vB.tolist(),eigenvalue_max_difference=float(abs(vA-vB).max()),normalized_eigenvalue_max_difference=float(abs(vA/vA.sum()-vB/vB.sum()).max()))
|
|
if name!='T_union':
|
|
axis=-1 if name=='plate' else 0;PA=np.outer(bA[:,axis],bA[:,axis]);PB=np.outer(bB[:,axis],bB[:,axis]);ideal=np.diag([0.,0.,1.])
|
|
center_record.update(oracle_axis_projector_difference=float(np.linalg.norm(PA-PB)),oracle_axis_error_A=float(np.linalg.norm(PA-ideal)),oracle_axis_error_B=float(np.linalg.norm(PB-ideal)),scope='Geometrically known axis at this analytic point; diagnostic only, not an axis forced into the gap-grouped feature output')
|
|
row['analytic_center']=center_record
|
|
rows.append(row);print(name,n,'primary mismatch',row['thresholds']['0.1']['pattern_mismatch_query_fraction'],'Pmax',row['thresholds']['0.1']['projector_frobenius_max'],flush=True)
|
|
# Largest real part: new grouping only, no claim of a second mesh.
|
|
old=Path('artifacts/routes-2026-11-13');a_path=next(old.glob('00000666*.route_arrays.npz'));old_data=np.load(a_path)
|
|
d=np.load(Path('artifacts/intake-2026-11-13/samples')/a_path.name.replace('.route_arrays.npz','.npz'));f=grouped(old_data['tensor'],.1)
|
|
largest=dict(case=a_path.stem,coverage=coverage(f,d['node_volume_raw']),remesh_comparison='NOT_AVAILABLE_single_exported_mesh; reused cached tensor only')
|
|
result=dict(contract=contract,rows=rows,largest_v5=largest,wall_seconds=time.monotonic()-start,acceptance='No projector/scalar remesh tolerance frozen; numeric diagnostics do not approve scalar features.')
|
|
target.write_text(json.dumps(result,indent=2)+'\n');print('Done',result['wall_seconds'],flush=True)
|
|
|
|
if __name__=='__main__':main()
|