Files
MeltMind/tools/phase2_b12_math.py

122 lines
7.5 KiB
Python

"""Frozen Df-guided tet-edge paths and dry merge-tree depth; no truth."""
import heapq
import math
import numpy as np
from scipy.sparse import csr_matrix
def edge_geometry(x,tets,volume,cell_speed):
pairs=[(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]
raw=np.concatenate([np.sort(tets[:,[i,j]],axis=1) for i,j in pairs])
edges,inverse=np.unique(raw,axis=0,return_inverse=True)
denominator=np.bincount(inverse,weights=np.tile(volume,6))
inside=np.bincount(inverse,weights=np.tile(volume*cell_speed,6))/denominator
length=np.linalg.norm(x[edges[:,0]]-x[edges[:,1]],axis=1)
if np.any(length<=0) or not np.isfinite(length).all():raise ValueError('NONPOSITIVE_OR_NONFINITE_EDGE')
a=np.r_[edges[:,0],edges[:,1]];b=np.r_[edges[:,1],edges[:,0]]
adjacency=csr_matrix((np.r_[length,length],(a,b)),shape=(len(x),len(x)))
thickness=csr_matrix((np.r_[2*inside,2*inside],(a,b)),shape=adjacency.shape)
return adjacency,thickness
def paths(df,raw,roots,adjacency,thickness,mass=None):
n=len(df);df=np.asarray(df);raw=np.asarray(raw);roots=set(map(int,roots))
mass=np.ones(n) if mass is None else np.asarray(mass)
if not roots or min(roots)<0 or max(roots)>=n or not np.isfinite(df).all():raise ValueError('INVALID_DF_OR_SOURCE')
if not np.array_equal(adjacency.indices,thickness.indices) or not np.array_equal(adjacency.indptr,thickness.indptr):raise ValueError('EDGE_FIELD_ALIGNMENT')
order=np.argsort(df,kind='stable');cuts=np.r_[0,np.flatnonzero(np.diff(df[order])!=0)+1,n]
parent=np.full(n,-2,np.int64);owner=np.full(n,-1,np.int64);b=np.full(n,np.nan);integral=np.full(n,np.nan);processed=[];ties=0;platforms=[]
for lo,hi in zip(cuts[:-1],cuts[1:]):
layer=set(map(int,order[lo:hi]))
while layer:
seed=min(layer,key=lambda i:int(raw[i]));layer.remove(seed);todo=[seed];nodes=[]
while todo:
i=todo.pop();nodes.append(i)
for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]:
j=int(jj)
if j in layer:layer.remove(j);todo.append(j)
block=set(nodes);best={};queue=[];exits=0
for i in nodes:
options=[]
for pos in range(adjacency.indptr[i],adjacency.indptr[i+1]):
j=int(adjacency.indices[pos]);length=float(adjacency.data[pos])
if df[j]<df[i] and owner[j]>=0:options.append((-(df[i]-df[j])/length,int(raw[j]),j,pos))
if i in roots:
parent[i]=-1;owner[i]=i;b[i]=np.inf;integral[i]=0.;processed.append(i);candidate=(0.,int(raw[i]),-1,i);exits+=1
elif options:
options.sort();_,_,j,pos=options[0];ties+=sum(o[0]==options[0][0] for o in options)>1
parent[i]=j;owner[i]=owner[j];h=float(thickness.data[pos]);b[i]=min(b[j],h) if np.isfinite(h) and h>0 and not np.isnan(b[j]) else np.nan
integral[i]=integral[j]+float(adjacency.data[pos])/h**2 if np.isfinite(h) and h>0 else np.nan;processed.append(i)
candidate=(0.,int(raw[i]),int(raw[j]),i);exits+=1
else:continue
best[i]=candidate[:3];heapq.heappush(queue,candidate)
finalized=set()
while queue:
dist,exit_id,parent_id,i=heapq.heappop(queue)
if i in finalized or best.get(i)!=(dist,exit_id,parent_id):continue
finalized.add(i)
for pos in range(adjacency.indptr[i],adjacency.indptr[i+1]):
j=int(adjacency.indices[pos])
if j not in block or j in finalized:continue
candidate=(dist+float(adjacency.data[pos]),exit_id,int(raw[i]))
if candidate[0]<=dist:raise ValueError('PLATFORM_DISTANCE_PRECISION_LOSS')
if j not in best or candidate<best[j]:
best[j]=candidate;parent[j]=i;owner[j]=owner[i];h=float(thickness.data[pos])
b[j]=min(b[i],h) if np.isfinite(h) and h>0 and not np.isnan(b[i]) else np.nan
integral[j]=integral[i]+float(adjacency.data[pos])/h**2 if np.isfinite(h) and h>0 else np.nan
heapq.heappush(queue,(*candidate,j))
if parent[i]>=0 and df[parent[i]]==df[i]:processed.append(i)
platforms.append(dict(size=len(nodes),exits=exits,reachable=len(finalized),mass=math.fsum(map(float,mass[nodes])),Df=float(df[nodes[0]]),minimum_raw_id=int(min(raw[nodes]))))
b[np.isinf(b)]=np.nan
return parent,owner,np.column_stack([b,integral]),dict(platforms=platforms,lower_slope_tie_nodes=int(ties),reachable_nodes=int(np.sum(owner>=0)))
def junction_depth(df,mass,raw,adjacency,roots,parent_owner,persistence=.010):
n=len(df);order=np.argsort(-np.asarray(df),kind='stable');cuts=np.r_[0,np.flatnonzero(np.diff(np.asarray(df)[order])!=0)+1,n]
uf=np.arange(n);active=np.zeros(n,bool);birth=np.zeros(n);birth_id=np.array(raw,copy=True);top=np.full(n,-1,np.int64);location=np.full(n,-1,np.int64)
tree_parent=[];significant=[];levels=[];total=math.fsum(map(float,mass));passed=0.
def find(i):
while uf[i]!=i:uf[i]=uf[uf[i]];i=int(uf[i])
return i
for lo,hi in zip(cuts[:-1],cuts[1:]):
layer=order[lo:hi];level=passed/total;pending=set(map(int,layer));blocks=[]
while pending:
first=pending.pop();todo=[first];nodes=[];olds=set()
while todo:
i=todo.pop();nodes.append(i)
for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]:
j=int(jj)
if active[j]:olds.add(find(j))
elif j in pending:pending.remove(j);todo.append(j)
blocks.append((nodes,olds))
bp=list(range(len(blocks)));seen={}
def bf(i):
while bp[i]!=i:bp[i]=bp[bp[i]];i=bp[i]
return i
for k,(_,olds) in enumerate(blocks):
for g in olds:
if g in seen:bp[bf(k)]=bf(seen[g])
else:seen[g]=k
groups={}
for k in range(len(blocks)):groups.setdefault(bf(k),[]).append(k)
for keys in groups.values():
nodes=[i for k in keys for i in blocks[k][0]];olds=set().union(*(blocks[k][1] for k in keys));event=False
tid=len(tree_parent);tree_parent.append(-1);levels.append(level)
if olds:
survivor=min(olds,key=lambda i:(birth[i],int(birth_id[i])))
event=any(level-birth[i]>=persistence and level-birth[i]>0 for i in olds-{survivor})
for g in olds:tree_parent[int(top[g])]=tid;uf[g]=survivor
else:survivor=min(nodes,key=lambda i:int(raw[i]));birth[survivor]=level;birth_id[survivor]=raw[survivor]
significant.append(event);top[survivor]=tid
for i in nodes:uf[i]=survivor;active[i]=True;location[i]=tid
passed=math.fsum((passed,math.fsum(map(float,np.asarray(mass)[layer]))))
depth=np.zeros(len(tree_parent),np.int64)
for i in range(len(depth)-1,-1,-1):
p=tree_parent[i]
if p>=0:depth[i]=depth[p]+int(significant[p])
result=np.full(n,np.nan)
valid=np.flatnonzero(parent_owner>=0)
result[valid]=depth[location[valid]]-depth[location[parent_owner[valid]]]
if np.any(result[valid]<0):raise ValueError('ROOT_NOT_ANCESTOR_IN_DRY_TREE')
return result,dict(significant_events=int(sum(significant)),tree_nodes=len(tree_parent)),dict(tree_parent=np.array(tree_parent),significant=np.array(significant),node_tree_location=location,tree_depth=depth,tree_levels=np.array(levels))