"""Synthetic acceptance for the fixed O1 geometry intervention; no real data.""" import itertools import unittest import numpy as np from scipy.spatial.distance import pdist from o1_partition import (Metis, canonical_mesh, graph, canonical_labels, quantize, partition_metrics, match, diameter, shuffle_type, readout, objective, interface_difference, common_roster, can_reserve, GeometryFailure, InputViolation) def box(nx=8, ny=4, nz=4): points = np.array(list(itertools.product(range(nx+1), range(ny+1), range(nz+1))), dtype=float) lookup = {tuple(p): i for i, p in enumerate(points)} tets = [] for low in itertools.product(range(nx), range(ny), range(nz)): for perm in itertools.permutations(range(3)): p = np.array(low); cell = [lookup[tuple(p)]] for axis in perm: p = p.copy(); p[axis] += 1; cell.append(lookup[tuple(p)]) tets.append(cell) return points, np.array(tets), np.arange(len(points))*3+11, np.arange(len(tets))*7+5 class O1Acceptance(unittest.TestCase): @classmethod def setUpClass(cls): cls.source = box(); cls.mesh = canonical_mesh(*cls.source) cls.g = graph(cls.mesh); cls.engine = Metis() cls.labels, cls.call = cls.engine.partition(cls.g, cls.mesh['raw_cells'], 0) def test_same_seed_same_input_twice_exact(self): again, receipt = self.engine.partition(self.g, self.mesh['raw_cells'], 0) np.testing.assert_array_equal(self.labels, again) self.assertEqual(self.call, receipt) def test_fixed_ufactor_and_physical_volume_reachable(self): self.assertEqual(self.call['options'][16], 50) self.assertEqual(self.call['options'][11], 1) m = partition_metrics(self.mesh, self.g, self.labels) self.assertGreaterEqual(min(m['fractions']), .95/8) self.assertLessEqual(max(m['fractions']), 1.05/8) self.assertEqual(len(m['diameters']), 8) def test_csr_and_raw_identity_ignore_traversal_order(self): x, t, rn, rc = self.source rng = np.random.default_rng(31) no, co = rng.permutation(len(x)), rng.permutation(len(t)) inverse = np.empty(len(x), dtype=int); inverse[no] = np.arange(len(x)) moved = canonical_mesh(x[no], inverse[t[co, ::-1]], rn[no], rc[co]) changed = graph(moved) for key in ['points', 'tets', 'raw_nodes', 'raw_cells', 'volume']: np.testing.assert_array_equal(self.mesh[key], moved[key]) for key in ['xadj', 'adjncy', 'vwgt', 'adjwgt', 'edges', 'area', 'faces_raw']: np.testing.assert_array_equal(self.g[key], changed[key]) labels, _ = self.engine.partition(changed, moved['raw_cells'], 0) np.testing.assert_array_equal(self.labels, labels) def test_numbering_invariance_and_interface_identity(self): relabeled = np.array([4, 6, 0, 7, 1, 3, 2, 5])[self.labels] np.testing.assert_array_equal(canonical_labels(relabeled, self.mesh['raw_cells']), self.labels) self.assertEqual(interface_difference(self.labels, relabeled, self.g)['value'], 0) b = self.mesh['points'][self.mesh['tets']].mean(axis=1)[:, :2] a = readout(self.mesh['tets'], self.mesh['volume'], b, self.labels, len(self.mesh['points'])) c = readout(self.mesh['tets'], self.mesh['volume'], b, relabeled, len(self.mesh['points'])) np.testing.assert_array_equal(a, c) def test_boundary_blending_matches_independent_sums(self): t, v, labels = self.mesh['tets'], self.mesh['volume'], self.labels b = np.column_stack((np.arange(len(t))*.01, np.arange(len(t))*.02)) out = readout(t, v, b, labels, len(self.mesh['points'])) for node in [0, 34, 100, len(out)-1]: incident = np.flatnonzero(np.any(t == node, axis=1)); expected = np.zeros(2) for k in incident: r = np.flatnonzero(labels == labels[k]) expected += v[k]*np.average(b[r], weights=v[r], axis=0) expected /= v[incident].sum() np.testing.assert_allclose(out[node], expected, rtol=1e-14, atol=1e-14) def test_quantization_positive_bounded_and_invalid_rejected(self): a = np.array([1e-20, 1., 20.]); w, e = quantize(a) self.assertGreater(w.min(), 0); self.assertLessEqual(int(w.astype(np.int64).sum()), 2*2**26) self.assertGreaterEqual(e['L1'], 0) with self.assertRaises(GeometryFailure): quantize(np.array([0., 1.])) def test_exact_diameter_not_bounding_box(self): points = np.array([[0,0,0],[1,0,0],[0,1,0],[0,0,1],[.1,.1,.1]], dtype=float) d, n = diameter(points, block=2) self.assertEqual(d, float(pdist(points).max())) self.assertNotEqual(d, np.sqrt(3)); self.assertEqual(n, 4) def test_whole_triples_shuffle_only_within_volume_strata(self): n = 103; z = np.arange(n*3).reshape(n, 3); volume = np.repeat(np.arange(11)+1, 10)[:n] raw = np.arange(n)[::-1] a, perm = shuffle_type(z, volume, raw, 3) b, p2 = shuffle_type(z, volume, raw, 3) np.testing.assert_array_equal(a, z[perm]); np.testing.assert_array_equal(a, b) np.testing.assert_array_equal(perm, p2) for ids in np.array_split(np.lexsort((raw, volume)), 10): self.assertEqual(set(ids), set(perm[ids])) with self.assertRaises(InputViolation): shuffle_type(z, volume, raw, '3') def test_true_constant_field_objective_and_readout(self): z = np.ones((len(self.labels), 3))*.125 self.assertAlmostEqual(objective(z, self.mesh['volume'], self.labels), 0., places=25) out = readout(self.mesh['tets'], self.mesh['volume'], z, self.labels, len(self.mesh['points'])) np.testing.assert_allclose(out, .125, atol=1e-15) def test_physical_and_pair_matching_hard_limits(self): m = dict(fractions=[.125]*8, cut_area=10., diameters=[2.]*8) self.assertTrue(match(m, m)['passed']) self.assertFalse(match(dict(m, cut_area=10.51), m)['passed']) self.assertFalse(match(dict(m, diameters=[2.101]*8), m)['passed']) self.assertFalse(match(dict(m, fractions=[.12]*8), m)['passed']) a, b = dict(m, cut_area=10.49), dict(m, cut_area=9.51) self.assertTrue(match(a, m)['passed']); self.assertTrue(match(b, m)['passed']) self.assertFalse(match(a, b, mutual=True)['passed']) def test_multicomponent_and_duplicate_tets_fail(self): x, t, rn, rc = self.source with self.assertRaises(GeometryFailure): canonical_mesh(x, np.vstack([t, t[:1]]), rn, np.r_[rc, rc.max()+1]) x2 = np.vstack([x, x+100]); t2 = np.vstack([t, t+len(x)]) with self.assertRaisesRegex(GeometryFailure, 'MULTICOMPONENT_SCOPE'): graph(canonical_mesh(x2, t2, np.arange(len(x2)), np.arange(len(t2)))) def test_full_component_intersection_and_budget_reservation(self): parts = [{'case':'a','component_id':'X'},{'case':'b','component_id':'X'},{'case':'c','component_id':'Y'}] rows, excluded = common_roster(parts, {'a':{'status':'PASS'},'b':{'status':'FAIL'},'c':{'status':'PASS'}}) self.assertEqual(rows, parts[2:]); self.assertEqual(excluded, ['X']) self.assertTrue(can_reserve(36000, 3)); self.assertFalse(can_reserve(36000.1, 3)) self.assertFalse(can_reserve(float('nan'), 0)) if __name__ == '__main__': unittest.main(verbosity=2)