155 lines
8.6 KiB
Python
155 lines
8.6 KiB
Python
"""Fixed physical support, unchanged hard spectral gap, and explicit regional errors."""
|
|
import argparse
|
|
import itertools
|
|
import json
|
|
from pathlib import Path
|
|
import time
|
|
import numpy as np
|
|
from scipy.spatial import cKDTree
|
|
from scipy.sparse import diags
|
|
if __package__:
|
|
from .projector_remesh_probe import geometry, exact_distance, grouped, coverage
|
|
from .route_feasibility import graph_from_edges, node_tensor
|
|
else:
|
|
from projector_remesh_probe import geometry, exact_distance, grouped, coverage
|
|
from route_feasibility import graph_from_edges, node_tensor
|
|
|
|
|
|
def physical_average(points, tensor, mass, radius, volume_weighted):
|
|
if radius <= 0 or np.any(mass <= 0):
|
|
raise ValueError('Positive radius and quadrature masses required')
|
|
tree = cKDTree(points)
|
|
weights = tree.sparse_distance_matrix(tree, radius, output_type='coo_matrix').tocsr()
|
|
weights.data = np.maximum(1 - (weights.data / radius) ** 2, 0) ** 2
|
|
weights.eliminate_zeros()
|
|
if volume_weighted:
|
|
weights = weights @ diags(mass)
|
|
denominator = np.asarray(weights.sum(axis=1)).ravel()
|
|
weights = diags(1 / denominator) @ weights
|
|
result = (weights @ tensor.reshape(len(points), 9)).reshape(-1, 3, 3)
|
|
effective = 1 / np.asarray(weights.multiply(weights).sum(axis=1)).ravel()
|
|
return result, dict(neighbor_quantiles=np.quantile(np.diff(weights.indptr), [0, .5, .95, 1]).tolist(),
|
|
effective_quadrature_nodes_quantiles=np.quantile(effective, [0, .5, .95, 1]).tolist(),
|
|
singleton_neighborhood_nodes=int(np.sum(np.diff(weights.indptr) == 1)))
|
|
|
|
|
|
def region_labels(x, name, radius, band):
|
|
labels = np.full(len(x), 'interior', dtype='<U16')
|
|
wall = exact_distance(x, name) <= band + 1e-12
|
|
if name in ('square_rod', 'circular_rod'):
|
|
height = 8 if name == 'square_rod' else 4
|
|
wall |= np.minimum(x[:, 2], height - x[:, 2]) <= radius + 1e-12
|
|
labels[wall] = 'wall_end'
|
|
if name == 'T_union':
|
|
junction = (abs(x[:, 0]) <= .75 + 1e-12) & (x[:, 1] >= .25 - 1e-12) & (x[:, 1] <= .75 + 1e-12)
|
|
labels[junction] = 'junction'
|
|
return labels
|
|
|
|
|
|
def statistics(values):
|
|
if not len(values):
|
|
return dict(count=0, maximum=None, p50=None, p90=None, p95=None, p99=None)
|
|
return dict(count=len(values), maximum=float(np.max(values)),
|
|
**{f'p{q}': float(np.percentile(values, q)) for q in [50, 90, 95, 99]})
|
|
|
|
|
|
def compare(t1, t2, positions, mask, tau):
|
|
a, b = grouped(t1, tau), grouped(t2, tau)
|
|
different = a['code'] != b['code']
|
|
same = mask & ~different & (a['code'] >= 0)
|
|
errors = np.linalg.norm(a['projector'] - b['projector'], axis=(2, 3)).max(1)
|
|
rows = {}
|
|
for code, name in [(0, 'isotropic'), (1, 'normal_plus_plane'), (2, 'plane_plus_axis'), (3, 'three_singletons')]:
|
|
select = same & (a['code'] == code)
|
|
rows[name] = statistics(errors[select])
|
|
ids = np.flatnonzero(same)
|
|
worst = ids[np.argsort(errors[ids])[-3:]]
|
|
return dict(queries=int(mask.sum()), pattern_mismatch_fraction=float(different[mask].mean()) if mask.any() else None,
|
|
pattern_counts_A={str(c): int(np.sum(mask & (a['code'] == c))) for c in [-1, 0, 1, 2, 3]},
|
|
pattern_counts_B={str(c): int(np.sum(mask & (b['code'] == c))) for c in [-1, 0, 1, 2, 3]},
|
|
same_pattern_projector=statistics(errors[same]), by_pattern=rows,
|
|
directional_two_group_projector=statistics(errors[same & np.isin(a['code'], [1, 2])]),
|
|
sorted_normalized_eigenvalue_error=statistics(abs(a['ratios'] - b['ratios']).max(1)[mask]),
|
|
worst_same_pattern_positions=positions[worst].tolist(),
|
|
first_mismatch_positions=positions[np.flatnonzero(mask & different)[:5]].tolist())
|
|
|
|
|
|
def build(x, tet, name):
|
|
q = x[tet]
|
|
volume = abs(np.linalg.det(q[:, 1:] - q[:, :1])) / 6
|
|
assert np.all(volume > 0)
|
|
mass = np.bincount(tet.ravel(), weights=np.repeat(volume / 4, 4), minlength=len(x))
|
|
edgeids = np.array(list(itertools.combinations(range(4), 2)))
|
|
edges = np.unique(np.sort(tet[:, edgeids].reshape(-1, 2), axis=1), axis=0)
|
|
graph = graph_from_edges(len(x), edges)
|
|
raw, average, meta = node_tensor(x, tet, mass, exact_distance(x, name), graph, steps=0)
|
|
baseline = raw.reshape(-1, 9)
|
|
for _ in range(3):
|
|
baseline = average @ baseline
|
|
return raw, baseline.reshape(-1, 3, 3), mass, float(volume.sum()), meta
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('output', type=Path)
|
|
out = parser.parse_args().output
|
|
target = out / 'physical_support_results.json'
|
|
if target.exists():
|
|
raise FileExistsError(target)
|
|
contract = json.loads((out / 'execution_contract.json').read_text())['O2']
|
|
old = json.loads(Path('artifacts/capacity-projectors-2026-11-13/group_breakdown/remesh_projectors.json').read_text())
|
|
old_rows = {(r['shape'], r['resolution']): r for r in old['rows']}
|
|
rows = []
|
|
started = time.monotonic()
|
|
for name, levels in contract['levels'].items():
|
|
radius, band = contract['radii'][name], contract['wall_band'][name]
|
|
for level 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, level, variant)
|
|
raw, baseline, mass, volume, meta = build(x, tet, name)
|
|
arms = {'archived_three_hop_mass': baseline}
|
|
support = {}
|
|
for key, weighted in [('physical_radius_equal_nodes', False), ('physical_radius_lumped_volume', True)]:
|
|
arms[key], support[key] = physical_average(x, raw, mass, radius, weighted)
|
|
meshes.append(dict(x=x, mass=mass, volume=volume, arms=arms, support=support,
|
|
region=region_labels(x, name, radius, band), removed=removed, meta=meta))
|
|
a, b = meshes
|
|
distances, index = cKDTree(b['x']).query(a['x'])
|
|
assert np.max(distances) < 1e-10
|
|
assert np.isclose(a['volume'], b['volume'], rtol=1e-10)
|
|
assert np.array_equal(a['region'], b['region'][index])
|
|
row = dict(shape=name, resolution=level, radius=radius, region_wall_band=band, variants=variants,
|
|
volumes=[a['volume'], b['volume']], nodes=[len(a['x']), len(b['x'])],
|
|
removed_degenerate_tets=[a['removed'], b['removed']], initial_estimator=[a['meta'], b['meta']],
|
|
quadrature_support=[a['support'], b['support']], arms={})
|
|
arrays = dict(query=a['x'], mass_A=a['mass'], mass_B_at_shared=b['mass'][index], region=a['region'])
|
|
for arm in contract['arms']:
|
|
ta, tb = a['arms'][arm], b['arms'][arm]
|
|
regions = {}
|
|
for region in ['all', 'interior', 'wall_end', 'junction']:
|
|
mask = np.ones(len(a['x']), bool) if region == 'all' else a['region'] == region
|
|
regions[region] = compare(ta, tb[index], a['x'], mask, contract['gap_threshold'])
|
|
for tag, mesh in [('A', a), ('B', b)]:
|
|
rm = np.ones(len(mesh['x']), bool) if region == 'all' else mesh['region'] == region
|
|
regions[region]['coverage_' + tag] = coverage(grouped(mesh['arms'][arm][rm], .1), mesh['mass'][rm]) if rm.any() else None
|
|
regions[region]['volume_fraction_' + tag] = float(mesh['mass'][rm].sum() / mesh['mass'].sum())
|
|
row['arms'][arm] = regions
|
|
arrays[arm + '_tensor_A'] = ta
|
|
arrays[arm + '_tensor_B_common'] = tb[index]
|
|
baseline = row['arms']['archived_three_hop_mass']['all']
|
|
reference = old_rows[(name, level)]['thresholds']['0.1']
|
|
assert np.isclose(baseline['pattern_mismatch_fraction'], reference['pattern_mismatch_query_fraction'])
|
|
assert np.isclose(baseline['same_pattern_projector']['maximum'], reference['projector_frobenius_max'])
|
|
row['archived_baseline_reproduced'] = True
|
|
np.savez_compressed(out / f'{name}_{level}_paired_fields.npz', **arrays)
|
|
rows.append(row)
|
|
print(name, level, {arm: round(row['arms'][arm]['all']['pattern_mismatch_fraction'], 4) for arm in contract['arms']}, flush=True)
|
|
target.write_text(json.dumps(dict(contract=contract, rows=rows, wall_seconds=time.monotonic()-started,
|
|
acceptance='NOT_ESTABLISHED; no frozen projector thresholds or radius selection'), indent=2, allow_nan=False)+'\n')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|