Files
MeltMind/tools/phase1_wallpair_probe.py
T

365 lines
19 KiB
Python

"""Exploratory paired-wall probe on two conforming meshes of analytic solids.
Axis-aligned rectangular support is an explicit restriction, not a general
mid-surface extractor. Geometry labels are used for evaluation only.
"""
import argparse
from collections import defaultdict
from contextlib import contextmanager
import hashlib
import itertools
import json
from pathlib import Path
import resource
import time
import numpy as np
TOL = 1e-8
OFFSET = 1e-6
ANGLE_COS = float(np.cos(np.deg2rad(5.)))
GRID = .5
def save(path, obj):
Path(path).write_text(json.dumps(obj, indent=2, allow_nan=False) + '\n')
@contextmanager
def timed(records, key):
cpu, wall = time.process_time(), time.monotonic()
yield
records[key] = {'cpu_seconds': time.process_time()-cpu,
'wall_seconds': time.monotonic()-wall,
'process_peak_rss_bytes': resource.getrusage(resource.RUSAGE_SELF).ru_maxrss*1024}
def shape(name):
# Boxes define physical ground truth, never a flow field.
boxes = {
'plate': [([0, 0, 0], [8, 6, 1])],
'u_gap': [([0, 0, 0], [2.5, 4, 1]), ([0, 0, 1], [1, 4, 6]),
([1.5, 0, 1], [2.5, 4, 6])],
't_rib': [([0, 0, 0], [8, 4, 1]), ([3, 0, 1], [5, 4, 2]),
([3.5, 0, 2], [4.5, 4, 5])],
}[name]
cells = set()
for low, high in boxes:
for c in itertools.product(*(range(round(a/GRID), round(b/GRID)) for a, b in zip(low, high))):
cells.add(c)
return sorted(cells)
def make_mesh(cells, variant):
points, indices, tets, owners = [], {}, [], []
def index(c):
c = tuple(c)
if c not in indices:
indices[c] = len(points)
points.append(np.array(c)*GRID)
return indices[c]
# Freudenthal triangulation, globally reflect local x for the second mesh.
# Consistent on every shared face; the surface geometry is identical.
for cell_id, cell in enumerate(cells):
for perm in itertools.permutations(range(3)):
vertices = [np.zeros(3, dtype=int)]
for axis in perm:
v = vertices[-1].copy(); v[axis] = 1; vertices.append(v)
if variant:
for v in vertices:
v[0] = 1-v[0]
tets.append([index(np.array(cell)+v) for v in vertices]); owners.append(cell_id)
return np.array(points), np.array(tets), np.array(owners)
def wall_anchors(cells):
present = set(cells); anchors, normals, tiles = [], [], []
for cell in cells:
low = np.array(cell)*GRID
for axis in range(3):
for sign in [-1, 1]:
nb = list(cell); nb[axis] += sign
if tuple(nb) in present:
continue
p = low+GRID/2; p[axis] = low[axis]+(GRID if sign == 1 else 0)
n = np.zeros(3); n[axis] = sign
anchors.append(p); normals.append(n); tiles.append(low)
return np.array(anchors), np.array(normals), np.array(tiles)
class Mesh:
def __init__(self, x, tet):
self.x, self.tet = x, tet
self.p = x[tet]
matrices = np.transpose(self.p[:, 1:]-self.p[:, :1], (0, 2, 1))
self.volumes = abs(np.linalg.det(matrices))/6
assert np.all(self.volumes > 0)
self.inverse = np.linalg.inv(matrices)
faces, opposite = [], []
for k in range(4):
faces.append(tet[:, [i for i in range(4) if i != k]])
opposite.append(tet[:, k])
faces, opposite = np.concatenate(faces), np.concatenate(opposite)
_, idx, counts = np.unique(np.sort(faces, axis=1), axis=0, return_index=True, return_counts=True)
assert np.all(counts <= 2), 'nonmanifold volume face'
idx = idx[counts == 1]; self.faces = faces[idx]; tri = x[self.faces]
n = np.cross(tri[:, 1]-tri[:, 0], tri[:, 2]-tri[:, 0])
wrong = np.einsum('ij,ij->i', n, x[opposite[idx]]-tri[:, 0]) > 0
n[wrong] *= -1; self.normals = n/np.linalg.norm(n, axis=1)[:, None]
self.tri = tri
self.e1, self.e2 = tri[:, 1]-tri[:, 0], tri[:, 2]-tri[:, 0]
# Connected coplanar triangles, not semantic plate/rib labels.
parent = list(range(len(tri)))
def find(i):
while parent[i] != i:
parent[i] = parent[parent[i]]; i = parent[i]
return i
edges = defaultdict(list)
for i, f in enumerate(self.faces):
for a, b in itertools.combinations(f, 2):
edges[tuple(sorted((int(a), int(b))))].append(i)
assert all(len(v) == 2 for v in edges.values()), 'boundary not closed manifold'
for group in edges.values():
a, b = group
if np.dot(self.normals[a], self.normals[b]) > 1-TOL:
parent[find(a)] = find(b)
roots = [find(i) for i in range(len(tri))]
self.patch = np.unique(roots, return_inverse=True)[1]
self.patches = []
for k in range(self.patch.max()+1):
ids = np.flatnonzero(self.patch == k); pts = tri[ids].reshape(-1, 3)
low, high = pts.min(0), pts.max(0); axis = int(np.argmax(abs(self.normals[ids[0]])))
area = np.linalg.norm(np.cross(self.e1[ids], self.e2[ids]), axis=1).sum()/2
lateral = [j for j in range(3) if j != axis]
rectangular = abs(area-np.prod((high-low)[lateral])) <= TOL*max(1, area)
self.patches.append({'axis': axis, 'low': low, 'high': high,
'rectangular': rectangular, 'span': (high-low)[lateral]})
def hit(self, origin, direction):
h = np.cross(np.broadcast_to(direction, self.e2.shape), self.e2)
det = np.einsum('ij,ij->i', self.e1, h)
ok = abs(det) > 1e-12
inv = np.divide(1., det, out=np.zeros_like(det), where=ok)
s = origin-self.tri[:, 0]
u = inv*np.einsum('ij,ij->i', s, h)
q = np.cross(s, self.e1)
v = inv*(q@direction)
distance = inv*np.einsum('ij,ij->i', self.e2, q)
ok &= (u >= -TOL) & (v >= -TOL) & (u+v <= 1+TOL) & (distance > TOL)
ids = np.flatnonzero(ok)
if not len(ids):
return None
d = distance[ids].min(); ties = ids[abs(distance[ids]-d) < TOL]
if len(np.unique(self.patch[ties])) != 1:
return None # A true edge/corner hit has ambiguous normal.
i = int(ties[0]); return origin+d*direction, i
def chord_inside(self, a, b):
# Intersect the line parameter interval with EACH original tetrahedron.
l0 = np.einsum('tij,tj->ti', self.inverse, a-self.p[:, 0])
dl = np.einsum('tij,j->ti', self.inverse, b-a)
l0 = np.column_stack([1-l0.sum(1), l0]); dl = np.column_stack([-dl.sum(1), dl])
lo, hi = np.zeros(len(self.tet)), np.ones(len(self.tet))
valid = np.ones(len(self.tet), dtype=bool)
for j in range(4):
moving = abs(dl[:, j]) > 1e-13
bound = np.divide(-TOL-l0[:, j], dl[:, j], out=np.zeros(len(dl)), where=moving)
lo = np.where(moving & (dl[:, j] > 0), np.maximum(lo, bound), lo)
hi = np.where(moving & (dl[:, j] < 0), np.minimum(hi, bound), hi)
valid &= moving | (l0[:, j] >= -TOL)
valid &= lo <= hi
intervals = sorted(zip(lo[valid], hi[valid])); end = 0.
for left, right in intervals:
if left > end+TOL:
return False
end = max(end, right)
if end >= 1-TOL:
return True
return False
def pair(mesh, anchors, normals, tiles):
records, prisms = [], []
for i, (a, n, tile) in enumerate(zip(anchors, normals, tiles)):
r = {'anchor': i, 'a': a.tolist(), 'normal': n.tolist(), 'paired': False,
'sheet_support': False, 'reason': 'NO_HIT'}
source = mesh.hit(a-OFFSET*n, n); target = mesh.hit(a-OFFSET*n, -n)
if source is None or target is None:
records.append(r); continue
b, face = target; _, src = source
p, q = int(mesh.patch[src]), int(mesh.patch[face]); h = float(np.linalg.norm(b-a))
r.update(b=b.tolist(), thickness=h, patches=[p, q])
reverse = mesh.hit(b-OFFSET*mesh.normals[face], -mesh.normals[face])
if p == q or np.dot(n, mesh.normals[face]) > -ANGLE_COS:
r['reason'] = 'NORMAL_OR_PATCH'
elif reverse is None or np.linalg.norm(reverse[0]-a) > 1e-5:
r['reason'] = 'REVERSE_MISMATCH'
elif not mesh.chord_inside(a, b):
r['reason'] = 'CHORD_OUTSIDE'
else:
r.update(paired=True, reason='PAIRED_ONLY')
pa, pb = mesh.patches[p], mesh.patches[q]
# Deliberately narrow eligibility: rectangular, planar opposed walls,
# thickness <= half the smallest lateral patch extent.
if pa['rectangular'] and pb['rectangular'] and h <= .5*min(*pa['span'], *pb['span'])+TOL:
axis = pa['axis']; low, high = tile.copy(), tile+GRID
low[axis], high[axis] = min(a[axis], b[axis]), max(a[axis], b[axis])
# Entire prism is inside the voxel union, checked separately by
# the caller against complete original-tet cell volumes.
prisms.append({'low': low, 'high': high, 'h': h, 'pair': tuple(sorted((p, q))),
'axis': axis, 'record': i})
r.update(sheet_support=True, reason='SHEET_PRISM_CANDIDATE')
records.append(r)
return records, prisms
def mapping(mesh, prisms, cells, records):
# Certify prism by complete voxel-cell occupancy. Mesh construction has
# independently checked 6 nondegenerate tets/cell and exact cell volumes.
present = set(cells); certified = []
for p in prisms:
lo, hi = np.rint(p['low']/GRID).astype(int), np.rint(p['high']/GRID).astype(int)
aligned = np.max(abs(lo*GRID-p['low'])) < TOL and np.max(abs(hi*GRID-p['high'])) < TOL
valid = aligned and all(tuple(c) in present for c in itertools.product(*(range(a, b) for a, b in zip(lo, hi))))
records[p['record']]['prism_inside'] = bool(valid)
if valid:
certified.append(p)
else:
records[p['record']].update(sheet_support=False, reason='PRISM_OUTSIDE_OR_UNSUPPORTED')
keys = sorted(set(p['pair'] for p in certified)); key_id = {key: i for i, key in enumerate(keys)}
# Candidate at every original node; ties between distinct wall pairs are
# UNKNOWN. A shortest pair needs >=2x separation from each alternative.
candidates = [dict() for _ in mesh.x]
for p in certified:
inside = np.all(mesh.x >= p['low']-TOL, axis=1) & np.all(mesh.x <= p['high']+TOL, axis=1)
for i in np.flatnonzero(inside):
candidates[i][key_id[p['pair']]] = p['h']
node_pair = np.full(len(mesh.x), -1, int)
for i, choices in enumerate(candidates):
ordered = sorted((h, k) for k, h in choices.items())
if ordered and (len(ordered) == 1 or ordered[1][0] >= 2*ordered[0][0]-TOL):
node_pair[i] = ordered[0][1]
tet_pair = np.full(len(mesh.tet), -1, int)
for p in certified:
k = key_id[p['pair']]
inside = np.all(mesh.p >= p['low']-TOL, axis=(1, 2)) & np.all(mesh.p <= p['high']+TOL, axis=(1, 2))
inside &= np.all(node_pair[mesh.tet] == k, axis=1)
tet_pair[inside] = k
# Scalar projection xi is affine on each certified prism; vertex bounds
# imply the entire tet stays in the prism. The count below is exact tet
# volume (to floating point), not node counts or centroid quadrature.
return node_pair, tet_pair, certified, keys
def truth(name, a, n):
axis = int(np.argmax(abs(n)))
if name == 'plate':
return 1. if axis == 2 else None
if name == 'u_gap':
if axis == 0 and a[2] > 1: return 1.
if axis == 2 and 1 < a[0] < 1.5 and a[2] <= 1: return 1.
if name == 't_rib':
if axis == 2 and (a[0] < 3 or a[0] > 5) and a[2] <= 1: return 1.
if axis == 0 and a[2] > 2: return 1.
return None
def hard_cells(name, cells):
c = (np.array(cells)+.5)*GRID
if name == 't_rib': return (c[:, 0] >= 3) & (c[:, 0] <= 5) & (c[:, 2] <= 2)
if name == 'u_gap': return c[:, 2] <= 1
return np.zeros(len(cells), dtype=bool)
def tests():
checks = []
cells = shape('plate'); x, t, owner = make_mesh(cells, 0); m = Mesh(x, t)
assert np.isclose(m.volumes.sum(), 48); checks.append('plate_volume_48')
assert np.allclose(np.bincount(owner, weights=m.volumes), GRID**3); checks.append('each_cell_volume')
assert m.chord_inside(np.array([1., 1., 0.]), np.array([1., 1., 1.])); checks.append('solid_chord')
hit = m.hit(np.array([1.25, 1.25, OFFSET]), np.array([0., 0., 1.]))
assert hit is not None and np.allclose(hit[0], [1.25, 1.25, 1.]); checks.append('first_hit')
xu, tu, _ = make_mesh(shape('u_gap'), 0); mu = Mesh(xu, tu)
assert not mu.chord_inside(np.array([1., 2., 3.]), np.array([1.5, 2., 3.])); checks.append('air_gap_rejected')
x2, t2, _ = make_mesh(cells, 1); m2 = Mesh(x2, t2)
assert len(t2) == len(t) and np.isclose(m2.volumes.sum(), 48); checks.append('second_conforming_mesh')
# Metric evaluator only: construction-defined hard zone is exact per cell.
tc = shape('t_rib'); assert hard_cells('t_rib', tc).sum()*GRID**3 == 16; checks.append('root_volume_16')
return checks
def run(root):
resource.setrlimit(resource.RLIMIT_CPU, (6600, 6600))
root = Path(root); root.mkdir(parents=True, exist_ok=True)
if (root/'science-started.json').exists(): raise FileExistsError('No duplicate probe or retry')
save(root/'science-started.json', {'unix': time.time(), 'pid': __import__('os').getpid(), 'scope': 'synthetic_only_first'})
stages = {}; all_results = []
with timed(stages, 'analytic_harness'):
save(root/'harness.json', {'checks': tests(), 'status': 'PASS'})
for name in ['plate', 'u_gap', 't_rib']:
for variant in [0, 1]:
key = f'{name}-mesh{variant}'; out = root/key; out.mkdir()
timing = {}
with timed(timing, 'geometry_preparation'):
cells = shape(name); x, t, owners = make_mesh(cells, variant)
anchors, normals, tiles = wall_anchors(cells)
with timed(timing, 'adjacency_and_tet_query_setup'):
mesh = Mesh(x, t)
assert np.allclose(np.bincount(owners, weights=mesh.volumes), GRID**3)
np.savez_compressed(out/'mesh.npz', points=x, tets=t, owner_cells=owners, cells=np.array(cells),
anchors=anchors, normals=normals, boundary_faces=mesh.faces)
with timed(timing, 'rays_reverse_and_whole_chord'):
records, prisms = pair(mesh, anchors, normals, tiles)
with timed(timing, 'node_mapping_and_certified_tet_volume'):
node_pair, tet_pair, certified, keys = mapping(mesh, prisms, cells, records)
covered = tet_pair >= 0; hard = hard_cells(name, cells)[owners]
expected = [truth(name, a, n) for a, n in zip(anchors, normals)]
errors = [abs(r['thickness']/h-1) for r, h in zip(records, expected) if h is not None and r['paired']]
false_gap = []
# Independent geometric truth: an accepted segment crossing the U's
# open rectangle x in (1,1.5), z>1 is false, irrespective of tet test.
for r in records:
if name == 'u_gap' and r['paired']:
a, b = np.array(r['a']), np.array(r['b'])
if min(a[0], b[0]) < 1.5-TOL and max(a[0], b[0]) > 1+TOL and min(a[2], b[2]) > 1+TOL:
false_gap.append(r['anchor'])
total = float(mesh.volumes.sum()); hard_volume = float(mesh.volumes[hard].sum())
result = {'shape': name, 'variant': variant, 'nodes': len(x), 'tets': len(t), 'anchors': len(anchors),
'total_boundary_area': len(anchors)*GRID**2, 'paired': sum(r['paired'] for r in records),
'paired_area_fraction': sum(r['paired'] for r in records)/len(records),
'thickness_truth_anchors': sum(h is not None for h in expected), 'thickness_paired_denominator': len(errors),
'thickness_relative_error_median_p95': np.quantile(errors, [.5, .95]).tolist() if errors else None,
'accepted_air_crossing_count': len(false_gap), 'accepted_air_crossing_anchors': false_gap,
'true_volume': total, 'covered_tet_volume': float(mesh.volumes[covered].sum()),
'covered_volume_fraction': float(mesh.volumes[covered].sum()/total),
'hard_zone_volume': hard_volume, 'hard_zone_sheet_volume': float(mesh.volumes[hard & covered].sum()),
'root_misclassified_fraction': float(mesh.volumes[hard & covered].sum()/hard_volume) if name == 't_rib' else None,
'mapped_nodes': int((node_pair >= 0).sum()), 'unknown_nodes': int((node_pair < 0).sum()),
'certified_prisms': len(certified), 'timing': timing,
'volume_measure': 'Sum of whole original-tet volumes; all vertices uniquely mapped to one pair and contained in a certified convex prism. No centroid/node-count quadrature.',
'restriction': 'Axis-aligned, rectangular planar wall patches only; exterior geometry identical, triangulations changed; no perturbed-boundary test.'}
np.savez_compressed(out/'mapping.npz', node_pair=node_pair, tet_pair=tet_pair, tet_volume=mesh.volumes, hard_tet=hard)
save(out/'pairs.json', records)
save(out/'prisms.json', [{'low': p['low'].tolist(), 'high': p['high'].tolist(),
'h': p['h'], 'pair': p['pair'], 'axis': p['axis']} for p in certified])
save(out/'result.json', result); all_results.append(result)
save(root/'progress.json', {'completed_cases': len(all_results), 'results': all_results})
comparisons = []
for name in ['plate', 'u_gap', 't_rib']:
a, b = [r for r in all_results if r['shape'] == name]
ra = json.loads((root/f'{name}-mesh0/pairs.json').read_text()); rb = json.loads((root/f'{name}-mesh1/pairs.json').read_text())
assert [r['a'] for r in ra] == [r['a'] for r in rb]
comparisons.append({'shape': name, 'identical_physical_anchors': True,
'pair_acceptance_disagreements': sum(r['paired'] != s['paired'] for r, s in zip(ra, rb)),
'max_paired_thickness_absolute_difference': max([abs(r['thickness']-s['thickness']) for r, s in zip(ra, rb) if r['paired'] and s['paired']] or [0.]),
'covered_volume_absolute_difference': abs(a['covered_tet_volume']-b['covered_tet_volume'])})
save(root/'complete.json', {'status': 'SYNTHETIC_EXPLORATORY_COMPLETE', 'cases': all_results,
'remesh_comparison': comparisons, 'harness_timing': stages,
'real_parts_attempted': 0, 'real_skip_reason': 'Method eligibility absent: whole-volume certificate currently relies on exact axis-aligned voxel tiling and rectangular planar wall patches; do not silently extrapolate to Greif.',
'training': False, 'labels_read': False, 'new_packages': False})
if __name__ == '__main__':
parser = argparse.ArgumentParser(); parser.add_argument('root'); args = parser.parse_args()
run(args.root)