Files
MeltMind/tools/phase2_b14_math.py
T

100 lines
7.4 KiB
Python

"""Exact P1 band volumes, face-connected families and once-crossing paths."""
import itertools
import numpy as np
from scipy.sparse import coo_matrix
from scipy.sparse.csgraph import connected_components,dijkstra
PAIRS=list(itertools.combinations(range(4),2))
FACES=list(itertools.combinations(range(4),3))
def below_fraction(values,t,inclusive=False):
f=np.sort(np.asarray(values,np.longdouble),axis=1);n=np.sum(f<=t if inclusive else f<t,axis=1);v=np.zeros(len(f),np.longdouble);v[n==4]=1
for count in [1,2,3]:
ix=n==count;a=f[ix]
if not len(a):continue
if count==1:v[ix]=np.prod((t-a[:,0,None])/(a[:,1:]-a[:,0,None]),axis=1)
elif count==3:v[ix]=1-np.prod((a[:,3,None]-t)/(a[:,3,None]-a[:,:3]),axis=1)
else:
q02=(t-a[:,0])/(a[:,2]-a[:,0]);q03=(t-a[:,0])/(a[:,3]-a[:,0]);q12=(t-a[:,1])/(a[:,2]-a[:,1]);q13=(t-a[:,1])/(a[:,3]-a[:,1])
v[ix]=q02*q03+q02*q13*(1-q03)+q12*q13*(1-q02)
return v
def band_fraction(f,lo,hi):
result=below_fraction(f,hi)-below_fraction(f,lo,True)
expected=(np.min(f,axis=1)<hi)&(np.max(f,axis=1)>lo)
if np.any(result<0) or np.any(result>1) or np.any(expected&(result<=0)):raise ValueError('Unresolved positive-volume clip / numerical cancellation')
return np.asarray(result,np.float64)
def layers(F):
out=np.zeros(len(F));good=F>0
_,e=np.frexp(F[good]/2);out[good]=np.ldexp(np.ones(sum(good)),np.minimum(e-1,-1));return out
def graph(n,edges,cost,mask=None,initial=None):
if mask is not None:edges=edges[mask];cost=cost[mask]
u=np.r_[edges[:,0],edges[:,1]];v=np.r_[edges[:,1],edges[:,0]];w=np.r_[cost,cost]
if initial is not None:
ii=np.flatnonzero(np.isfinite(initial));u=np.r_[u,np.full(len(ii),n)];v=np.r_[v,ii];w=np.r_[w,initial[ii]];n+=1
return coo_matrix((w,(u,v)),shape=(n,n)).tocsr()
def edge_data(x,t,speed):
all_edges=np.sort(t[:,PAIRS].reshape(-1,2),axis=1);edges,inverse=np.unique(all_edges,axis=0,return_inverse=True)
fastest=np.zeros(len(edges));np.maximum.at(fastest,inverse,np.repeat(speed,6));cost=np.linalg.norm(x[edges[:,0]]-x[edges[:,1]],axis=1)/fastest
if not np.isfinite(cost).all() or np.any(cost<=0):raise ValueError('Nonpositive/nonfinite true edge cost')
return edges,inverse,cost
def families(t,F,volume,r):
frac=band_fraction(F[t],.75*r,1.25*r);active=frac>0;ids=np.flatnonzero(active);label=np.full(len(t),-1,int)
faces=np.sort(t[:,FACES].reshape(-1,3),axis=1);uniq,inv,count=np.unique(faces,axis=0,return_inverse=True,return_counts=True)
order=np.argsort(inv,kind='stable');starts=np.r_[0,np.cumsum(count[:-1])];two=np.flatnonzero(count==2)
owners=np.repeat(np.arange(len(t)),4);a=owners[order[starts[two]]];b=owners[order[starts[two]+1]]
values=F[uniq[two]];ok=active[a]&active[b]&(values.min(1)<1.25*r)&(values.max(1)>.75*r)
local=np.full(len(t),-1,int);local[ids]=np.arange(len(ids));aa=local[a[ok]];bb=local[b[ok]]
mat=coo_matrix((np.ones(2*len(aa)),(np.r_[aa,bb],np.r_[bb,aa])),shape=(len(ids),len(ids))).tocsr()
n,labels=connected_components(mat,directed=False);label[ids]=labels;vol=np.bincount(labels,weights=volume[ids]*frac[ids],minlength=n)
if not np.isclose(vol.sum(),np.sum(volume*frac),rtol=1e-13,atol=0):raise ValueError('Band volume conservation')
badface=np.flatnonzero((count>2)&(F[uniq].min(1)<1.25*r)&(F[uniq].max(1)>.75*r))
return label,vol,frac,uniq[badface]
def manifold_edge(tets,u,v):
links=[tuple(int(x) for x in tet if x!=u and x!=v) for tet in tets];adj={}
for a,b in links:adj.setdefault(a,set()).add(b);adj.setdefault(b,set()).add(a)
if len(set(tuple(sorted(x)) for x in links))!=len(links) or any(len(v)>2 for v in adj.values()):return False
seen=set();todo=[next(iter(adj))]
while todo:
a=todo.pop()
if a not in seen:seen.add(a);todo.extend(adj[a]-seen)
return len(seen)==len(adj)
def channels(x,t,F,Df,mass,volume,speed,sources,emit):
n=len(x);edges,inv,cost=edge_data(x,t,speed);G=graph(n,edges,cost);_,physical=connected_components(G,directed=False)
dG=dijkstra(G,directed=False,indices=sources,min_only=True);source=np.zeros(n,bool);source[sources]=True
comparable=np.isfinite(dG)&np.isfinite(Df)&(dG>=.95*Df)&(dG<=1.05*Df)
extra=np.full((n,2),np.nan);extra[source]=[1,0];layer=layers(F);diag=[]
edgeorder=np.argsort(inv,kind='stable');edgecount=np.bincount(inv,minlength=len(edges));edgestart=np.r_[0,np.cumsum(edgecount[:-1])];owners=np.repeat(np.arange(len(t)),6)
for r in np.unique(layer[(~source)&(F>0)]):
target=np.flatnonzero((layer==r)&~source);label,V,frac,badfaces=families(t,F,volume,r)
low=F<=r;cross=low[edges[:,0]]!=low[edges[:,1]];ce=np.flatnonzero(cross);u=edges[ce,0].copy();v=edges[ce,1].copy();rev=~low[u];u[rev],v[rev]=v[rev].copy(),u[rev].copy()
flabel=np.full(len(ce),-1,int);ambiguous=set(physical[badfaces.ravel()].tolist())
for j,e in enumerate(ce):
incident=owners[edgeorder[edgestart[e]:edgestart[e]+edgecount[e]]];labels=np.unique(label[incident]);labels=labels[labels>=0]
if len(labels)!=1 or not manifold_edge(t[incident],int(u[j]),int(v[j])):ambiguous.add(int(physical[u[j]]))
else:flabel[j]=labels[0]
lowG=graph(n,edges,cost,low[edges[:,0]]&low[edges[:,1]])
dm=dijkstra(lowG,directed=False,indices=sources,min_only=True);highmask=~low[edges[:,0]]&~low[edges[:,1]]
count=np.zeros(len(target),int);sums=np.zeros(len(target));maximum=np.zeros(len(target));qt=[];qa=[];ql=[]
eligible=comparable[target]&~np.isin(physical[target],list(ambiguous));limit=float(np.max(1.05*Df[target]))
for a in range(len(V)):
es=np.flatnonzero(flabel==a)
if not len(es):continue
init=np.full(n,np.inf);np.minimum.at(init,v[es],dm[u[es]]+cost[ce[es]])
H=graph(n,edges,cost,highmask,init);L=dijkstra(H,directed=True,indices=n,limit=limit)[:n][target]
qualifies=eligible&np.isfinite(L)&(L<=1.05*Df[target])
if np.any(L[np.isfinite(L)]+1e-10*np.maximum(1,dG[target][np.isfinite(L)])<dG[target][np.isfinite(L)]):raise ValueError('Restricted path below full graph distance')
count[qualifies]+=1;sums[qualifies]+=V[a];maximum[qualifies]=np.maximum(maximum[qualifies],V[a]);qt.extend(target[qualifies]);qa.extend(np.full(sum(qualifies),a));ql.extend(L[qualifies])
extra[target[eligible],0]=count[eligible];w=eligible&(count>0);extra[target[w],1]=1-maximum[w]/sums[w]
record=dict(r=float(r),targets=len(target),families=len(V),band_volume=float(V.sum()),ambiguous_components=sorted(ambiguous),qualified_targets=int(sum(w)),comparable_targets=int(sum(comparable[target])),no_witness=int(sum(eligible&(count==0))))
emit(record,dict(family_volume=V,tet_family=label,tet_band_fraction=frac,target_ids=target,qualified_target=np.asarray(qt,int),qualified_family=np.asarray(qa,int),qualified_cost=np.asarray(ql,float)))
diag.append(record)
nonroot=~source;den=float(mass[nonroot].sum());valid=np.isfinite(extra).all(1)&nonroot
reason=dict(distance_low=float(mass[nonroot&(dG<.95*Df)].sum()/den),distance_high=float(mass[nonroot&(dG>1.05*Df)].sum()/den),nonroot_zero_F=float(mass[nonroot&(F==0)].sum()/den))
return extra,dict(layers=diag,valid_nonroot_volume_fraction=float(mass[valid].sum()/den),two_family_nonroot_volume_fraction=float(mass[valid&(extra[:,0]>=2)].sum()/den),missing_reasons_volume_fraction=reason,source_nodes=int(sum(source)),nonroot_volume=den),dG